Devtools[LayoutEditor]: Pass data about property change from InspectorOverlayPage

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 91 matching lines @@
     void setPausedInDebuggerMessage(const String*) override { }
     void setInspectModeEnabled(bool) override { }
     void hideHighlight() override { }
     void highlightNode(Node*, Node* eventTarget, const InspectorHighlightConfig&, bool omitTooltip) override { }
     void highlightQuad(PassOwnPtr<FloatQuad>, const InspectorHighlightConfig&) override { }
     void showAndHideViewSize(bool showGrid) override { }
     void setListener(InspectorOverlay::Listener* listener) override { }
     void suspendUpdates() override { }
     void resumeUpdates() override { }
     void clear() override { }
+    LayoutEditor* layoutEditor() { return nullptr; }
 };
 
 DEFINE_TRACE(InspectorOverlayStub)
 {
     InspectorOverlay::trace(visitor);
 }
 
 } // anonymous namespace
 
 // static
 PassOwnPtrWillBeRawPtr<InspectorOverlay> InspectorOverlayImpl::createEmpty()
 {
     return adoptPtrWillBeNoop(new InspectorOverlayStub());
 }
 
 InspectorOverlayImpl::InspectorOverlayImpl(WebViewImpl* webViewImpl)
     : m_webViewImpl(webViewImpl)
     , m_inspectModeEnabled(false)
     , m_overlayHost(InspectorOverlayHost::create())
     , m_drawViewSize(false)
     , m_drawViewSizeWithGrid(false)
     , m_omitTooltip(false)
     , m_timer(this, &InspectorOverlayImpl::onTimer)
     , m_suspendCount(0)
     , m_updating(false)
+    , m_layoutEditor(LayoutEditor::create())
 {
     m_overlayHost->setListener(this);
+    m_overlayHost->setLayoutEditorListener(m_layoutEditor.get());
 }
 
 InspectorOverlayImpl::~InspectorOverlayImpl()
 {
     ASSERT(!m_overlayPage);
 }
 
 DEFINE_TRACE(InspectorOverlayImpl)
 {
     visitor->trace(m_highlightNode);
@@ skipping 21 matching lines @@
     // Don't invalidate during an update, because that will lead to Document::scheduleLayoutTreeUpdate
     // being called within Document::updateLayoutTree which violates document lifecycle expectations.
     if (m_updating)
         return;
 
     m_webViewImpl->addPageOverlay(this, OverlayZOrders::highlight);
 }
 
 bool InspectorOverlayImpl::handleInputEvent(const WebInputEvent& inputEvent)
 {
+    bool handled = false;
     if (isEmpty())
-        return false;
+        return handled;
 
     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));
         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)
-            overlayMainFrame()->eventHandler().handleMouseMoveEvent(mouseEvent);
+            handled = overlayMainFrame()->eventHandler().handleMouseMoveEvent(mouseEvent);
         if (mouseEvent.type() == PlatformEvent::MousePressed)
-            overlayMainFrame()->eventHandler().handleMousePressEvent(mouseEvent);
+            handled = overlayMainFrame()->eventHandler().handleMousePressEvent(mouseEvent);
         if (mouseEvent.type() == PlatformEvent::MouseReleased)
-            overlayMainFrame()->eventHandler().handleMouseReleaseEvent(mouseEvent);
+            handled = overlayMainFrame()->eventHandler().handleMouseReleaseEvent(mouseEvent);
     }
     if (WebInputEvent::isTouchEventType(inputEvent.type)) {
         PlatformTouchEvent touchEvent = PlatformTouchEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebTouchEvent&>(inputEvent));
         overlayMainFrame()->eventHandler().handleTouchEvent(touchEvent);
     }
     if (WebInputEvent::isKeyboardEventType(inputEvent.type)) {
         PlatformKeyboardEvent keyboardEvent = PlatformKeyboardEventBuilder(static_cast<const WebKeyboardEvent&>(inputEvent));
         overlayMainFrame()->eventHandler().keyEvent(keyboardEvent);
     }
 
-    // Overlay should not consume events.
-    return false;
+    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()
 {
+    m_layoutEditor->setNode(nullptr);
     m_highlightNode.clear();
     m_eventTargetNode.clear();
     m_highlightQuad.clear();
-    m_layoutEditor.clear();
     update();
 }
 
 void InspectorOverlayImpl::highlightNode(Node* node, Node* eventTarget, const InspectorHighlightConfig& highlightConfig, bool omitTooltip)
 {
     m_nodeHighlightConfig = highlightConfig;
     m_highlightNode = node;
     if (highlightConfig.showLayoutEditor)
-        m_layoutEditor = LayoutEditor::create(node);
+        m_layoutEditor->setNode(node);
     m_eventTargetNode = eventTarget;
     m_omitTooltip = omitTooltip;
     update();
 }
 
 void InspectorOverlayImpl::highlightQuad(PassOwnPtr<FloatQuad> quad, const InspectorHighlightConfig& highlightConfig)
 {
     m_quadHighlightConfig = highlightConfig;
     m_highlightQuad = quad;
     m_omitTooltip = false;
@@ skipping 230 matching lines @@
     if (!m_suspendCount++)
         clear();
 }
 
 void InspectorOverlayImpl::resumeUpdates()
 {
     --m_suspendCount;
 }
 
 } // namespace blink