Rename DOM.getLayoutTreeNodes to CSS.getLayoutTreeAndStyles

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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/inspector/InspectorDOMAgent.h"
 
 #include "bindings/core/v8/BindingSecurity.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8Node.h"
 #include "core/InputTypeNames.h"
+#include "core/css/CSSComputedStyleDeclaration.h"
+#include "core/css/CSSVariableData.h"
 #include "core/dom/Attr.h"
 #include "core/dom/CharacterData.h"
 #include "core/dom/ContainerNode.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/DocumentType.h"
 #include "core/dom/Element.h"
 #include "core/dom/Node.h"
@@ skipping 30 matching lines @@
 #include "core/xml/XPathResult.h"
 #include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/PlatformTouchEvent.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
+namespace std {
+
+using ComputedStyleArray =
+    std::vector<std::unique_ptr<blink::protocol::DOM::ComputedStyleProperty>>;
+
+template <>
+struct equal_to<ComputedStyleArray> {
+  bool operator()(const ComputedStyleArray& a,
+                  const ComputedStyleArray& b) const {
+    if (a.size() != b.size())
+      return false;
+    for (size_t i = 0; i < a.size(); i++) {
+      if (a[i]->getName() != b[i]->getName() ||
+          a[i]->getValue() != b[i]->getValue()) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+template <>
+struct hash<ComputedStyleArray> {
+  using argument_type = ComputedStyleArray;
+  using result_type = size_t;
+
+  static size_t computeHash(
+      const blink::protocol::DOM::ComputedStyleProperty* property) {
+    size_t h1 = DefaultHash<String>::Hash::hash(property->getName());
+    size_t h2 = DefaultHash<String>::Hash::hash(property->getValue());
+    return h1 ^ (h2 << 1);
+  }
+
+  size_t operator()(const ComputedStyleArray& array) const {
+    if (array.size() == 0)
+      return 0;
+    size_t h = computeHash(array[0].get());
+    for (size_t i = 1; i < array.size(); i++) {
+      size_t h2 = computeHash(array[i].get());
+      h ^= (h2 << 1);
+    }
+    return h;
+  }
+};
+}  // namespace std
+
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace DOMAgentState {
 static const char domAgentEnabled[] = "domAgentEnabled";
 };
 
 namespace {
 
@@ skipping 430 matching lines @@
     *errorString = "Document is not available";
     return;
   }
 
   discardFrontendBindings();
 
   *root = buildObjectForNode(m_document.get(), 2, m_documentNodeToIdMap.get());
 }
 
 void InspectorDOMAgent::getLayoutTreeNodes(
-    ErrorString* errorString,
+    ErrorString* error_string,
+    std::unique_ptr<protocol::Array<String>> style_whitelist,
     std::unique_ptr<protocol::Array<protocol::DOM::LayoutTreeNode>>*
-        layoutTreeNodes) {
-  layoutTreeNodes->reset(new protocol::Array<protocol::DOM::LayoutTreeNode>);
-  visitLayoutTreeNodes(m_document.get(), *layoutTreeNodes->get());
+        layout_tree_nodes,
+    std::unique_ptr<protocol::Array<protocol::DOM::ComputedStyle>>*
+        computed_styles) {
+  m_document->updateStyleAndLayoutTree();
+
+  layout_tree_nodes->reset(new protocol::Array<protocol::DOM::LayoutTreeNode>);
+  ComputedStylesMap style_to_index_map;
+  visitLayoutTreeNodes(m_document.get(), *layout_tree_nodes->get(),
+                       style_whitelist.get(), style_to_index_map);
+
+  std::vector<std::unique_ptr<protocol::DOM::ComputedStyle>> styles(
+      style_to_index_map.size());
+  for (ComputedStylesMap::value_type& pair : style_to_index_map) {
+    ComputedStyleArray& style = *const_cast<ComputedStyleArray*>(&pair.first);
+    using ProtocolStyleArray =
+        protocol::Array<blink::protocol::DOM::ComputedStyleProperty>;
+    styles[pair.second] =
+        protocol::DOM::ComputedStyle::create()
+            .setProperties(std::unique_ptr<ProtocolStyleArray>(
+                new ProtocolStyleArray(std::move(style))))
+            .build();
+  }
+
+  computed_styles->reset(
+      new protocol::Array<protocol::DOM::ComputedStyle>(std::move(styles)));

[dgozman, 2016/10/12 21:00:40]

Can just use addItem above, directly constructing the protocol::Array instead of
using intermediate vector.

[alex clarke (OOO till 29th), 2016/10/13 20:25:10]

The problem with that is:
for (ComputedStylesMap::value_type& pair : style_to_index_map) {
  pair.second // this is not sorted so we can't use addItem
}

+}
+
+int InspectorDOMAgent::getStyleIndexForNode(
+    Node* node,
+    protocol::Array<String>* style_whitelist,
+    ComputedStylesMap& style_to_index_map) {
+  CSSComputedStyleDeclaration* computed_style_info =
+      CSSComputedStyleDeclaration::create(node, true);
+  ComputedStyleArray style;
+  for (size_t i = 0; i < style_whitelist->length(); i++) {
+    CSSPropertyID property_id = cssPropertyID(style_whitelist->get(i));
+    if (property_id == CSSPropertyInvalid)
+      continue;
+    style.push_back(

[dgozman, 2016/10/12 21:00:40]

Since all the keys in all ComputedStyleArray instances are the same, I'd:
- convert style_whitelist to array of CSSPropertyID beforehand;
- have a map<vector<String>, int> as a cache;
- append keys when constructing result.

[alex clarke (OOO till 29th), 2016/10/13 20:25:10]

Right, in the spirit of that it seems simplest to pass around the whitelist as
Vector<std::pair<String, CSSPropertyID>>

+        protocol::DOM::ComputedStyleProperty::create()
+            .setName(style_whitelist->get(i))
+            .setValue(computed_style_info->getPropertyValue(property_id))
+            .build());
+  }
+
+  ComputedStylesMap::iterator it = style_to_index_map.find(style);
+  if (it != style_to_index_map.end())
+    return it->second;
+  size_t index = style_to_index_map.size();
+  style_to_index_map.insert(std::make_pair(std::move(style), index));
+  return index;
 }
 
 void InspectorDOMAgent::visitLayoutTreeNodes(
     Node* node,
-    protocol::Array<protocol::DOM::LayoutTreeNode>& layoutTreeNodes) {
+    protocol::Array<protocol::DOM::LayoutTreeNode>& layout_tree_nodes,
+    protocol::Array<String>* style_whitelist,
+    ComputedStylesMap& style_to_index_map) {
   for (; node; node = NodeTraversal::next(*node)) {
     // Visit shadow dom nodes.
     if (node->isElementNode()) {
       const Element* element = toElement(node);
       ElementShadow* elementShadow = element->shadow();
       if (elementShadow) {
         visitLayoutTreeNodes(&elementShadow->youngestShadowRoot(),
-                             layoutTreeNodes);
+                             layout_tree_nodes, style_whitelist,
+                             style_to_index_map);
       }
     }
 
     // Pierce iframe boundaries.
     if (node->isFrameOwnerElement()) {
-      visitLayoutTreeNodes(
-          toHTMLFrameOwnerElement(node)->contentDocument()->documentElement(),
-          layoutTreeNodes);
+      Document* content_document =
+          toHTMLFrameOwnerElement(node)->contentDocument();
+      content_document->updateStyleAndLayoutTree();
+      visitLayoutTreeNodes(content_document->documentElement(),
+                           layout_tree_nodes, style_whitelist,
+                           style_to_index_map);
     }
 
     LayoutObject* layoutObject = node->layoutObject();
     if (!layoutObject)
       continue;
 
     int backendNodeId = DOMNodeIds::idForNode(node);
     std::unique_ptr<protocol::DOM::LayoutTreeNode> layoutTreeNode =
         protocol::DOM::LayoutTreeNode::create()
             .setBackendNodeId(backendNodeId)
+            .setStyleIndex(
+                getStyleIndexForNode(node, style_whitelist, style_to_index_map))
             .setBoundingBox(buildRectForFloatRect(
                 node->isElementNode()
                     ? FloatRect(toElement(node)->boundsInViewport())
                     : layoutObject->absoluteBoundingBoxRect()))
             .build();
 
     if (layoutObject->isText()) {
       LayoutText* layoutText = toLayoutText(layoutObject);
       layoutTreeNode->setLayoutText(layoutText->text());
       if (layoutText->hasTextBoxes()) {
@@ skipping 10 matching lines @@
                                        .setStartCharacterIndex(textBox->start())
                                        .setNumCharacters(textBox->len())
                                        .setBoundingBox(buildRectForFloatRect(
                                            absoluteCoordsTextBoxRect))
                                        .build());
         }
         layoutTreeNode->setInlineTextNodes(std::move(inlineTextNodes));
       }
     }
 
-    layoutTreeNodes.addItem(std::move(layoutTreeNode));
+    layout_tree_nodes.addItem(std::move(layoutTreeNode));
   }
 }
 
 void InspectorDOMAgent::pushChildNodesToFrontend(int nodeId, int depth) {
   Node* node = nodeForId(nodeId);
   if (!node || (!node->isElementNode() && !node->isDocumentNode() &&
                 !node->isDocumentFragment()))
     return;
 
   NodeToIdMap* nodeMap = m_idToNodesMap.get(nodeId);
@@ skipping 1752 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