The Tor Browser: comparison content/base/src/TreeWalker.cpp

--1:000000000000
+:6ee4ac0c2450
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set ts=4 et sw=4 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+/*
+* Implementation of DOM Traversal's nsIDOMTreeWalker
+*/
+#include "mozilla/dom/TreeWalker.h"
+#include "nsIContent.h"
+#include "nsIDOMNode.h"
+#include "nsError.h"
+#include "nsINode.h"
+#include "nsContentUtils.h"
+#include "mozilla/dom/TreeWalkerBinding.h"
+namespace mozilla {
+namespace dom {
+/*
+* Factories, constructors and destructors
+*/
+TreeWalker::TreeWalker(nsINode *aRoot,
+uint32_t aWhatToShow,
+const NodeFilterHolder &aFilter) :
+nsTraversal(aRoot, aWhatToShow, aFilter),
+mCurrentNode(aRoot)
+{
+}
+TreeWalker::~TreeWalker()
+{
+/* destructor code */
+}
+/*
+* nsISupports and cycle collection stuff
+*/
+NS_IMPL_CYCLE_COLLECTION(TreeWalker, mFilter, mCurrentNode, mRoot)
+// QueryInterface implementation for TreeWalker
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TreeWalker)
+NS_INTERFACE_MAP_ENTRY(nsIDOMTreeWalker)
+NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMTreeWalker)
+NS_INTERFACE_MAP_END
+// Have to pass in dom::TreeWalker because a11y has an a11y::TreeWalker that
+// passes TreeWalker so refcount logging would get confused on the name
+// collision.
+NS_IMPL_CYCLE_COLLECTING_ADDREF(dom::TreeWalker)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(dom::TreeWalker)
+/*
+* nsIDOMTreeWalker Getters/Setters
+*/
+/* readonly attribute nsIDOMNode root; */
+NS_IMETHODIMP TreeWalker::GetRoot(nsIDOMNode * *aRoot)
+{
+NS_ADDREF(*aRoot = Root()->AsDOMNode());
+return NS_OK;
+}
+/* readonly attribute unsigned long whatToShow; */
+NS_IMETHODIMP TreeWalker::GetWhatToShow(uint32_t *aWhatToShow)
+{
+*aWhatToShow = WhatToShow();
+return NS_OK;
+}
+/* readonly attribute nsIDOMNodeFilter filter; */
+NS_IMETHODIMP TreeWalker::GetFilter(nsIDOMNodeFilter * *aFilter)
+{
+NS_ENSURE_ARG_POINTER(aFilter);
+*aFilter = mFilter.ToXPCOMCallback().take();
+return NS_OK;
+}
+/* attribute nsIDOMNode currentNode; */
+NS_IMETHODIMP TreeWalker::GetCurrentNode(nsIDOMNode * *aCurrentNode)
+{
+if (mCurrentNode) {
+return CallQueryInterface(mCurrentNode, aCurrentNode);
+}
+*aCurrentNode = nullptr;
+return NS_OK;
+}
+NS_IMETHODIMP TreeWalker::SetCurrentNode(nsIDOMNode * aCurrentNode)
+{
+NS_ENSURE_TRUE(aCurrentNode, NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+NS_ENSURE_TRUE(mRoot, NS_ERROR_UNEXPECTED);
+nsCOMPtr<nsINode> node = do_QueryInterface(aCurrentNode);
+NS_ENSURE_TRUE(node, NS_ERROR_UNEXPECTED);
+ErrorResult rv;
+SetCurrentNode(*node, rv);
+return rv.ErrorCode();
+}
+void
+TreeWalker::SetCurrentNode(nsINode& aNode, ErrorResult& aResult)
+{
+aResult = nsContentUtils::CheckSameOrigin(mRoot, &aNode);
+if (aResult.Failed()) {
+return;
+}
+mCurrentNode = &aNode;
+}
+/*
+* nsIDOMTreeWalker functions
+*/
+/* nsIDOMNode parentNode (); */
+NS_IMETHODIMP TreeWalker::ParentNode(nsIDOMNode **_retval)
+{
+return ImplNodeGetter(&TreeWalker::ParentNode, _retval);
+}
+already_AddRefed<nsINode>
+TreeWalker::ParentNode(ErrorResult& aResult)
+{
+nsCOMPtr<nsINode> node = mCurrentNode;
+while (node && node != mRoot) {
+node = node->GetParentNode();
+if (node) {
+int16_t filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
+mCurrentNode = node;
+return node.forget();
+}
+}
+}
+return nullptr;
+}
+/* nsIDOMNode firstChild (); */
+NS_IMETHODIMP TreeWalker::FirstChild(nsIDOMNode **_retval)
+{
+return ImplNodeGetter(&TreeWalker::FirstChild, _retval);
+}
+already_AddRefed<nsINode>
+TreeWalker::FirstChild(ErrorResult& aResult)
+{
+return FirstChildInternal(false, aResult);
+}
+/* nsIDOMNode lastChild (); */
+NS_IMETHODIMP TreeWalker::LastChild(nsIDOMNode **_retval)
+{
+return ImplNodeGetter(&TreeWalker::LastChild, _retval);
+}
+already_AddRefed<nsINode>
+TreeWalker::LastChild(ErrorResult& aResult)
+{
+return FirstChildInternal(true, aResult);
+}
+/* nsIDOMNode previousSibling (); */
+NS_IMETHODIMP TreeWalker::PreviousSibling(nsIDOMNode **_retval)
+{
+return ImplNodeGetter(&TreeWalker::PreviousSibling, _retval);
+}
+already_AddRefed<nsINode>
+TreeWalker::PreviousSibling(ErrorResult& aResult)
+{
+return NextSiblingInternal(true, aResult);
+}
+/* nsIDOMNode nextSibling (); */
+NS_IMETHODIMP TreeWalker::NextSibling(nsIDOMNode **_retval)
+{
+return ImplNodeGetter(&TreeWalker::NextSibling, _retval);
+}
+already_AddRefed<nsINode>
+TreeWalker::NextSibling(ErrorResult& aResult)
+{
+return NextSiblingInternal(false, aResult);
+}
+/* nsIDOMNode previousNode (); */
+NS_IMETHODIMP TreeWalker::PreviousNode(nsIDOMNode **_retval)
+{
+return ImplNodeGetter(&TreeWalker::PreviousNode, _retval);
+}
+already_AddRefed<nsINode>
+TreeWalker::PreviousNode(ErrorResult& aResult)
+{
+nsCOMPtr<nsINode> node = mCurrentNode;
+while (node != mRoot) {
+while (nsINode *previousSibling = node->GetPreviousSibling()) {
+node = previousSibling;
+int16_t filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+nsINode *lastChild;
+while (filtered != nsIDOMNodeFilter::FILTER_REJECT &&
+(lastChild = node->GetLastChild())) {
+node = lastChild;
+filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+}
+if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
+mCurrentNode = node;
+return node.forget();
+}
+}
+if (node == mRoot) {
+break;
+}
+node = node->GetParentNode();
+if (!node) {
+break;
+}
+int16_t filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
+mCurrentNode = node;
+return node.forget();
+}
+}
+return nullptr;
+}
+/* nsIDOMNode nextNode (); */
+NS_IMETHODIMP TreeWalker::NextNode(nsIDOMNode **_retval)
+{
+return ImplNodeGetter(&TreeWalker::NextNode, _retval);
+}
+already_AddRefed<nsINode>
+TreeWalker::NextNode(ErrorResult& aResult)
+{
+int16_t filtered = nsIDOMNodeFilter::FILTER_ACCEPT; // pre-init for inner loop
+nsCOMPtr<nsINode> node = mCurrentNode;
+while (1) {
+nsINode *firstChild;
+while (filtered != nsIDOMNodeFilter::FILTER_REJECT &&
+(firstChild = node->GetFirstChild())) {
+node = firstChild;
+filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+if (filtered ==  nsIDOMNodeFilter::FILTER_ACCEPT) {
+// Node found
+mCurrentNode = node;
+return node.forget();
+}
+}
+nsINode *sibling = nullptr;
+nsINode *temp = node;
+do {
+if (temp == mRoot)
+break;
+sibling = temp->GetNextSibling();
+if (sibling)
+break;
+temp = temp->GetParentNode();
+} while (temp);
+if (!sibling)
+break;
+node = sibling;
+// Found a sibling. Either ours or ancestor's
+filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+if (filtered ==  nsIDOMNodeFilter::FILTER_ACCEPT) {
+// Node found
+mCurrentNode = node;
+return node.forget();
+}
+}
+return nullptr;
+}
+/*
+* TreeWalker helper functions
+*/
+/*
+* Implements FirstChild and LastChild which only vary in which direction
+* they search.
+* @param aReversed Controls whether we search forwards or backwards
+* @param aResult   Whether we threw or not.
+* @returns         The desired node. Null if no child is found
+*/
+already_AddRefed<nsINode>
+TreeWalker::FirstChildInternal(bool aReversed, ErrorResult& aResult)
+{
+nsCOMPtr<nsINode> node = aReversed ? mCurrentNode->GetLastChild()
+: mCurrentNode->GetFirstChild();
+while (node) {
+int16_t filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+switch (filtered) {
+case nsIDOMNodeFilter::FILTER_ACCEPT:
+// Node found
+mCurrentNode = node;
+return node.forget();
+case nsIDOMNodeFilter::FILTER_SKIP: {
+nsINode *child = aReversed ? node->GetLastChild()
+: node->GetFirstChild();
+if (child) {
+node = child;
+continue;
+}
+break;
+}
+case nsIDOMNodeFilter::FILTER_REJECT:
+// Keep searching
+break;
+}
+do {
+nsINode *sibling = aReversed ? node->GetPreviousSibling()
+: node->GetNextSibling();
+if (sibling) {
+node = sibling;
+break;
+}
+nsINode *parent = node->GetParentNode();
+if (!parent || parent == mRoot || parent == mCurrentNode) {
+return nullptr;
+}
+node = parent;
+} while (node);
+}
+return nullptr;
+}
+/*
+* Implements NextSibling and PreviousSibling which only vary in which
+* direction they search.
+* @param aReversed Controls whether we search forwards or backwards
+* @param aResult   Whether we threw or not.
+* @returns         The desired node. Null if no child is found
+*/
+already_AddRefed<nsINode>
+TreeWalker::NextSiblingInternal(bool aReversed, ErrorResult& aResult)
+{
+nsCOMPtr<nsINode> node = mCurrentNode;
+if (node == mRoot) {
+return nullptr;
+}
+while (1) {
+nsINode* sibling = aReversed ? node->GetPreviousSibling()
+: node->GetNextSibling();
+while (sibling) {
+node = sibling;
+int16_t filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
+// Node found
+mCurrentNode = node;
+return node.forget();
+}
+// If rejected or no children, try a sibling
+if (filtered == nsIDOMNodeFilter::FILTER_REJECT ||
+!(sibling = aReversed ? node->GetLastChild()
+: node->GetFirstChild())) {
+sibling = aReversed ? node->GetPreviousSibling()
+: node->GetNextSibling();
+}
+}
+node = node->GetParentNode();
+if (!node || node == mRoot) {
+return nullptr;
+}
+// Is parent transparent in filtered view?
+int16_t filtered = TestNode(node, aResult);
+if (aResult.Failed()) {
+return nullptr;
+}
+if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
+return nullptr;
+}
+}
+}
+JSObject*
+TreeWalker::WrapObject(JSContext *cx)
+{
+return TreeWalkerBinding::Wrap(cx, this);
+}
+} // namespace dom
+} // namespace mozilla

The Tor Browser / file comparison

comparison: content/base/src/TreeWalker.cpp

content/base/src/TreeWalker.cpp