Rename DOM.getLayoutTreeNodes to 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 34 matching lines @@
 #include "core/css/MediaList.h"
 #include "core/css/MediaQuery.h"
 #include "core/css/MediaValues.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleSheet.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/StyleSheetList.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/css/resolver/StyleResolver.h"
+#include "core/dom/DOMNodeIds.h"
 #include "core/dom/Node.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/Text.h"
+#include "core/dom/shadow/ElementShadow.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLHeadElement.h"
 #include "core/html/VoidCallback.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/InspectorHistory.h"
 #include "core/inspector/InspectorNetworkAgent.h"
 #include "core/inspector/InspectorResourceContainer.h"
@@ skipping 210 matching lines @@
     bool contains = foundTopElement || element->boundingBox().contains(rect);
     if (!contains && foundNonTransparentColor) {
       // Only return colors if some opaque element covers up this one.
       colors.clear();
       foundOpaqueColor = false;
     }
   }
   return foundOpaqueColor;
 }
 
+std::unique_ptr<protocol::DOM::Rect> buildRectForFloatRect(
+    const FloatRect& rect) {
+  return protocol::DOM::Rect::create()
+      .setX(rect.x())
+      .setY(rect.y())
+      .setWidth(rect.width())
+      .setHeight(rect.height())
+      .build();
+}
+
 }  // namespace
 
 namespace CSSAgentState {
 static const char cssAgentEnabled[] = "cssAgentEnabled";
 }
 
 typedef blink::protocol::CSS::Backend::EnableCallback EnableCallback;
 
 namespace blink {
 
@@ skipping 34 matching lines @@
   WTF_MAKE_NONCOPYABLE(StyleSheetAction);
 
  public:
   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++) {
+      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])
+        return false;
+    }
+    return true;
+  }
+
+  static void constructDeletedValue(Vector<String>& vec, bool) {
+    vec.clear();
+    vec.append(String(WTF::HashTableDeletedValue));
+  }
+
+  static bool isDeletedValue(const Vector<String>& vec) {
+    return !vec.isEmpty() && vec[0].isHashTableDeletedValue();
+  }
+
+  static bool isEmptyValue(const Vector<String>& vec) { return vec.isEmpty(); }
+
+  static const bool emptyValueIsZero = false;
+  static const bool safeToCompareToEmptyOrDeleted = false;
+  static const bool hasIsEmptyValueFunction = true;
+};
+
 class InspectorCSSAgent::SetStyleSheetTextAction final
     : public InspectorCSSAgent::StyleSheetAction {
   WTF_MAKE_NONCOPYABLE(SetStyleSheetTextAction);
 
  public:
   SetStyleSheetTextAction(InspectorStyleSheetBase* styleSheet,
                           const String& text)
       : InspectorCSSAgent::StyleSheetAction("SetStyleSheetText"),
         m_styleSheet(styleSheet),
         m_text(text) {}
@@ skipping 1930 matching lines @@
       foundOpaqueColor = getColorsFromRect(textBounds, ownerElement->document(),
                                            nullptr, colors);
     }
   }
 
   *result = protocol::Array<String>::create();
   for (auto color : colors)
     result->fromJust()->addItem(color.serializedAsCSSComponentValue());
 }
 
+void InspectorCSSAgent::getLayoutTreeAndStyles(
+    ErrorString* errorString,
+    std::unique_ptr<protocol::Array<String>> styleWhitelist,
+    std::unique_ptr<protocol::Array<protocol::CSS::LayoutTreeNode>>*
+        layoutTreeNodes,
+    std::unique_ptr<protocol::Array<protocol::CSS::ComputedStyle>>*
+        computedStyles) {
+  m_domAgent->document()->updateStyleAndLayoutTree();
+
+  // Look up the CSSPropertyIDs for each entry in |styleWhitelist|.
+  Vector<std::pair<String, CSSPropertyID>> cssPropertyWhitelist;
+  for (size_t i = 0; i < styleWhitelist->length(); i++) {
+    CSSPropertyID propertyId = cssPropertyID(styleWhitelist->get(i));
+    if (propertyId == CSSPropertyInvalid)
+      continue;
+    cssPropertyWhitelist.append(
+        std::make_pair(styleWhitelist->get(i), propertyId));
+  }
+
+  *layoutTreeNodes = protocol::Array<protocol::CSS::LayoutTreeNode>::create();
+  *computedStyles = protocol::Array<protocol::CSS::ComputedStyle>::create();
+
+  ComputedStylesMap styleToIndexMap;
+  visitLayoutTreeNodes(m_domAgent->document(), *layoutTreeNodes->get(),
+                       cssPropertyWhitelist, styleToIndexMap,
+                       *computedStyles->get());
+}
+
+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));
+  }
+
+  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)
+                                 .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;
+}
+
+void InspectorCSSAgent::visitLayoutTreeNodes(
+    Node* node,
+    protocol::Array<protocol::CSS::LayoutTreeNode>& layoutTreeNodes,
+    const Vector<std::pair<String, CSSPropertyID>>& cssPropertyWhitelist,
+    ComputedStylesMap& styleToIndexMap,
+    protocol::Array<protocol::CSS::ComputedStyle>& computedStyles) {
+  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, cssPropertyWhitelist,
+                             styleToIndexMap, computedStyles);
+      }
+    }
+
+    // Pierce iframe boundaries.
+    if (node->isFrameOwnerElement()) {
+      Document* contentDocument =
+          toHTMLFrameOwnerElement(node)->contentDocument();
+      contentDocument->updateStyleAndLayoutTree();
+      visitLayoutTreeNodes(contentDocument->documentElement(), layoutTreeNodes,
+                           cssPropertyWhitelist, styleToIndexMap,
+                           computedStyles);
+    }
+
+    LayoutObject* layoutObject = node->layoutObject();
+    if (!layoutObject)
+      continue;
+
+    int backendNodeId = DOMNodeIds::idForNode(node);
+    std::unique_ptr<protocol::CSS::LayoutTreeNode> layoutTreeNode =
+        protocol::CSS::LayoutTreeNode::create()
+            .setBackendNodeId(backendNodeId)
+            .setStyleIndex(getStyleIndexForNode(
+                node, cssPropertyWhitelist, styleToIndexMap, computedStyles))
+            .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()) {
+        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()) {
+          FloatRect localCoordsTextBoxRect(textBox->calculateBoundaries());
+          FloatRect absoluteCoordsTextBoxRect =
+              layoutObject->localToAbsoluteQuad(localCoordsTextBoxRect)
+                  .boundingBox();
+          inlineTextNodes->addItem(protocol::CSS::InlineTextBox::create()
+                                       .setStartCharacterIndex(textBox->start())
+                                       .setNumCharacters(textBox->len())
+                                       .setBoundingBox(buildRectForFloatRect(
+                                           absoluteCoordsTextBoxRect))
+                                       .build());
+        }
+        layoutTreeNode->setInlineTextNodes(std::move(inlineTextNodes));
+      }
+    }
+
+    layoutTreeNodes.addItem(std::move(layoutTreeNode));
+  }
+}
+
 DEFINE_TRACE(InspectorCSSAgent) {
   visitor->trace(m_domAgent);
   visitor->trace(m_inspectedFrames);
   visitor->trace(m_networkAgent);
   visitor->trace(m_resourceContentLoader);
   visitor->trace(m_resourceContainer);
   visitor->trace(m_idToInspectorStyleSheet);
   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