Revert of [DevTools] Consolidate overlay-related functionality in Overlay domain

third_party/WebKit/Source/web/WebDevToolsAgentImpl.cpp

 /*
  * Copyright (C) 2010-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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 66 matching lines @@
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/text/WTFString.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebLayerTreeView.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebString.h"
 #include "public/web/WebDevToolsAgentClient.h"
 #include "public/web/WebSettings.h"
 #include "web/DevToolsEmulator.h"
 #include "web/InspectorEmulationAgent.h"
-#include "web/InspectorOverlayAgent.h"
+#include "web/InspectorOverlay.h"
+#include "web/InspectorRenderingAgent.h"
 #include "web/WebFrameWidgetImpl.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebSettingsImpl.h"
 #include "web/WebViewImpl.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 127 matching lines @@
 
   static ClientMessageLoopAdapter* instance_;
 };
 
 ClientMessageLoopAdapter* ClientMessageLoopAdapter::instance_ = nullptr;
 
 // static
 WebDevToolsAgentImpl* WebDevToolsAgentImpl::Create(
     WebLocalFrameImpl* frame,
     WebDevToolsAgentClient* client) {
+  InspectorOverlay* overlay = new InspectorOverlay(frame);
+
   if (!IsMainFrame(frame)) {
     WebDevToolsAgentImpl* agent =
-        new WebDevToolsAgentImpl(frame, client, false);
+        new WebDevToolsAgentImpl(frame, client, overlay, false);
     if (frame->FrameWidget())
       agent->LayerTreeViewChanged(
           ToWebFrameWidgetImpl(frame->FrameWidget())->LayerTreeView());
     return agent;
   }
 
   WebViewImpl* view = frame->ViewImpl();
-  WebDevToolsAgentImpl* agent = new WebDevToolsAgentImpl(frame, client, true);
+  WebDevToolsAgentImpl* agent =
+      new WebDevToolsAgentImpl(frame, client, overlay, true);
   agent->LayerTreeViewChanged(view->LayerTreeView());
   return agent;
 }
 
 WebDevToolsAgentImpl::WebDevToolsAgentImpl(
     WebLocalFrameImpl* web_local_frame_impl,
     WebDevToolsAgentClient* client,
+    InspectorOverlay* overlay,
     bool include_view_agents)
     : client_(client),
       web_local_frame_impl_(web_local_frame_impl),
       instrumenting_agents_(
           web_local_frame_impl_->GetFrame()->InstrumentingAgents()),
       resource_content_loader_(InspectorResourceContentLoader::Create(
           web_local_frame_impl_->GetFrame())),
+      overlay_(overlay),
       inspected_frames_(
           InspectedFrames::Create(web_local_frame_impl_->GetFrame())),
       resource_container_(new InspectorResourceContainer(inspected_frames_)),
+      dom_agent_(nullptr),
       page_agent_(nullptr),
       network_agent_(nullptr),
       layer_tree_agent_(nullptr),
       tracing_agent_(nullptr),
       trace_events_agent_(new InspectorTraceEvents()),
-      overlay_agent_(nullptr),
       include_view_agents_(include_view_agents),
       layer_tree_id_(0) {
   DCHECK(IsMainThread());
   DCHECK(web_local_frame_impl_->GetFrame());
   instrumenting_agents_->addInspectorTraceEvents(trace_events_agent_);
 }
 
 WebDevToolsAgentImpl::~WebDevToolsAgentImpl() {
   DCHECK(!client_);
 }
 
 DEFINE_TRACE(WebDevToolsAgentImpl) {
   visitor->Trace(web_local_frame_impl_);
   visitor->Trace(instrumenting_agents_);
   visitor->Trace(resource_content_loader_);
+  visitor->Trace(overlay_);
   visitor->Trace(inspected_frames_);
   visitor->Trace(resource_container_);
+  visitor->Trace(dom_agent_);
   visitor->Trace(page_agent_);
   visitor->Trace(network_agent_);
   visitor->Trace(layer_tree_agent_);
   visitor->Trace(tracing_agent_);
   visitor->Trace(trace_events_agent_);
-  visitor->Trace(overlay_agent_);
   visitor->Trace(session_);
 }
 
 void WebDevToolsAgentImpl::WillBeDestroyed() {
   DCHECK(web_local_frame_impl_->GetFrame());
   DCHECK(inspected_frames_->Root()->View());
   instrumenting_agents_->removeInspectorTraceEvents(trace_events_agent_);
   trace_events_agent_ = nullptr;
   Detach();
   resource_content_loader_->Dispose();
   client_ = nullptr;
 }
 
 void WebDevToolsAgentImpl::InitializeSession(int session_id,
                                              const String& host_id,
                                              String* state) {
   DCHECK(client_);
   ClientMessageLoopAdapter::EnsureMainThreadDebuggerCreated(client_);
   MainThreadDebugger* main_thread_debugger = MainThreadDebugger::Instance();
   v8::Isolate* isolate = V8PerIsolateData::MainThreadIsolate();
 
   session_ = new InspectorSession(
       this, instrumenting_agents_.Get(), session_id,
       main_thread_debugger->GetV8Inspector(),
       main_thread_debugger->ContextGroupId(inspected_frames_->Root()), state);
 
   InspectorDOMAgent* dom_agent = new InspectorDOMAgent(
-      isolate, inspected_frames_.Get(), session_->V8Session());
+      isolate, inspected_frames_.Get(), session_->V8Session(), overlay_.Get());
+  dom_agent_ = dom_agent;
   session_->Append(dom_agent);
 
   InspectorLayerTreeAgent* layer_tree_agent =
       InspectorLayerTreeAgent::Create(inspected_frames_.Get());
   layer_tree_agent_ = layer_tree_agent;
   session_->Append(layer_tree_agent);
 
   InspectorNetworkAgent* network_agent =
       InspectorNetworkAgent::Create(inspected_frames_.Get());
   network_agent_ = network_agent;
   session_->Append(network_agent);
 
   InspectorCSSAgent* css_agent = InspectorCSSAgent::Create(
-      dom_agent, inspected_frames_.Get(), network_agent_,
+      dom_agent_, inspected_frames_.Get(), network_agent_,
       resource_content_loader_.Get(), resource_container_.Get());
   session_->Append(css_agent);
 
   session_->Append(new InspectorAnimationAgent(
       inspected_frames_.Get(), css_agent, session_->V8Session()));
 
   session_->Append(InspectorMemoryAgent::Create());
 
   session_->Append(
       InspectorApplicationCacheAgent::Create(inspected_frames_.Get()));
 
   session_->Append(new InspectorIndexedDBAgent(inspected_frames_.Get(),
                                                session_->V8Session()));
 
   InspectorWorkerAgent* worker_agent =
       new InspectorWorkerAgent(inspected_frames_.Get());
   session_->Append(worker_agent);
 
   InspectorTracingAgent* tracing_agent = InspectorTracingAgent::Create(
       this, worker_agent, inspected_frames_.Get());
   tracing_agent_ = tracing_agent;
   session_->Append(tracing_agent);
 
-  session_->Append(
-      new InspectorDOMDebuggerAgent(isolate, dom_agent, session_->V8Session()));
+  session_->Append(new InspectorDOMDebuggerAgent(isolate, dom_agent_,
+                                                 session_->V8Session()));
 
   session_->Append(InspectorInputAgent::Create(inspected_frames_.Get()));
 
   InspectorPageAgent* page_agent = InspectorPageAgent::Create(
       inspected_frames_.Get(), this, resource_content_loader_.Get(),
       session_->V8Session());
   page_agent_ = page_agent;
   session_->Append(page_agent);
 
   session_->Append(new InspectorLogAgent(
       &inspected_frames_->Root()->GetPage()->GetConsoleMessageStorage(),
       inspected_frames_->Root()->GetPerformanceMonitor()));
 
   session_->Append(
       new DeviceOrientationInspectorAgent(inspected_frames_.Get()));
 
-  InspectorOverlayAgent* overlay_agent =
-      new InspectorOverlayAgent(web_local_frame_impl_, inspected_frames_.Get(),
-                                session_->V8Session(), dom_agent);
-  overlay_agent_ = overlay_agent;
-  session_->Append(overlay_agent);
-
   tracing_agent_->SetLayerTreeId(layer_tree_id_);
   network_agent_->SetHostId(host_id);
 
   if (include_view_agents_) {
     // TODO(dgozman): we should actually pass the view instead of frame, but
     // during remote->local transition we cannot access mainFrameImpl() yet, so
     // we have to store the frame which will become the main frame later.
     session_->Append(
+        InspectorRenderingAgent::Create(web_local_frame_impl_, overlay_.Get()));
+    session_->Append(
         InspectorEmulationAgent::Create(web_local_frame_impl_, this));
     // TODO(dgozman): migrate each of the following agents to frame once module
     // is ready.
     Page* page = web_local_frame_impl_->ViewImpl()->GetPage();
     session_->Append(InspectorDatabaseAgent::Create(page));
-    session_->Append(new InspectorAccessibilityAgent(page, dom_agent));
+    session_->Append(new InspectorAccessibilityAgent(page, dom_agent_));
     session_->Append(InspectorDOMStorageAgent::Create(page));
     session_->Append(InspectorCacheStorageAgent::Create());
   }
 
+  if (overlay_)
+    overlay_->Init(session_->V8Session(), dom_agent_);
+
   Platform::Current()->CurrentThread()->AddTaskObserver(this);
 }
 
 void WebDevToolsAgentImpl::DestroySession() {
-  overlay_agent_.Clear();
+  if (overlay_)
+    overlay_->Clear();
+
   tracing_agent_.Clear();
   layer_tree_agent_.Clear();
   network_agent_.Clear();
   page_agent_.Clear();
+  dom_agent_.Clear();
 
   session_->Dispose();
   session_.Clear();
 
   Platform::Current()->CurrentThread()->RemoveTaskObserver(this);
 }
 
 void WebDevToolsAgentImpl::Attach(const WebString& host_id, int session_id) {
   if (Attached())
     return;
@@ skipping 62 matching lines @@
   if (client_)
     client_->EnableTracing(category_filter);
 }
 
 void WebDevToolsAgentImpl::DisableTracing() {
   if (client_)
     client_->DisableTracing();
 }
 
 void WebDevToolsAgentImpl::ShowReloadingBlanket() {
-  if (overlay_agent_)
-    overlay_agent_->ShowReloadingBlanket();
+  if (overlay_)
+    overlay_->ShowReloadingBlanket();
 }
 
 void WebDevToolsAgentImpl::HideReloadingBlanket() {
-  if (overlay_agent_)
-    overlay_agent_->HideReloadingBlanket();
+  if (overlay_)
+    overlay_->HideReloadingBlanket();
 }
 
 void WebDevToolsAgentImpl::SetCPUThrottlingRate(double rate) {
   if (client_)
     client_->SetCPUThrottlingRate(rate);
 }
 
 void WebDevToolsAgentImpl::DispatchOnInspectorBackend(
     int session_id,
     int call_id,
@@ skipping 13 matching lines @@
   if (!Attached() || session_id != session_->SessionId())
     return;
   InspectorTaskRunner::IgnoreInterruptsScope scope(
       MainThreadDebugger::Instance()->TaskRunner());
   session_->DispatchProtocolMessage(method, message);
 }
 
 void WebDevToolsAgentImpl::InspectElementAt(
     int session_id,
     const WebPoint& point_in_root_frame) {
-  if (!overlay_agent_ || !session_ || session_->SessionId() != session_id)
+  if (!dom_agent_ || !session_ || session_->SessionId() != session_id)
     return;
   HitTestRequest::HitTestRequestType hit_type =
       HitTestRequest::kMove | HitTestRequest::kReadOnly |
       HitTestRequest::kAllowChildFrameContent;
   HitTestRequest request(hit_type);
   WebMouseEvent dummy_event(WebInputEvent::kMouseDown,
                             WebInputEvent::kNoModifiers,
                             WTF::MonotonicallyIncreasingTimeMS());
   dummy_event.SetPositionInWidget(point_in_root_frame.x, point_in_root_frame.y);
   IntPoint transformed_point = FlooredIntPoint(
       TransformWebMouseEvent(web_local_frame_impl_->GetFrameView(), dummy_event)
           .PositionInRootFrame());
   HitTestResult result(
       request, web_local_frame_impl_->GetFrameView()->RootFrameToContents(
                    transformed_point));
   web_local_frame_impl_->GetFrame()->ContentLayoutItem().HitTest(result);
   Node* node = result.InnerNode();
   if (!node && web_local_frame_impl_->GetFrame()->GetDocument())
     node = web_local_frame_impl_->GetFrame()->GetDocument()->documentElement();
-  overlay_agent_->Inspect(node);
+  dom_agent_->Inspect(node);
 }
 
 void WebDevToolsAgentImpl::FailedToRequestDevTools() {
   ClientMessageLoopAdapter::ResumeForCreateWindow();
 }
 
 void WebDevToolsAgentImpl::SendProtocolMessage(int session_id,
                                                int call_id,
                                                const String& response,
                                                const String& state) {
   ASSERT(Attached());
   if (client_)
     client_->SendProtocolMessage(session_id, call_id, response, state);
 }
 
 void WebDevToolsAgentImpl::PageLayoutInvalidated(bool resized) {
-  if (overlay_agent_)
-    overlay_agent_->PageLayoutInvalidated(resized);
+  if (overlay_)
+    overlay_->PageLayoutInvalidated(resized);
+}
+
+void WebDevToolsAgentImpl::ConfigureOverlay(bool suspended,
+                                            const String& message) {
+  if (!overlay_)
+    return;
+  overlay_->SetPausedInDebuggerMessage(message);
+  if (suspended)
+    overlay_->Suspend();
+  else
+    overlay_->Resume();
 }
 
 void WebDevToolsAgentImpl::WaitForCreateWindow(LocalFrame* frame) {
   if (!Attached())
     return;
   if (client_ &&
       client_->RequestDevToolsForFrame(WebLocalFrameImpl::FromFrame(frame)))
     ClientMessageLoopAdapter::PauseForCreateWindow(web_local_frame_impl_);
 }
 
 WebString WebDevToolsAgentImpl::EvaluateInWebInspectorOverlay(
     const WebString& script) {
-  if (!overlay_agent_)
+  if (!overlay_)
     return WebString();
 
-  return overlay_agent_->EvaluateInOverlayForTest(script);
+  return overlay_->EvaluateInOverlayForTest(script);
 }
 
 bool WebDevToolsAgentImpl::CacheDisabled() {
   if (!network_agent_)
     return false;
   return network_agent_->CacheDisabled();
 }
 
 void WebDevToolsAgentImpl::FlushProtocolNotifications() {
   if (session_)
@@ skipping 37 matching lines @@
 }
 
 bool WebDevToolsAgent::ShouldInterruptForMethod(const WebString& method) {
   return method == "Debugger.pause" || method == "Debugger.setBreakpoint" ||
          method == "Debugger.setBreakpointByUrl" ||
          method == "Debugger.removeBreakpoint" ||
          method == "Debugger.setBreakpointsActive";
 }
 
 }  // namespace blink