[DevTools] Reverse dependencies between InspectorOverlay and agents.

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 19 matching lines @@
 #include "web/InspectorOverlayImpl.h"
 
 #include "bindings/core/v8/ScriptController.h"
 #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/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 {
-
-class InspectorOverlayStub : public NoBaseWillBeGarbageCollectedFinalized<InspectorOverlayStub>, public InspectorOverlay {
-    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(InspectorOverlayStub);
-    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(InspectorOverlayStub);
-public:
-    InspectorOverlayStub() { }
-    DECLARE_TRACE();
-
-    // InspectorOverlay implementation.
-    void update() override { }
-    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 { }
-    void setLayoutEditor(PassOwnPtrWillBeRawPtr<LayoutEditor>) override { }
-};
-
-DEFINE_TRACE(InspectorOverlayStub)
-{
-    InspectorOverlay::trace(visitor);
-}
-
-} // anonymous 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 56 matching lines @@
     InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlayImpl& overlay)
         : m_client(&client)
         , m_overlay(&overlay)
     { }
 
     RawPtrWillBeMember<ChromeClient> m_client;
     RawPtrWillBeMember<InspectorOverlayImpl> m_overlay;
 };
 
 
-// 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_resizeTimerActive(false)
     , m_omitTooltip(false)
     , m_timer(this, &InspectorOverlayImpl::onTimer)
     , m_suspendCount(0)
     , m_inLayout(false)
     , m_needsUpdate(false)
 {
     m_overlayHost->setDebuggerListener(this);
 }
 
 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_listener);
     visitor->trace(m_layoutEditor);
-    InspectorOverlay::trace(visitor);
+}
+
+void InspectorOverlayImpl::init(InspectorCSSAgent* cssAgent, InspectorDebuggerAgent* debuggerAgent)
+{
+    m_layoutEditor = LayoutEditor::create(cssAgent);
+    // TODO(dgozman): overlay should be a listener, not layout editor.
+    m_overlayHost->setLayoutEditorListener(m_layoutEditor.get());
+    m_debuggerAgent = debuggerAgent;
 }
 
 void InspectorOverlayImpl::invalidate()
 {
     if (!m_pageOverlay)
         m_pageOverlay = PageOverlay::create(m_webViewImpl, new InspectorPageOverlayDelegate(*this));
 
     m_pageOverlay->update();
 }
 
@@ skipping 77 matching lines @@
 }
 
 void InspectorOverlayImpl::highlightQuad(PassOwnPtr<FloatQuad> quad, const InspectorHighlightConfig& highlightConfig)
 {
     m_quadHighlightConfig = highlightConfig;
     m_highlightQuad = quad;
     m_omitTooltip = false;
     update();
 }
 
-void InspectorOverlayImpl::showAndHideViewSize(bool showGrid)
-{
-    m_drawViewSize = true;
-    m_drawViewSizeWithGrid = showGrid;
-    update();
-    m_timer.startOneShot(1, FROM_HERE);
-}
-
 bool InspectorOverlayImpl::isEmpty()
 {
     if (m_suspendCount)
         return true;
-    bool hasAlwaysVisibleElements = m_highlightNode || m_eventTargetNode || m_highlightQuad  || m_drawViewSize;
+    bool hasAlwaysVisibleElements = m_highlightNode || m_eventTargetNode || m_highlightQuad  || (m_resizeTimerActive && m_drawViewSize);
     bool hasInvisibleInInspectModeElements = !m_pausedInDebuggerMessage.isNull();
     return !(hasAlwaysVisibleElements || (hasInvisibleInInspectModeElements && !m_inspectModeEnabled));
 }
 
 void InspectorOverlayImpl::update()
 {
     if (isEmpty()) {
         if (m_pageOverlay)
             m_pageOverlay.clear();
         return;
@@ skipping 58 matching lines @@
 }
 
 void InspectorOverlayImpl::drawPausedInDebuggerMessage()
 {
     if (!m_pausedInDebuggerMessage.isNull())
         evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
 }
 
 void InspectorOverlayImpl::drawViewSize()
 {
-    if (m_drawViewSize)
+    if (m_resizeTimerActive && m_drawViewSize)
         evaluateInOverlay("drawViewSize", m_drawViewSizeWithGrid ? "true" : "false");
 }
 
 Page* InspectorOverlayImpl::overlayPage()
 {
     if (m_overlayPage)
         return m_overlayPage.get();
 
     ScriptForbiddenScope::AllowUserAgentScript allowScript;
 
@@ skipping 83 matching lines @@
 {
     ScriptForbiddenScope::AllowUserAgentScript allowScript;
     RefPtr<JSONArray> command = JSONArray::create();
     command->pushString(method);
     command->pushValue(argument);
     toLocalFrame(overlayPage()->mainFrame())->script().executeScriptInMainWorld("dispatch(" + command->toJSONString() + ")", ScriptController::ExecuteScriptWhenScriptsDisabled);
 }
 
 void InspectorOverlayImpl::onTimer(Timer<InspectorOverlayImpl>*)
 {
-    m_drawViewSize = false;
+    m_resizeTimerActive = false;
     update();
 }
 
 void InspectorOverlayImpl::clear()
 {
     if (m_overlayPage) {
         m_overlayPage->willBeDestroyed();
         m_overlayPage.clear();
         m_overlayChromeClient.clear();
     }
-    m_drawViewSize = false;
+    m_resizeTimerActive = false;
     m_pausedInDebuggerMessage = String();
     m_inspectModeEnabled = false;
     m_timer.stop();
     hideHighlight();
 }
 
 void InspectorOverlayImpl::overlayResumed()
 {
-    if (m_listener)
-        m_listener->overlayResumed();
+    if (m_debuggerAgent) {
+        ErrorString error;
+        m_debuggerAgent->resume(&error);
+    }
 }
 
 void InspectorOverlayImpl::overlaySteppedOver()
 {
-    if (m_listener)
-        m_listener->overlaySteppedOver();
+    if (m_debuggerAgent) {
+        ErrorString error;
+        m_debuggerAgent->stepOver(&error);
+    }
 }
 
-void InspectorOverlayImpl::suspendUpdates()
+void InspectorOverlayImpl::profilingStarted()
 {
     if (!m_suspendCount++)
         clear();
 }
 
-void InspectorOverlayImpl::resumeUpdates()
+void InspectorOverlayImpl::profilingStopped()
 {
     --m_suspendCount;
 }
 
-void InspectorOverlayImpl::setLayoutEditor(PassOwnPtrWillBeRawPtr<LayoutEditor> layoutEditor)
+void InspectorOverlayImpl::pageLayoutInvalidated(bool resized)
 {
-    m_layoutEditor = layoutEditor;
-    m_overlayHost->setLayoutEditorListener(m_layoutEditor.get());
+    if (resized && m_drawViewSize) {
+        m_resizeTimerActive = true;
+        m_timer.startOneShot(1, FROM_HERE);
+    }
+    update();
+}
+
+void InspectorOverlayImpl::setShowViewportSizeOnResize(bool show, bool showGrid)
+{
+    m_drawViewSize = show;
+    m_drawViewSizeWithGrid = showGrid;
 }
 
 } // namespace blink