Fix index used to join results of DOM.getDocument and CSS.getLayoutTreeAndStyles

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

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * 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
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 336 matching lines @@
   StyleSheetAction(const String& name) : InspectorHistory::Action(name) {}
 
   virtual std::unique_ptr<protocol::CSS::CSSStyle> takeSerializedStyle() {
     return nullptr;
   }
 };
 
 struct InspectorCSSAgent::VectorStringHashTraits
     : public WTF::GenericHashTraits<Vector<String>> {
   static unsigned hash(const Vector<String>& vec) {
-    unsigned h = DefaultHash<String>::Hash::hash(vec[0]);
-    for (size_t i = 1; i < vec.size(); i++) {
+    unsigned h = DefaultHash<size_t>::Hash::hash(vec.size());
+    for (size_t i = 0; i < vec.size(); i++) {
       h = WTF::hashInts(h, DefaultHash<String>::Hash::hash(vec[i]));
     }
     return h;
   }
 
   static bool equal(const Vector<String>& a, const Vector<String>& b) {
     if (a.size() != b.size())
       return false;
     for (size_t i = 0; i < a.size(); i++) {
       if (a[i] != b[i])
@@ skipping 1999 matching lines @@
 int InspectorCSSAgent::getStyleIndexForNode(
     Node* node,
     const Vector<std::pair<String, CSSPropertyID>>& cssPropertyWhitelist,
     ComputedStylesMap& styleToIndexMap,
     protocol::Array<protocol::CSS::ComputedStyle>& computedStyles) {
   CSSComputedStyleDeclaration* computedStyleInfo =
       CSSComputedStyleDeclaration::create(node, true);
 
   Vector<String> style;
   for (const auto& pair : cssPropertyWhitelist) {
-    style.append(computedStyleInfo->getPropertyValue(pair.second));
+    String value = computedStyleInfo->getPropertyValue(pair.second);
+    if (value.isEmpty())
+      continue;
+    style.append(value);
   }
 
+  // -1 means an empty style.
+  if (style.isEmpty())
+    return -1;
+
   ComputedStylesMap::iterator it = styleToIndexMap.find(style);
   if (it != styleToIndexMap.end())
     return it->value;
 
   // It's a distinct style, so append to |computedStyles|.
   std::unique_ptr<protocol::Array<protocol::CSS::CSSComputedStyleProperty>>
       styleProperties =
           protocol::Array<protocol::CSS::CSSComputedStyleProperty>::create();
+
   for (size_t i = 0; i < style.size(); i++) {
     styleProperties->addItem(protocol::CSS::CSSComputedStyleProperty::create()
                                  .setName(cssPropertyWhitelist[i].first)

[dgozman, 2016/10/27 19:16:05]

Aren't these two out of sync, since we skip items in |style|, but don't skip in
|cssPropertyWhitelist| ?

[alex clarke (OOO till 29th), 2016/10/27 20:51:19]

Uh wow yes! Fixed now.

                                  .setValue(style[i])
                                  .build());
   }
   computedStyles.addItem(protocol::CSS::ComputedStyle::create()
                              .setProperties(std::move(styleProperties))
                              .build());
 
   size_t index = styleToIndexMap.size();
   styleToIndexMap.add(std::move(style), index);
   return index;
@@ skipping 24 matching lines @@
       contentDocument->updateStyleAndLayoutTree();
       visitLayoutTreeNodes(contentDocument->documentElement(), layoutTreeNodes,
                            cssPropertyWhitelist, styleToIndexMap,
                            computedStyles);
     }
 
     LayoutObject* layoutObject = node->layoutObject();
     if (!layoutObject)
       continue;
 
-    int backendNodeId = DOMNodeIds::idForNode(node);
+    int nodeId = m_domAgent->boundNodeId(node);
+    if (!nodeId)
+      continue;
+
     std::unique_ptr<protocol::CSS::LayoutTreeNode> layoutTreeNode =
         protocol::CSS::LayoutTreeNode::create()
-            .setBackendNodeId(backendNodeId)
-            .setStyleIndex(getStyleIndexForNode(
-                node, cssPropertyWhitelist, styleToIndexMap, computedStyles))
+            .setNodeId(nodeId)
             .setBoundingBox(buildRectForFloatRect(
                 node->isElementNode()
                     ? FloatRect(toElement(node)->boundsInViewport())
                     : layoutObject->absoluteBoundingBoxRect()))
             .build();
+    int styleIndex = getStyleIndexForNode(node, cssPropertyWhitelist,
+                                          styleToIndexMap, computedStyles);
+    if (styleIndex != -1)
+      layoutTreeNode->setStyleIndex(styleIndex);
 
     if (layoutObject->isText()) {
       LayoutText* layoutText = toLayoutText(layoutObject);
       layoutTreeNode->setLayoutText(layoutText->text());
       if (layoutText->hasTextBoxes()) {
         std::unique_ptr<protocol::Array<protocol::CSS::InlineTextBox>>
             inlineTextNodes =
                 protocol::Array<protocol::CSS::InlineTextBox>::create();
         for (const InlineTextBox* textBox = layoutText->firstTextBox(); textBox;
              textBox = textBox->nextTextBox()) {
@@ skipping 26 matching lines @@
   visitor->trace(m_idToInspectorStyleSheetForInlineStyle);
   visitor->trace(m_cssStyleSheetToInspectorStyleSheet);
   visitor->trace(m_documentToCSSStyleSheets);
   visitor->trace(m_invalidatedDocuments);
   visitor->trace(m_nodeToInspectorStyleSheet);
   visitor->trace(m_inspectorUserAgentStyleSheet);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink