Make DOM.getChildNodes & DOM.getDocument optionally pierce iframe boundaries

third_party/WebKit/Source/core/inspector/InspectorDOMAgent.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 500 matching lines @@
   setSearchingForNode(errorString, NotSearching,
                       Maybe<protocol::DOM::HighlightConfig>());
   m_instrumentingAgents->removeInspectorDOMAgent(this);
   m_history.clear();
   m_domEditor.clear();
   setDocument(nullptr);
 }
 
 void InspectorDOMAgent::getDocument(
     ErrorString* errorString,
+    const Maybe<int>& depth,
+    const Maybe<bool>& traverseFrames,
     std::unique_ptr<protocol::DOM::Node>* root) {
   // Backward compatibility. Mark agent as enabled when it requests document.
   if (!enabled())
     innerEnable();
 
   if (!m_document) {
     *errorString = "Document is not available";
     return;
   }
 
   discardFrontendBindings();
 
-  *root = buildObjectForNode(m_document.get(), 2, m_documentNodeToIdMap.get());
+  int sanitizedDepth = depth.fromMaybe(2);
+  if (sanitizedDepth == -1)
+    sanitizedDepth = INT_MAX;
+
+  *root = buildObjectForNode(m_document.get(), sanitizedDepth,
+                             traverseFrames.fromMaybe(false),
+                             m_documentNodeToIdMap.get());
 }
 
 void InspectorDOMAgent::getLayoutTreeNodes(
     ErrorString* errorString,
     std::unique_ptr<protocol::Array<protocol::DOM::LayoutTreeNode>>*
         layoutTreeNodes) {
   layoutTreeNodes->reset(new protocol::Array<protocol::DOM::LayoutTreeNode>);
   visitLayoutTreeNodes(m_document.get(), *layoutTreeNodes->get());
 }
 
@@ skipping 53 matching lines @@
                                        .build());
         }
         layoutTreeNode->setInlineTextNodes(std::move(inlineTextNodes));
       }
     }
 
     layoutTreeNodes.addItem(std::move(layoutTreeNode));
   }
 }
 
-void InspectorDOMAgent::pushChildNodesToFrontend(int nodeId, int depth) {
+void InspectorDOMAgent::pushChildNodesToFrontend(int nodeId,
+                                                 int depth,
+                                                 bool traverseFrames) {
   Node* node = nodeForId(nodeId);
   if (!node || (!node->isElementNode() && !node->isDocumentNode() &&
                 !node->isDocumentFragment()))
     return;
 
   NodeToIdMap* nodeMap = m_idToNodesMap.get(nodeId);
 
   if (m_childrenRequested.contains(nodeId)) {
     if (depth <= 1)
       return;
 
     depth--;
 
     for (node = innerFirstChild(node); node; node = innerNextSibling(node)) {
       int childNodeId = nodeMap->get(node);
       ASSERT(childNodeId);
-      pushChildNodesToFrontend(childNodeId, depth);
+      pushChildNodesToFrontend(childNodeId, depth, traverseFrames);
     }
 
     return;
   }
 
   std::unique_ptr<protocol::Array<protocol::DOM::Node>> children =
-      buildArrayForContainerChildren(node, depth, nodeMap);
+      buildArrayForContainerChildren(node, depth, traverseFrames, nodeMap);
   frontend()->setChildNodes(nodeId, std::move(children));
 }
 
 void InspectorDOMAgent::discardFrontendBindings() {
   if (m_history)
     m_history->reset();
   m_searchResults.clear();
   m_documentNodeToIdMap->clear();
   m_idToNode.clear();
   m_idToNodesMap.clear();
@@ skipping 36 matching lines @@
         continue;
       const SpaceSplitString& classNameList = element.classNames();
       for (unsigned i = 0; i < classNameList.size(); ++i)
         uniqueNames.add(classNameList[i]);
     }
   }
   for (const String& className : uniqueNames)
     (*classNames)->addItem(className);
 }
 
