Devtools[LayoutEditor]: Rework layout-editor workflow

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 299 matching lines @@
     : InspectorBaseAgent<InspectorDOMAgent, InspectorFrontend::DOM>("DOM")
     , m_pageAgent(pageAgent)
     , m_injectedScriptManager(injectedScriptManager)
     , m_overlay(overlay)
     , m_domListener(nullptr)
     , m_documentNodeToIdMap(adoptPtrWillBeNoop(new NodeToIdMap()))
     , m_lastNodeId(1)
     , m_searchingForNode(NotSearching)
     , m_suppressAttributeModifiedEvent(false)
     , m_backendNodeIdToInspect(0)
+    , m_searchingInLayoutEditorPaused(false)
 {
 }
 
 InspectorDOMAgent::~InspectorDOMAgent()
 {
 #if !ENABLE(OILPAN)
     setDocument(nullptr);
     ASSERT(m_searchingForNode == NotSearching);
 #endif
 }
@@ skipping 790 matching lines @@
         nodeIds->addItem(pushNodePathToFrontend((it->value)[i].get()));
 }
 
 void InspectorDOMAgent::discardSearchResults(ErrorString*, const String& searchId)
 {
     m_searchResults.remove(searchId);
 }
 
 bool InspectorDOMAgent::handleMousePress()
 {
-    if (m_searchingForNode == NotSearching)
+    if (m_searchingForNode == NotSearching || (m_searchingForNode == SearchingInLayoutEditor && m_searchingInLayoutEditorPaused))
         return false;
 
     if (m_hoveredNodeForInspectMode) {
         inspect(m_hoveredNodeForInspectMode.get());
         m_hoveredNodeForInspectMode.clear();
         return true;
     }
     return false;
 }
 
 bool InspectorDOMAgent::handleGestureEvent(LocalFrame* frame, const PlatformGestureEvent& event)
 {
-    if (m_searchingForNode == NotSearching || event.type() != PlatformEvent::GestureTap)
+    if (m_searchingForNode == NotSearching || event.type() != PlatformEvent::GestureTap || (m_searchingForNode == SearchingInLayoutEditor && m_searchingInLayoutEditorPaused))
         return false;
     Node* node = hoveredNodeForEvent(frame, event, false);
     if (node && m_inspectModeHighlightConfig) {
         m_overlay->highlightNode(node, 0 /* eventTarget */, *m_inspectModeHighlightConfig, false);
         inspect(node);
         return true;
     }
     return false;
 }
 
 bool InspectorDOMAgent::handleTouchEvent(LocalFrame* frame, const PlatformTouchEvent& event)
 {
-    if (m_searchingForNode == NotSearching)
+    if (m_searchingForNode == NotSearching || (m_searchingForNode == SearchingInLayoutEditor && m_searchingInLayoutEditorPaused))
         return false;
     Node* node = hoveredNodeForEvent(frame, event, false);
     if (node && m_inspectModeHighlightConfig) {
         m_overlay->highlightNode(node, 0 /* eventTarget */, *m_inspectModeHighlightConfig, false);
         inspect(node);
         return true;
     }
     return false;
 }
 
 void InspectorDOMAgent::inspect(Node* inspectedNode)
 {
     if (!inspectedNode)
         return;
 
     Node* node = inspectedNode;
     while (node && !node->isElementNode() && !node->isDocumentNode() && !node->isDocumentFragment())
         node = node->parentOrShadowHostNode();
     if (!node)
         return;
 
     int backendNodeId = DOMNodeIds::idForNode(node);
     if (!frontend() || !enabled()) {
         m_backendNodeIdToInspect = backendNodeId;
         return;
     }
 
     frontend()->inspectNodeRequested(backendNodeId);
+
+    if (m_searchingForNode == SearchingInLayoutEditor) {
+        m_searchingInLayoutEditorPaused = true;
+        m_overlay->setInspectModeEnabled(false);
+    }
 }
 
 bool InspectorDOMAgent::handleMouseMove(LocalFrame* frame, const PlatformMouseEvent& event)
 {
-    if (m_searchingForNode == NotSearching)
+    if (m_searchingForNode == NotSearching || (m_searchingForNode == SearchingInLayoutEditor && m_searchingInLayoutEditorPaused))
         return false;
 
     if (!frame->view() || !frame->contentLayoutObject())
         return true;
     Node* node = hoveredNodeForEvent(frame, event, event.shiftKey());
 
     // Do not highlight within user agent shadow root unless requested.
     if (m_searchingForNode != SearchingForUAShadow) {
         ShadowRoot* shadowRoot = userAgentShadowRoot(node);
         if (shadowRoot)
@@ skipping 58 matching lines @@
     highlightConfig->padding = parseConfigColor("paddingColor", highlightInspectorObject);
     highlightConfig->border = parseConfigColor("borderColor", highlightInspectorObject);
     highlightConfig->margin = parseConfigColor("marginColor", highlightInspectorObject);
     highlightConfig->eventTarget = parseConfigColor("eventTargetColor", highlightInspectorObject);
     highlightConfig->shape = parseConfigColor("shapeColor", highlightInspectorObject);
     highlightConfig->shapeMargin = parseConfigColor("shapeMarginColor", highlightInspectorObject);
 
     return highlightConfig.release();
 }
 
-void InspectorDOMAgent::setInspectModeEnabled(ErrorString* errorString, bool enabled, const bool* inspectUAShadowDOM, const RefPtr<JSONObject>* highlightConfig)
+void InspectorDOMAgent::setInspectModeEnabled(ErrorString* errorString, bool enabled, const String* mode, const RefPtr<JSONObject>* highlightConfig)
 {
     if (enabled && !pushDocumentUponHandlelessOperation(errorString))
         return;
-    SearchMode searchMode = enabled ? (asBool(inspectUAShadowDOM) ? SearchingForUAShadow : SearchingForNormal) : NotSearching;
+    SearchMode searchMode = SearchingForNormal;
+    if (!enabled) {
+        searchMode = NotSearching;
+    } else if (!mode) {
+        searchMode = SearchingForNormal;
+    } else if (*mode == "showUAShadowDOM") {
+        searchMode = SearchingForUAShadow;
+    } else if (*mode == "showLayoutEditor") {
+        searchMode = SearchingInLayoutEditor;
+        m_searchingInLayoutEditorPaused = false;
+    }
+
     setSearchingForNode(errorString, searchMode, highlightConfig ? highlightConfig->get() : nullptr);
 }
 
 void InspectorDOMAgent::highlightRect(ErrorString*, int x, int y, int width, int height, const RefPtr<JSONObject>* color, const RefPtr<JSONObject>* outlineColor)
 {
     OwnPtr<FloatQuad> quad = adoptPtr(new FloatQuad(FloatRect(x, y, width, height)));
     innerHighlightQuad(quad.release(), color, outlineColor);
 }
 
 void InspectorDOMAgent::highlightQuad(ErrorString* errorString, const RefPtr<JSONArray>& quadArray, const RefPtr<JSONObject>* color, const RefPtr<JSONObject>* outlineColor)
@@ skipping 931 matching lines @@
 bool InspectorDOMAgent::pushDocumentUponHandlelessOperation(ErrorString* errorString)
 {
     if (!m_documentNodeToIdMap->contains(m_document)) {
         RefPtr<TypeBuilder::DOM::Node> root;
         getDocument(errorString, root);
         return errorString->isEmpty();
     }
     return true;
 }
 
+void InspectorDOMAgent::resumeSearchingForNode(Node* startNode)
+{
+    if (m_searchingForNode != SearchingInLayoutEditor)
+        return;
+
+    m_searchingInLayoutEditorPaused = false;
+    m_overlay->setInspectModeEnabled(true);
+    if (startNode && m_inspectModeHighlightConfig) {
+        m_hoveredNodeForInspectMode = startNode;
+        m_overlay->highlightNode(startNode, 0, *m_inspectModeHighlightConfig, false);
+    }
+
+}
+
 DEFINE_TRACE(InspectorDOMAgent)
 {
     visitor->trace(m_domListener);
     visitor->trace(m_pageAgent);
     visitor->trace(m_injectedScriptManager);
     visitor->trace(m_overlay);
 #if ENABLE(OILPAN)
     visitor->trace(m_documentNodeToIdMap);
     visitor->trace(m_danglingNodeToIdMaps);
     visitor->trace(m_idToNode);
     visitor->trace(m_idToNodesMap);
     visitor->trace(m_document);
     visitor->trace(m_revalidateTask);
     visitor->trace(m_searchResults);
 #endif
     visitor->trace(m_hoveredNodeForInspectMode);
     visitor->trace(m_history);
     visitor->trace(m_domEditor);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink