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 298 matching lines @@
     : InspectorBaseAgent<InspectorDOMAgent, InspectorFrontend::DOM>("DOM")
     , m_pageAgent(pageAgent)
     , m_injectedScriptManager(injectedScriptManager)
     , m_client(client)
     , m_domListener(nullptr)
     , m_documentNodeToIdMap(adoptPtrWillBeNoop(new NodeToIdMap()))
     , m_lastNodeId(1)
     , m_searchingForNode(NotSearching)
     , m_suppressAttributeModifiedEvent(false)
     , m_backendNodeIdToInspect(0)
+    , m_layoutEditorEnabled(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 (!shouldHandleInputEvents())
         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)

[dgozman, 2015/08/28 23:44:10]

Bring back GestureTap!

[sergeyv, 2015/09/02 00:40:57]

Done.

+    if (!shouldHandleInputEvents())
         return false;
     Node* node = hoveredNodeForEvent(frame, event, false);
     if (node && m_inspectModeHighlightConfig) {
         if (m_client)
             m_client->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 (!shouldHandleInputEvents())
         return false;
     Node* node = hoveredNodeForEvent(frame, event, false);
     if (node && m_inspectModeHighlightConfig) {
         if (m_client)
             m_client->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_layoutEditorEnabled = true;
+        if (m_client) {
+            m_client->setInspectModeEnabled(false);
+            m_client->showLayoutEditorForNode(node, *m_inspectModeHighlightConfig.get());
+        }
+    }
 }
 
 bool InspectorDOMAgent::handleMouseMove(LocalFrame* frame, const PlatformMouseEvent& event)
 {
-    if (m_searchingForNode == NotSearching)
+    if (!shouldHandleInputEvents())
         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 23 matching lines @@
 {
     // TODO(dgozman): move this to overlay.
     m_searchingForNode = searchMode;
     if (m_client)
         m_client->setInspectModeEnabled(searchMode != NotSearching);
     if (searchMode != NotSearching) {
         m_inspectModeHighlightConfig = highlightConfigFromInspectorObject(errorString, highlightInspectorObject);
     } else {
         m_hoveredNodeForInspectMode.clear();
         hideHighlight(errorString);
+        if (m_client)
+            m_client->showLayoutEditorForNode(nullptr, m_inspectModeHighlightConfig ? *m_inspectModeHighlightConfig : InspectorHighlightConfig());
     }
 }
 
 PassOwnPtr<InspectorHighlightConfig> InspectorDOMAgent::highlightConfigFromInspectorObject(ErrorString* errorString, JSONObject* highlightInspectorObject)
 {
     if (!highlightInspectorObject) {
         *errorString = "Internal error: highlight configuration parameter is missing";
         return nullptr;
     }
 
     OwnPtr<InspectorHighlightConfig> highlightConfig = adoptPtr(new InspectorHighlightConfig());
     bool showInfo = false; // Default: false (do not show a tooltip).
     highlightInspectorObject->getBoolean("showInfo", &showInfo);
     highlightConfig->showInfo = showInfo;
     bool showRulers = false; // Default: false (do not show rulers).
     highlightInspectorObject->getBoolean("showRulers", &showRulers);
     highlightConfig->showRulers = showRulers;
     bool showExtensionLines = false; // Default: false (do not show extension lines).
     highlightInspectorObject->getBoolean("showExtensionLines", &showExtensionLines);
     highlightConfig->showExtensionLines = showExtensionLines;
-    bool showLayoutEditor = false;
-    highlightInspectorObject->getBoolean("showLayoutEditor", &showLayoutEditor);
-    highlightConfig->showLayoutEditor = showLayoutEditor;
     bool displayAsMaterial = false;
     highlightInspectorObject->getBoolean("displayAsMaterial", &displayAsMaterial);
     highlightConfig->displayAsMaterial = displayAsMaterial;
     highlightConfig->content = parseConfigColor("contentColor", highlightInspectorObject);
     highlightConfig->contentOutline = parseConfigColor("contentOutlineColor", highlightInspectorObject);
     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") {

[dgozman, 2015/08/28 23:44:10]

There should be TypeBuilder constants for these.

[sergeyv, 2015/09/02 00:40:58]

Done.

+        searchMode = SearchingForUAShadow;
+    } else if (*mode == "showLayoutEditor") {
+        searchMode = SearchingInLayoutEditor;
+        m_layoutEditorEnabled = 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 936 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_layoutEditorEnabled = false;
+    if (m_client)
+        m_client->setInspectModeEnabled(true);
+    if (startNode && m_inspectModeHighlightConfig) {
+        m_hoveredNodeForInspectMode = startNode;
+        if (m_client)
+            m_client->highlightNode(startNode, 0, *m_inspectModeHighlightConfig, false);
+    }
+
+}
+
+bool InspectorDOMAgent::shouldHandleInputEvents()

[dgozman, 2015/08/28 23:44:10]

shouldSearchForNode

[sergeyv, 2015/09/02 00:40:57]

Done.

+{
+    return m_searchingForNode != NotSearching && (m_searchingForNode != SearchingInLayoutEditor || !m_layoutEditorEnabled);

[dgozman, 2015/08/28 23:44:10]

return !(m_searchingForNode == NotSearching || (m_searchingForNode ==
SearchingInLayoutEditor && m_layoutEditorEnabled));

[sergeyv, 2015/09/02 00:40:58]

Done.

+}
+
 DEFINE_TRACE(InspectorDOMAgent)
 {
     visitor->trace(m_domListener);
     visitor->trace(m_pageAgent);
     visitor->trace(m_injectedScriptManager);
 #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