Rename traverseFrames to pierce and traverse shadow dom too.

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 458 matching lines @@
   setSearchingForNode(NotSearching, Maybe<protocol::DOM::HighlightConfig>());
   m_instrumentingAgents->removeInspectorDOMAgent(this);
   m_history.clear();
   m_domEditor.clear();
   setDocument(nullptr);
   return Response::OK();
 }
 
 Response InspectorDOMAgent::getDocument(
     Maybe<int> depth,
-    Maybe<bool> traverseFrames,
+    Maybe<bool> pierce,
     std::unique_ptr<protocol::DOM::Node>* root) {
   // Backward compatibility. Mark agent as enabled when it requests document.
   if (!enabled())
     innerEnable();
 
   if (!m_document)
     return Response::Error("Document is not available");
 
   discardFrontendBindings();
 
   int sanitizedDepth = depth.fromMaybe(2);
   if (sanitizedDepth == -1)
     sanitizedDepth = INT_MAX;
 
-  *root = buildObjectForNode(m_document.get(), sanitizedDepth,
-                             traverseFrames.fromMaybe(false),
-                             m_documentNodeToIdMap.get());
+  *root =
+      buildObjectForNode(m_document.get(), sanitizedDepth,
+                         pierce.fromMaybe(false), m_documentNodeToIdMap.get());
   return Response::OK();
 }
 
 void InspectorDOMAgent::pushChildNodesToFrontend(int nodeId,
                                                  int depth,
-                                                 bool traverseFrames) {
+                                                 bool pierce) {
   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, traverseFrames);
+      pushChildNodesToFrontend(childNodeId, depth, pierce);
     }
 
     return;
   }
 
   std::unique_ptr<protocol::Array<protocol::DOM::Node>> children =
-      buildArrayForContainerChildren(node, depth, traverseFrames, nodeMap);
+      buildArrayForContainerChildren(node, depth, pierce, 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 998 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,
+    bool pierce,
     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 26 matching lines @@
     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, traverseFrames ? depth : 0, traverseFrames, nodesMap));
+        value->setContentDocument(
+            buildObjectForNode(doc, pierce ? depth : 0, pierce, 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, traverseFrames, nodesMap));
+            buildObjectForNode(root, pierce ? depth : 0, pierce, 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, traverseFrames, nodesMap));
+        value->setImportedDocument(
+            buildObjectForNode(linkElement.import(), 0, pierce, nodesMap));
       }
       forcePushChildren = true;
     }
 
     if (isHTMLTemplateElement(*element)) {
-      value->setTemplateContent(
-          buildObjectForNode(toHTMLTemplateElement(*element).content(), 0,
-                             traverseFrames, nodesMap));
+      value->setTemplateContent(buildObjectForNode(
+          toHTMLTemplateElement(*element).content(), 0, pierce, 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, traverseFrames, nodesMap);
+        buildArrayForContainerChildren(node, depth, pierce, 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,
+                                                  bool pierce,
                                                   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, traverseFrames, nodesMap));
+      children->addItem(buildObjectForNode(firstChild, 0, pierce, 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, traverseFrames, nodesMap));
+    children->addItem(buildObjectForNode(child, depth, pierce, 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))
@@ skipping 537 matching lines @@
   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