Add a DOM.getLayoutTreeNodes devtools command

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 49 matching lines @@
 #include "core/html/imports/HTMLImportChild.h"
 #include "core/html/imports/HTMLImportLoader.h"
 #include "core/inspector/DOMEditor.h"
 #include "core/inspector/DOMPatchSupport.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/InspectorHighlight.h"
 #include "core/inspector/InspectorHistory.h"
 #include "core/inspector/V8InspectorString.h"
 #include "core/layout/HitTestResult.h"
+#include "core/layout/LayoutInline.h"
 #include "core/layout/api/LayoutViewItem.h"
+#include "core/layout/line/InlineTextBox.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/xml/DocumentXPathEvaluator.h"
 #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"
@@ skipping 48 matching lines @@
 }
 
 v8::Local<v8::Value> nodeV8Value(v8::Local<v8::Context> context, Node* node)
 {
     v8::Isolate* isolate = context->GetIsolate();
     if (!node || !BindingSecurity::shouldAllowAccessTo(currentDOMWindow(isolate), node, BindingSecurity::ErrorReportOption::DoNotReport))
         return v8::Null(isolate);
     return toV8(node, context->Global(), isolate);
 }
 
+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
 
+
 class InspectorRevalidateDOMTask final : public GarbageCollectedFinalized<InspectorRevalidateDOMTask> {
 public:
     explicit InspectorRevalidateDOMTask(InspectorDOMAgent*);
     void scheduleStyleAttrRevalidationFor(Element*);
     void reset() { m_timer.stop(); }
     void onTimer(TimerBase*);
     DECLARE_TRACE();
 
 private:
     Member<InspectorDOMAgent> m_domAgent;
@@ skipping 371 matching lines @@
     if (!m_document) {
         *errorString = "Document is not available";
         return;
     }
 
     discardFrontendBindings();
 
     *root = buildObjectForNode(m_document.get(), 2, 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());
+}
+
+void InspectorDOMAgent::visitLayoutTreeNodes(Node* node, protocol::Array<protocol::DOM::LayoutTreeNode>& layoutTreeNodes)
+{
+    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);
+        }
+
+        // Pierce iframe boundaries.
+        if (node->isFrameOwnerElement())
+            visitLayoutTreeNodes(toHTMLFrameOwnerElement(node)->contentDocument()->documentElement(), layoutTreeNodes);
+
+        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)
+                .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::DOM::InlineTextBox>> inlineTextNodes(new protocol::Array<protocol::DOM::InlineTextBox>());
+                for (const InlineTextBox* textBox = layoutText->firstTextBox(); textBox; textBox = textBox->nextTextBox()) {
+                    FloatRect localCoordsTextBoxRect(textBox->calculateBoundaries());
+                    FloatRect absoluteCoordsTextBoxRect = layoutObject->localToAbsoluteQuad(localCoordsTextBoxRect).boundingBox();
+                    inlineTextNodes->addItem(
+                        protocol::DOM::InlineTextBox::create()
+                            .setStartCharacterIndex(textBox->start())
+                            .setNumCharacters(textBox->len())
+                            .setBoundingBox(buildRectForFloatRect(absoluteCoordsTextBoxRect))
+                            .build());
+                }
+                layoutTreeNode->setInlineTextNodes(std::move(inlineTextNodes));
+            }
+        }
+
+        layoutTreeNodes.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);
 
     if (m_childrenRequested.contains(nodeId)) {
         if (depth <= 1)
@@ skipping 1587 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