Devtools: Move inspectMode logic from InspectorDomAgent to InspectorOverlayImpl

Source/web/InspectorOverlayImpl.cpp

 /*
  * Copyright (C) 2011 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
@@ skipping 22 matching lines @@
 #include "bindings/core/v8/V8InspectorOverlayHost.h"
 #include "core/dom/Node.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/InspectorDebuggerAgent.h"
 #include "core/inspector/InspectorOverlayHost.h"
 #include "core/inspector/LayoutEditor.h"
+#include "core/layout/LayoutView.h"
 #include "core/loader/EmptyClients.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/JSONValues.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
 #include "web/PageOverlay.h"
 #include "web/WebGraphicsContextImpl.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include <v8.h>
 
 namespace blink {
 
+namespace {
+
+Node* hoveredNodeForPoint(LocalFrame* frame, const IntPoint& pointInRootFrame, bool ignorePointerEventsNone)
+{
+    HitTestRequest::HitTestRequestType hitType = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::AllowChildFrameContent;
+    if (ignorePointerEventsNone)
+        hitType |= HitTestRequest::IgnorePointerEventsNone;
+    HitTestRequest request(hitType);
+    HitTestResult result(request, frame->view()->rootFrameToContents(pointInRootFrame));
+    frame->contentLayoutObject()->hitTest(result);
+    Node* node = result.innerPossiblyPseudoNode();
+    while (node && node->nodeType() == Node::TEXT_NODE)
+        node = node->parentNode();
+    return node;
+}
+
+Node* hoveredNodeForEvent(LocalFrame* frame, const PlatformGestureEvent& event, bool ignorePointerEventsNone)
+{
+    return hoveredNodeForPoint(frame, event.position(), ignorePointerEventsNone);
+}
+
+Node* hoveredNodeForEvent(LocalFrame* frame, const PlatformMouseEvent& event, bool ignorePointerEventsNone)
+{
+    return hoveredNodeForPoint(frame, event.position(), ignorePointerEventsNone);
+}
+
+Node* hoveredNodeForEvent(LocalFrame* frame, const PlatformTouchEvent& event, bool ignorePointerEventsNone)
+{
+    const Vector<PlatformTouchPoint>& points = event.touchPoints();
+    if (!points.size())
+        return nullptr;
+    return hoveredNodeForPoint(frame, roundedIntPoint(points[0].pos()), ignorePointerEventsNone);
+}
+} // namespace
+
 class InspectorOverlayImpl::InspectorPageOverlayDelegate final : public PageOverlay::Delegate {
 public:
     explicit InspectorPageOverlayDelegate(InspectorOverlayImpl& overlay)
         : m_overlay(&overlay)
     { }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_overlay);
         PageOverlay::Delegate::trace(visitor);
@@ skipping 58 matching lines @@
         , m_overlay(&overlay)
     { }
 
     RawPtrWillBeMember<ChromeClient> m_client;
     RawPtrWillBeMember<InspectorOverlayImpl> m_overlay;
 };
 
 
 InspectorOverlayImpl::InspectorOverlayImpl(WebViewImpl* webViewImpl)
     : m_webViewImpl(webViewImpl)
-    , m_inspectModeEnabled(false)
     , m_overlayHost(InspectorOverlayHost::create())
     , m_drawViewSize(false)
     , m_drawViewSizeWithGrid(false)
     , m_resizeTimerActive(false)
     , m_omitTooltip(false)
     , m_timer(this, &InspectorOverlayImpl::onTimer)
     , m_suspendCount(0)
     , m_inLayout(false)
     , m_needsUpdate(false)
+    , m_inspectMode(InspectorDOMAgent::NotSearching)
 {
 }
 
 InspectorOverlayImpl::~InspectorOverlayImpl()
 {
     ASSERT(!m_overlayPage);
 }
 
 DEFINE_TRACE(InspectorOverlayImpl)
 {
     visitor->trace(m_highlightNode);
     visitor->trace(m_eventTargetNode);
     visitor->trace(m_overlayPage);
     visitor->trace(m_overlayChromeClient);
     visitor->trace(m_overlayHost);
     visitor->trace(m_debuggerAgent);
+    visitor->trace(m_domAgent);
     visitor->trace(m_layoutEditor);
+    visitor->trace(m_hoveredNodeForInspectMode);
 }
 
-void InspectorOverlayImpl::init(InspectorCSSAgent* cssAgent, InspectorDebuggerAgent* debuggerAgent)
+void InspectorOverlayImpl::init(InspectorCSSAgent* cssAgent, InspectorDebuggerAgent* debuggerAgent, InspectorDOMAgent* domAgent)
 {
     m_layoutEditor = LayoutEditor::create(cssAgent);
     m_debuggerAgent = debuggerAgent;
+    m_domAgent = domAgent;
     m_overlayHost->setListener(this);
 }
 
 void InspectorOverlayImpl::invalidate()
 {
     if (!m_pageOverlay)
         m_pageOverlay = PageOverlay::create(m_webViewImpl, new InspectorPageOverlayDelegate(*this));
 
     m_pageOverlay->update();
 }
 
 void InspectorOverlayImpl::layout()
 {
     if (isEmpty())
         return;
 
     TemporaryChange<bool> scoped(m_inLayout, true);
     if (m_needsUpdate) {
         m_needsUpdate = false;
         rebuildOverlayPage();
     }
     overlayMainFrame()->view()->updateAllLifecyclePhases();
 }
 
 bool InspectorOverlayImpl::handleInputEvent(const WebInputEvent& inputEvent)
 {
     bool handled = false;
+
     if (isEmpty())
-        return handled;
+        return false;
 
     if (WebInputEvent::isGestureEventType(inputEvent.type) && inputEvent.type == WebInputEvent::GestureTap) {
         // Only let GestureTab in (we only need it and we know PlatformGestureEventBuilder supports it).
         PlatformGestureEvent gestureEvent = PlatformGestureEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebGestureEvent&>(inputEvent));
+        handled = handleGestureEvent(gestureEvent);
+        if (handled)
+            return true;
+
         overlayMainFrame()->eventHandler().handleGestureEvent(gestureEvent);
     }
     if (WebInputEvent::isMouseEventType(inputEvent.type) && inputEvent.type != WebInputEvent::MouseEnter) {
         // PlatformMouseEventBuilder does not work with MouseEnter type, so we filter it out manually.
         PlatformMouseEvent mouseEvent = PlatformMouseEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebMouseEvent&>(inputEvent));
+
+        if (mouseEvent.type() == PlatformEvent::MouseMoved)
+            handled = handleMouseMove(mouseEvent);
+        else if (mouseEvent.type() == PlatformEvent::MousePressed)
+            handled = handleMousePress();
+
+        if (handled)
+            return true;
+
         if (mouseEvent.type() == PlatformEvent::MouseMoved)
             handled = overlayMainFrame()->eventHandler().handleMouseMoveEvent(mouseEvent);
         if (mouseEvent.type() == PlatformEvent::MousePressed)
             handled = overlayMainFrame()->eventHandler().handleMousePressEvent(mouseEvent);
         if (mouseEvent.type() == PlatformEvent::MouseReleased)
             handled = overlayMainFrame()->eventHandler().handleMouseReleaseEvent(mouseEvent);
     }
+
     if (WebInputEvent::isTouchEventType(inputEvent.type)) {
         PlatformTouchEvent touchEvent = PlatformTouchEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebTouchEvent&>(inputEvent));
+        handled = handleTouchEvent(touchEvent);
+        if (handled)
+            return true;
         overlayMainFrame()->eventHandler().handleTouchEvent(touchEvent);
     }
     if (WebInputEvent::isKeyboardEventType(inputEvent.type)) {
         PlatformKeyboardEvent keyboardEvent = PlatformKeyboardEventBuilder(static_cast<const WebKeyboardEvent&>(inputEvent));
         overlayMainFrame()->eventHandler().keyEvent(keyboardEvent);
     }
 
     return handled;
 }
 
 void InspectorOverlayImpl::setPausedInDebuggerMessage(const String* message)
 {
     m_pausedInDebuggerMessage = message ? *message : String();
     update();
 }
 
-void InspectorOverlayImpl::setInspectModeEnabled(bool enabled)
-{
-    m_inspectModeEnabled = enabled;
-    update();
-}
-
 void InspectorOverlayImpl::hideHighlight()
 {
     if (m_layoutEditor)
         m_layoutEditor->setNode(nullptr);
     m_highlightNode.clear();
     m_eventTargetNode.clear();
     m_highlightQuad.clear();
     update();
 }
 
+void InspectorOverlayImpl::highlightNode(Node* node, const InspectorHighlightConfig& highlightConfig, bool omitTooltip)
+{
+    highlightNode(node, nullptr, highlightConfig, omitTooltip);
+}
+
 void InspectorOverlayImpl::highlightNode(Node* node, Node* eventTarget, const InspectorHighlightConfig& highlightConfig, bool omitTooltip)
 {
     m_nodeHighlightConfig = highlightConfig;
     m_highlightNode = node;
     if (m_layoutEditor && highlightConfig.showLayoutEditor)
         m_layoutEditor->setNode(node);
     m_eventTargetNode = eventTarget;
     m_omitTooltip = omitTooltip;
     update();
 }
 
+void InspectorOverlayImpl::setInspectMode(InspectorDOMAgent::SearchMode searchMode, PassOwnPtr<InspectorHighlightConfig> highlightConfig)
+{
+    m_inspectMode = searchMode;
+    update();
+
+    if (searchMode != InspectorDOMAgent::NotSearching) {
+        m_inspectModeHighlightConfig = highlightConfig;
+    } else {
+        m_hoveredNodeForInspectMode.clear();
+        hideHighlight();
+    }
+}
+
 void InspectorOverlayImpl::highlightQuad(PassOwnPtr<FloatQuad> quad, const InspectorHighlightConfig& highlightConfig)
 {
     m_quadHighlightConfig = highlightConfig;
     m_highlightQuad = quad;
     m_omitTooltip = false;
     update();
 }
 
 bool InspectorOverlayImpl::isEmpty()
 {
     if (m_suspendCount)
         return true;
-    bool hasAlwaysVisibleElements = m_highlightNode || m_eventTargetNode || m_highlightQuad  || (m_resizeTimerActive && m_drawViewSize);
-    bool hasInvisibleInInspectModeElements = !m_pausedInDebuggerMessage.isNull();
-    return !(hasAlwaysVisibleElements || (hasInvisibleInInspectModeElements && !m_inspectModeEnabled));
+    bool hasVisibleElements = m_highlightNode || m_eventTargetNode || m_highlightQuad  || (m_resizeTimerActive && m_drawViewSize) || !m_pausedInDebuggerMessage.isNull();
+    return !hasVisibleElements && m_inspectMode == InspectorDOMAgent::NotSearching;
 }
 
 void InspectorOverlayImpl::update()
 {
     if (isEmpty()) {
         if (m_pageOverlay)
             m_pageOverlay.clear();
         return;
     }
     m_needsUpdate = true;
     m_webViewImpl->page()->chromeClient().scheduleAnimation();
 }
 
 void InspectorOverlayImpl::rebuildOverlayPage()
 {
     FrameView* view = m_webViewImpl->mainFrameImpl()->frameView();
     if (!view)
         return;
 
     IntRect visibleRectInDocument = view->scrollableArea()->visibleContentRect();
     IntSize viewportSize = m_webViewImpl->page()->frameHost().visualViewport().size();
     toLocalFrame(overlayPage()->mainFrame())->view()->resize(viewportSize);
     reset(viewportSize, visibleRectInDocument.location());
 
     drawNodeHighlight();
     drawQuadHighlight();
-    if (!m_inspectModeEnabled)
-        drawPausedInDebuggerMessage();
+    drawPausedInDebuggerMessage();
     drawViewSize();
 }
 
 static PassRefPtr<JSONObject> buildObjectForSize(const IntSize& size)
 {
     RefPtr<JSONObject> result = JSONObject::create();
     result->setNumber("width", size.width());
     result->setNumber("height", size.height());
     return result.release();
 }
@@ skipping 22 matching lines @@
     if (!m_highlightQuad)
         return;
 
     InspectorHighlight highlight;
     highlight.appendQuad(*m_highlightQuad, m_quadHighlightConfig.content, m_quadHighlightConfig.contentOutline);
     evaluateInOverlay("drawHighlight", highlight.asJSONObject());
 }
 
 void InspectorOverlayImpl::drawPausedInDebuggerMessage()
 {
-    if (!m_pausedInDebuggerMessage.isNull())
+    if (m_inspectMode == InspectorDOMAgent::NotSearching && !m_pausedInDebuggerMessage.isNull())
         evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
 }
 
 void InspectorOverlayImpl::drawViewSize()
 {
     if (m_resizeTimerActive && m_drawViewSize)
         evaluateInOverlay("drawViewSize", m_drawViewSizeWithGrid ? "true" : "false");
 }
 
 Page* InspectorOverlayImpl::overlayPage()
@@ skipping 102 matching lines @@
 
 void InspectorOverlayImpl::clear()
 {
     if (m_overlayPage) {
         m_overlayPage->willBeDestroyed();
         m_overlayPage.clear();
         m_overlayChromeClient.clear();
     }
     m_resizeTimerActive = false;
     m_pausedInDebuggerMessage = String();
-    m_inspectModeEnabled = false;
+    m_inspectMode = InspectorDOMAgent::NotSearching;
     m_timer.stop();
     hideHighlight();
 }
 
 void InspectorOverlayImpl::overlayResumed()
 {
     if (m_debuggerAgent) {
         ErrorString error;
         m_debuggerAgent->resume(&error);
     }
@@ skipping 41 matching lines @@
     }
     update();
 }
 
 void InspectorOverlayImpl::setShowViewportSizeOnResize(bool show, bool showGrid)
 {
     m_drawViewSize = show;
     m_drawViewSizeWithGrid = showGrid;
 }
 
+bool InspectorOverlayImpl::handleMouseMove(const PlatformMouseEvent& event)
+{
+    if (m_inspectMode == InspectorDOMAgent::NotSearching)
+        return false;
+
+    LocalFrame* frame = m_webViewImpl->mainFrameImpl()->frame();
+    if (!frame->view() || !frame->contentLayoutObject())
+        return false;
+    Node* node = hoveredNodeForEvent(frame, event, event.shiftKey());
+
+    // Do not highlight within user agent shadow root unless requested.
+    if (m_inspectMode != InspectorDOMAgent::SearchingForUAShadow) {
+        ShadowRoot* shadowRoot = InspectorDOMAgent::userAgentShadowRoot(node);
+        if (shadowRoot)
+            node = shadowRoot->host();
+    }
+
+    // Shadow roots don't have boxes - use host element instead.
+    if (node && node->isShadowRoot())
+        node = node->parentOrShadowHostNode();
+
+    if (!node)
+        return true;
+
+    Node* eventTarget = event.shiftKey() ? hoveredNodeForEvent(m_webViewImpl->mainFrameImpl()->frame(), event, false) : nullptr;
+    if (eventTarget == node)
+        eventTarget = nullptr;
+
+    if (node && m_inspectModeHighlightConfig) {
+        m_hoveredNodeForInspectMode = node;
+        highlightNode(node, eventTarget, *m_inspectModeHighlightConfig, event.ctrlKey() || event.metaKey());
+    }
+    return true;
+}
+
+bool InspectorOverlayImpl::handleMousePress()
+{
+    if (m_inspectMode == InspectorDOMAgent::NotSearching)
+        return false;
+
+    if (m_hoveredNodeForInspectMode) {
+        if (m_domAgent)
+            m_domAgent->inspect(m_hoveredNodeForInspectMode.get());
+        m_hoveredNodeForInspectMode.clear();
+        return true;
+    }
+    return false;
+}
+
+bool InspectorOverlayImpl::handleGestureEvent(const PlatformGestureEvent& event)
+{
+    if (m_inspectMode == InspectorDOMAgent::NotSearching || event.type() != PlatformEvent::GestureTap)
+        return false;
+    Node* node = hoveredNodeForEvent(m_webViewImpl->mainFrameImpl()->frame(), event, false);
+    if (node && m_inspectModeHighlightConfig) {
+        highlightNode(node, *m_inspectModeHighlightConfig, false);
+        if (m_domAgent)
+            m_domAgent->inspect(node);
+        return true;
+    }
+    return false;
+}
+
+bool InspectorOverlayImpl::handleTouchEvent(const PlatformTouchEvent& event)
+{
+    if (m_inspectMode == InspectorDOMAgent::NotSearching)
+        return false;
+    Node* node = hoveredNodeForEvent(m_webViewImpl->mainFrameImpl()->frame(), event, false);
+    if (node && m_inspectModeHighlightConfig) {
+        highlightNode(node, *m_inspectModeHighlightConfig, false);
+        if (m_domAgent)
+            m_domAgent->inspect(node);
+        return true;
+    }
+    return false;
+}
+
 } // namespace blink