-void InspectorDOMAgent::requestChildNodes(ErrorString* errorString,
-                                          int nodeId,
-                                          const Maybe<int>& depth) {
+void InspectorDOMAgent::requestChildNodes(
+    ErrorString* errorString,
+    int nodeId,
+    const Maybe<int>& depth,
+    const Maybe<bool>& maybeTaverseFrames) {
   int sanitizedDepth = depth.fromMaybe(1);
   if (sanitizedDepth == 0 || sanitizedDepth < -1) {
     *errorString =
         "Please provide a positive integer as a depth or -1 for entire subtree";
     return;
   }
   if (sanitizedDepth == -1)
     sanitizedDepth = INT_MAX;
 
-  pushChildNodesToFrontend(nodeId, sanitizedDepth);
+  bool traverseFrames = maybeTaverseFrames.fromMaybe(false);
+  // Cached results may not be valid if |traverseFrames| is true.

[pfeldman, 2016/10/12 18:45:26]

childrenRequested is about children only, frames hierarchy is orthogonal. You
requested children here, the bit gets set.

[alex clarke (OOO till 29th), 2016/10/13 15:31:05]

OK we can remove this.  You need to be careful when calling DOM.getDocument and
DOM.requestChildNodes because the traverseFrames flag must match or you won't
necessarily get the nodes you expected.  Thinking about it - it's probably OK
you need the traverseFrames flag to match.

+  if (traverseFrames)
+    m_childrenRequested.clear();
+
+  pushChildNodesToFrontend(nodeId, sanitizedDepth, traverseFrames);
 }
 
 void InspectorDOMAgent::querySelector(ErrorString* errorString,
                                       int nodeId,
                                       const String& selectors,
                                       int* elementId) {
   *elementId = 0;
   Node* node = assertNode(errorString, nodeId);
   if (!node || !node->isContainerNode())
     return;
@@ skipping 79 matching lines @@
   Node* node = nodeToPush;
   while (Node* parent = innerParentNode(node))
     node = parent;
 
   // Node being pushed is detached -> push subtree root.
   NodeToIdMap* newMap = new NodeToIdMap;
   NodeToIdMap* danglingMap = newMap;
   m_danglingNodeToIdMaps.append(newMap);
   std::unique_ptr<protocol::Array<protocol::DOM::Node>> children =
       protocol::Array<protocol::DOM::Node>::create();
-  children->addItem(buildObjectForNode(node, 0, danglingMap));
+  children->addItem(buildObjectForNode(node, 0, false, danglingMap));
   frontend()->setChildNodes(0, std::move(children));
 
   return pushNodePathToFrontend(nodeToPush, danglingMap);
 }
 
 int InspectorDOMAgent::boundNodeId(Node* node) {
   return m_documentNodeToIdMap->get(node);
 }
 
 void InspectorDOMAgent::setAttributeValue(ErrorString* errorString,
@@ skipping 828 matching lines @@
     case ShadowRootType::Closed:
       return protocol::DOM::ShadowRootTypeEnum::Closed;
   }
   ASSERT_NOT_REACHED();
   return protocol::DOM::ShadowRootTypeEnum::UserAgent;
 }
 
 std::unique_ptr<protocol::DOM::Node> InspectorDOMAgent::buildObjectForNode(
     Node* node,
     int depth,
+    bool traverseFrames,
     NodeToIdMap* nodesMap) {
   int id = bind(node, nodesMap);
   String localName;
   String nodeValue;
 
   switch (node->getNodeType()) {
     case Node::kTextNode:
     case Node::kCommentNode:
     case Node::kCdataSectionNode:
       nodeValue = node->nodeValue();
@@ skipping 24 matching lines @@
     Element* element = toElement(node);
     value->setAttributes(buildArrayForElementAttributes(element));
 
     if (node->isFrameOwnerElement()) {
       HTMLFrameOwnerElement* frameOwner = toHTMLFrameOwnerElement(node);
       if (LocalFrame* frame = frameOwner->contentFrame() &&
                                       frameOwner->contentFrame()->isLocalFrame()
                                   ? toLocalFrame(frameOwner->contentFrame())
                                   : nullptr)
         value->setFrameId(IdentifiersFactory::frameId(frame));
-      if (Document* doc = frameOwner->contentDocument())
-        value->setContentDocument(buildObjectForNode(doc, 0, nodesMap));
+      if (Document* doc = frameOwner->contentDocument()) {
+        value->setContentDocument(buildObjectForNode(
+            doc, traverseFrames ? depth : 0, traverseFrames, nodesMap));
+      }
     }
 
     if (node->parentNode() && node->parentNode()->isDocumentNode()) {
       LocalFrame* frame = node->document().frame();
       if (frame)
         value->setFrameId(IdentifiersFactory::frameId(frame));
     }
 
     ElementShadow* shadow = element->shadow();
     if (shadow) {
       std::unique_ptr<protocol::Array<protocol::DOM::Node>> shadowRoots =
           protocol::Array<protocol::DOM::Node>::create();
       for (ShadowRoot* root = &shadow->youngestShadowRoot(); root;
-           root = root->olderShadowRoot())
-        shadowRoots->addItem(buildObjectForNode(root, 0, nodesMap));
+           root = root->olderShadowRoot()) {
+        shadowRoots->addItem(
+            buildObjectForNode(root, 0, traverseFrames, nodesMap));
+      }
       value->setShadowRoots(std::move(shadowRoots));
       forcePushChildren = true;
     }
 
     if (isHTMLLinkElement(*element)) {
       HTMLLinkElement& linkElement = toHTMLLinkElement(*element);
       if (linkElement.isImport() && linkElement.import() &&
-          innerParentNode(linkElement.import()) == linkElement)
-        value->setImportedDocument(
-            buildObjectForNode(linkElement.import(), 0, nodesMap));
+          innerParentNode(linkElement.import()) == linkElement) {
+        value->setImportedDocument(buildObjectForNode(
+            linkElement.import(), 0, traverseFrames, nodesMap));
+      }
       forcePushChildren = true;
     }
 
     if (isHTMLTemplateElement(*element)) {
-      value->setTemplateContent(buildObjectForNode(
-          toHTMLTemplateElement(*element).content(), 0, nodesMap));
+      value->setTemplateContent(
+          buildObjectForNode(toHTMLTemplateElement(*element).content(), 0,
+                             traverseFrames, nodesMap));
       forcePushChildren = true;
     }
 
     if (element->getPseudoId()) {
       protocol::DOM::PseudoType pseudoType;
       if (InspectorDOMAgent::getPseudoElementType(element->getPseudoId(),
                                                   &pseudoType))
         value->setPseudoType(pseudoType);
     } else {
       std::unique_ptr<protocol::Array<protocol::DOM::Node>> pseudoElements =
@@ skipping 34 matching lines @@
   }
 
   if (node->isContainerNode()) {
     int nodeCount = innerChildNodeCount(node);
     value->setChildNodeCount(nodeCount);
     if (nodesMap == m_documentNodeToIdMap)
       m_cachedChildCount.set(id, nodeCount);
     if (forcePushChildren && !depth)
       depth = 1;
     std::unique_ptr<protocol::Array<protocol::DOM::Node>> children =
-        buildArrayForContainerChildren(node, depth, nodesMap);
+        buildArrayForContainerChildren(node, depth, traverseFrames, nodesMap);
     if (children->length() > 0 ||
         depth)  // Push children along with shadow in any case.
       value->setChildren(std::move(children));
   }
 
   return value;
 }
 
 std::unique_ptr<protocol::Array<String>>
 InspectorDOMAgent::buildArrayForElementAttributes(Element* element) {
   std::unique_ptr<protocol::Array<String>> attributesValue =
       protocol::Array<String>::create();
   // Go through all attributes and serialize them.
   AttributeCollection attributes = element->attributes();
   for (auto& attribute : attributes) {
     // Add attribute pair
     attributesValue->addItem(attribute.name().toString());
     attributesValue->addItem(attribute.value());
   }
   return attributesValue;
 }
 
 std::unique_ptr<protocol::Array<protocol::DOM::Node>>
 InspectorDOMAgent::buildArrayForContainerChildren(Node* container,
                                                   int depth,
+                                                  bool traverseFrames,
                                                   NodeToIdMap* nodesMap) {
   std::unique_ptr<protocol::Array<protocol::DOM::Node>> children =
       protocol::Array<protocol::DOM::Node>::create();
   if (depth == 0) {
     // Special-case the only text child - pretend that container's children have
     // been requested.
     Node* firstChild = container->firstChild();
     if (firstChild && firstChild->getNodeType() == Node::kTextNode &&
         !firstChild->nextSibling()) {
-      children->addItem(buildObjectForNode(firstChild, 0, nodesMap));
+      children->addItem(
+          buildObjectForNode(firstChild, 0, traverseFrames, nodesMap));
       m_childrenRequested.add(bind(container, nodesMap));
     }
     return children;
   }
 
   Node* child = innerFirstChild(container);
   depth--;
   m_childrenRequested.add(bind(container, nodesMap));
 
   while (child) {
-    children->addItem(buildObjectForNode(child, depth, nodesMap));
+    children->addItem(
+        buildObjectForNode(child, depth, traverseFrames, nodesMap));
     child = innerNextSibling(child);
   }
   return children;
 }
 
 std::unique_ptr<protocol::Array<protocol::DOM::Node>>
 InspectorDOMAgent::buildArrayForPseudoElements(Element* element,
                                                NodeToIdMap* nodesMap) {
   if (!element->pseudoElement(PseudoIdBefore) &&
       !element->pseudoElement(PseudoIdAfter))
     return nullptr;
 
   std::unique_ptr<protocol::Array<protocol::DOM::Node>> pseudoElements =
       protocol::Array<protocol::DOM::Node>::create();
-  if (element->pseudoElement(PseudoIdBefore))
+  if (element->pseudoElement(PseudoIdBefore)) {
     pseudoElements->addItem(buildObjectForNode(
-        element->pseudoElement(PseudoIdBefore), 0, nodesMap));
-  if (element->pseudoElement(PseudoIdAfter))
-    pseudoElements->addItem(
-        buildObjectForNode(element->pseudoElement(PseudoIdAfter), 0, nodesMap));
+        element->pseudoElement(PseudoIdBefore), 0, false, nodesMap));
+  }
+  if (element->pseudoElement(PseudoIdAfter)) {
+    pseudoElements->addItem(buildObjectForNode(
+        element->pseudoElement(PseudoIdAfter), 0, false, nodesMap));
+  }
   return pseudoElements;
 }
 
 std::unique_ptr<protocol::Array<protocol::DOM::BackendNode>>
 InspectorDOMAgent::buildArrayForDistributedNodes(
     InsertionPoint* insertionPoint) {
   std::unique_ptr<protocol::Array<protocol::DOM::BackendNode>>
       distributedNodes = protocol::Array<protocol::DOM::BackendNode>::create();
   for (size_t i = 0; i < insertionPoint->distributedNodesSize(); ++i) {
     Node* distributedNode = insertionPoint->distributedNodeAt(i);
@@ skipping 96 matching lines @@
   int frameOwnerId = m_documentNodeToIdMap->get(frameOwner);
   if (!frameOwnerId)
     return;
 
   // Re-add frame owner element together with its new children.
   int parentId = m_documentNodeToIdMap->get(innerParentNode(frameOwner));
   frontend()->childNodeRemoved(parentId, frameOwnerId);
   unbind(frameOwner, m_documentNodeToIdMap.get());
 
   std::unique_ptr<protocol::DOM::Node> value =
-      buildObjectForNode(frameOwner, 0, m_documentNodeToIdMap.get());
+      buildObjectForNode(frameOwner, 0, false, m_documentNodeToIdMap.get());
   Node* previousSibling = innerPreviousSibling(frameOwner);
   int prevId =
       previousSibling ? m_documentNodeToIdMap->get(previousSibling) : 0;
   frontend()->childNodeInserted(parentId, prevId, std::move(value));
 }
 
 void InspectorDOMAgent::didCommitLoad(LocalFrame*, DocumentLoader* loader) {
   LocalFrame* inspectedFrame = m_inspectedFrames->root();
   if (loader->frame() != inspectedFrame) {
     invalidateFrameOwnerElement(loader->frame());
@@ skipping 21 matching lines @@
   if (!m_childrenRequested.contains(parentId)) {
     // No children are mapped yet -> only notify on changes of child count.
     int count = m_cachedChildCount.get(parentId) + 1;
     m_cachedChildCount.set(parentId, count);
     frontend()->childNodeCountUpdated(parentId, count);
   } else {
     // Children have been requested -> return value of a new child.
     Node* prevSibling = innerPreviousSibling(node);
     int prevId = prevSibling ? m_documentNodeToIdMap->get(prevSibling) : 0;
     std::unique_ptr<protocol::DOM::Node> value =
-        buildObjectForNode(node, 0, m_documentNodeToIdMap.get());
+        buildObjectForNode(node, 0, false, m_documentNodeToIdMap.get());
     frontend()->childNodeInserted(parentId, prevId, std::move(value));
   }
 }
 
 void InspectorDOMAgent::willRemoveDOMNode(Node* node) {
   if (isWhitespace(node))
     return;
 
   ContainerNode* parent = node->parentNode();
 
@@ skipping 98 matching lines @@
 void InspectorDOMAgent::didPushShadowRoot(Element* host, ShadowRoot* root) {
   if (!host->ownerDocument())
     return;
 
   int hostId = m_documentNodeToIdMap->get(host);
   if (!hostId)
     return;
 
   pushChildNodesToFrontend(hostId, 1);
   frontend()->shadowRootPushed(
-      hostId, buildObjectForNode(root, 0, m_documentNodeToIdMap.get()));
+      hostId, buildObjectForNode(root, 0, false, m_documentNodeToIdMap.get()));
 }
 
 void InspectorDOMAgent::willPopShadowRoot(Element* host, ShadowRoot* root) {
   if (!host->ownerDocument())
     return;
 
   int hostId = m_documentNodeToIdMap->get(host);
   int rootId = m_documentNodeToIdMap->get(root);
   if (hostId && rootId)
     frontend()->shadowRootPopped(hostId, rootId);
@@ skipping 44 matching lines @@
   Element* parent = pseudoElement->parentOrShadowHostElement();
   if (!parent)
     return;
   int parentId = m_documentNodeToIdMap->get(parent);
   if (!parentId)
     return;
 
   pushChildNodesToFrontend(parentId, 1);
   frontend()->pseudoElementAdded(
       parentId,
-      buildObjectForNode(pseudoElement, 0, m_documentNodeToIdMap.get()));
+      buildObjectForNode(pseudoElement, 0, false, m_documentNodeToIdMap.get()));
 }
 
 void InspectorDOMAgent::pseudoElementDestroyed(PseudoElement* pseudoElement) {
   int pseudoElementId = m_documentNodeToIdMap->get(pseudoElement);
   if (!pseudoElementId)
     return;
 
   // If a PseudoElement is bound, its parent element must be bound, too.
   Element* parent = pseudoElement->parentOrShadowHostElement();
   ASSERT(parent);
@@ skipping 144 matching lines @@
   ScriptState::Scope scope(scriptState);
   return m_v8Session->wrapObject(scriptState->context(),
                                  nodeV8Value(scriptState->context(), node),
                                  toV8InspectorStringView(objectGroup));
 }
 
 bool InspectorDOMAgent::pushDocumentUponHandlelessOperation(
     ErrorString* errorString) {
   if (!m_documentNodeToIdMap->contains(m_document)) {
     std::unique_ptr<protocol::DOM::Node> root;
-    getDocument(errorString, &root);
+    getDocument(errorString, Maybe<int>(), Maybe<bool>(), &root);
     return errorString->isEmpty();
   }
   return true;
 }
 
 DEFINE_TRACE(InspectorDOMAgent) {
   visitor->trace(m_domListener);
   visitor->trace(m_inspectedFrames);
   visitor->trace(m_documentNodeToIdMap);
   visitor->trace(m_danglingNodeToIdMaps);
   visitor->trace(m_idToNode);
   visitor->trace(m_idToNodesMap);
   visitor->trace(m_document);
   visitor->trace(m_revalidateTask);
   visitor->trace(m_searchResults);
   visitor->trace(m_history);
   visitor->trace(m_domEditor);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink