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);
+  pushChildNodesToFrontend(nodeId, sanitizedDepth,
+                           maybeTaverseFrames.fromMaybe(false));
 }
 
 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