[DevTools] Dispatch messages to V8InspectorSession directly.

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 24 matching lines @@
 #include "core/InstrumentingAgents.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/InspectorAnimationAgent.h"
 #include "core/inspector/InspectorApplicationCacheAgent.h"
 #include "core/inspector/InspectorCSSAgent.h"
 #include "core/inspector/InspectorDOMAgent.h"
 #include "core/inspector/InspectorDOMDebuggerAgent.h"
-#include "core/inspector/InspectorDebuggerAgent.h"
-#include "core/inspector/InspectorHeapProfilerAgent.h"
 #include "core/inspector/InspectorInputAgent.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorLayerTreeAgent.h"
 #include "core/inspector/InspectorMemoryAgent.h"
 #include "core/inspector/InspectorPageAgent.h"
-#include "core/inspector/InspectorProfilerAgent.h"
 #include "core/inspector/InspectorResourceAgent.h"
 #include "core/inspector/InspectorResourceContainer.h"
 #include "core/inspector/InspectorResourceContentLoader.h"
-#include "core/inspector/InspectorRuntimeAgent.h"
 #include "core/inspector/InspectorTaskRunner.h"
 #include "core/inspector/InspectorTracingAgent.h"
 #include "core/inspector/InspectorWorkerAgent.h"
 #include "core/inspector/LayoutEditor.h"
 #include "core/inspector/MainThreadDebugger.h"
 #include "core/inspector/PageConsoleAgent.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "modules/accessibility/InspectorAccessibilityAgent.h"
@@ skipping 113 matching lines @@
 
         m_runningForCreateWindow = true;
         if (!m_runningForDebugBreak)
             runLoop(frame);
     }
 
     void runLoop(WebLocalFrameImpl* frame)
     {
         // 0. Flush pending frontend messages.
         WebDevToolsAgentImpl* agent = frame->devToolsAgentImpl();
-        agent->flushPendingProtocolNotifications();
+        agent->flushProtocolNotifications();
 
         Vector<WebViewImpl*> views;
         HeapVector<Member<WebFrameWidgetImpl>> widgets;
 
         // 1. Disable input events.
         const HashSet<WebViewImpl*>& viewImpls = WebViewImpl::allInstances();
         HashSet<WebViewImpl*>::const_iterator viewImplsEnd = viewImpls.end();
         for (HashSet<WebViewImpl*>::const_iterator it =  viewImpls.begin(); it != viewImplsEnd; ++it) {
             WebViewImpl* view = *it;
             m_frozenViews.add(view);
@@ skipping 166 matching lines @@
 }
 
 void WebDevToolsAgentImpl::willBeDestroyed()
 {
     DCHECK(m_webLocalFrameImpl->frame());
     DCHECK(m_inspectedFrames->root()->view());
     detach();
     m_resourceContentLoader->dispose();
 }
 
-void WebDevToolsAgentImpl::initializeSession(int sessionId, const String& hostId)
+void WebDevToolsAgentImpl::initializeSession(int sessionId, const String& hostId, String* state)
 {
-    m_session = new InspectorSession(this, m_inspectedFrames.get(), m_instrumentingAgents.get(), sessionId, false /* autoFlush */);
-
     ClientMessageLoopAdapter::ensureMainThreadDebuggerCreated(m_client);
     MainThreadDebugger* mainThreadDebugger = MainThreadDebugger::instance();
     v8::Isolate* isolate = V8PerIsolateData::mainThreadIsolate();
-    m_v8Session = mainThreadDebugger->debugger()->connect(mainThreadDebugger->contextGroupId(m_inspectedFrames->root()));
 
-    m_session->append(new InspectorRuntimeAgent(m_v8Session->runtimeAgent()));
+    m_session = new InspectorSession(this, m_inspectedFrames.get(), m_instrumentingAgents.get(), sessionId, false /* autoFlush */, mainThreadDebugger->debugger(), mainThreadDebugger->contextGroupId(m_inspectedFrames->root()), state);
 
-    InspectorDOMAgent* domAgent = new InspectorDOMAgent(isolate, m_inspectedFrames.get(), m_v8Session.get(), m_overlay.get());
+    InspectorDOMAgent* domAgent = new InspectorDOMAgent(isolate, m_inspectedFrames.get(), m_session->v8Session(), m_overlay.get());
     m_domAgent = domAgent;
     m_session->append(domAgent);
 
     InspectorLayerTreeAgent* layerTreeAgent = InspectorLayerTreeAgent::create(m_inspectedFrames.get());
     m_layerTreeAgent = layerTreeAgent;
     m_session->append(layerTreeAgent);
 
     InspectorResourceAgent* resourceAgent = InspectorResourceAgent::create(m_inspectedFrames.get());
     m_resourceAgent = resourceAgent;
     m_session->append(resourceAgent);
 
     InspectorCSSAgent* cssAgent = InspectorCSSAgent::create(m_domAgent, m_inspectedFrames.get(), m_resourceAgent, m_resourceContentLoader.get(), m_resourceContainer.get());
     m_session->append(cssAgent);
 
-    m_session->append(new InspectorAnimationAgent(m_inspectedFrames.get(), m_domAgent, cssAgent, m_v8Session.get()));
+    m_session->append(new InspectorAnimationAgent(m_inspectedFrames.get(), m_domAgent, cssAgent, m_session->v8Session()));
 
     m_session->append(InspectorMemoryAgent::create());
 
     m_session->append(InspectorApplicationCacheAgent::create(m_inspectedFrames.get()));
 
     m_session->append(InspectorIndexedDBAgent::create(m_inspectedFrames.get()));
 
-    InspectorDebuggerAgent* debuggerAgent = new InspectorDebuggerAgent(m_v8Session->debuggerAgent());
-    m_session->append(debuggerAgent);
-
-    m_session->append(new PageConsoleAgent(m_v8Session.get(), m_domAgent, m_inspectedFrames.get()));
+    m_session->append(new PageConsoleAgent(m_session->v8Session(), m_domAgent, m_inspectedFrames.get()));
 
     InspectorWorkerAgent* workerAgent = new InspectorWorkerAgent(m_inspectedFrames.get());
     m_session->append(workerAgent);
 
     InspectorTracingAgent* tracingAgent = InspectorTracingAgent::create(this, workerAgent, m_inspectedFrames.get());
     m_tracingAgent = tracingAgent;
     m_session->append(tracingAgent);
 
-    m_session->append(new InspectorDOMDebuggerAgent(isolate, m_domAgent, m_v8Session.get()));
+    m_session->append(new InspectorDOMDebuggerAgent(isolate, m_domAgent, m_session->v8Session()));
 
     m_session->append(InspectorInputAgent::create(m_inspectedFrames.get()));
 
-    m_session->append(new InspectorProfilerAgent(m_v8Session->profilerAgent()));
-
-    m_session->append(new InspectorHeapProfilerAgent(m_v8Session->heapProfilerAgent()));
-
-    InspectorPageAgent* pageAgent = InspectorPageAgent::create(m_inspectedFrames.get(), this, m_resourceContentLoader.get(), m_v8Session.get());
+    InspectorPageAgent* pageAgent = InspectorPageAgent::create(m_inspectedFrames.get(), this, m_resourceContentLoader.get(), m_session->v8Session());
     m_pageAgent = pageAgent;
     m_session->append(pageAgent);
 
     m_tracingAgent->setLayerTreeId(m_layerTreeId);
     m_resourceAgent->setHostId(hostId);
 
     if (m_includeViewAgents) {
         // 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.
         m_session->append(InspectorRenderingAgent::create(m_webLocalFrameImpl, m_overlay.get()));
         m_session->append(InspectorEmulationAgent::create(m_webLocalFrameImpl, this));
         // TODO(dgozman): migrate each of the following agents to frame once module is ready.
         Page* page = m_webLocalFrameImpl->viewImpl()->page();
         m_session->append(InspectorDatabaseAgent::create(page));
         m_session->append(DeviceOrientationInspectorAgent::create(page));
         m_session->append(new InspectorAccessibilityAgent(page, m_domAgent));
         m_session->append(InspectorDOMStorageAgent::create(page));
         m_session->append(InspectorCacheStorageAgent::create());
     }
 
     if (m_overlay)
-        m_overlay->init(cssAgent, debuggerAgent, m_domAgent);
+        m_overlay->init(cssAgent, m_session->v8Session(), m_domAgent);
 
     Platform::current()->currentThread()->addTaskObserver(this);
 }
 
 void WebDevToolsAgentImpl::destroySession()
 {
     if (m_overlay)
         m_overlay->clear();
 
     m_tracingAgent.clear();
     m_layerTreeAgent.clear();
     m_resourceAgent.clear();
     m_pageAgent.clear();
     m_domAgent.clear();
 
-    m_session->detach();
-    m_v8Session.clear();
+    m_session->dispose();
     m_session.clear();
 
     Platform::current()->currentThread()->removeTaskObserver(this);
 }
 
 void WebDevToolsAgentImpl::attach(const WebString& hostId, int sessionId)
 {
     if (attached())
         return;
-    initializeSession(sessionId, hostId);
-    m_session->attach(m_v8Session.get(), nullptr);
+    initializeSession(sessionId, hostId, nullptr);
 }
 
 void WebDevToolsAgentImpl::reattach(const WebString& hostId, int sessionId, const WebString& savedState)
 {
     if (attached())
         return;
-    initializeSession(sessionId, hostId);
     String state = savedState;
-    m_session->attach(m_v8Session.get(), &state);
+    initializeSession(sessionId, hostId, &state);
+    m_session->restore();
 }
 
 void WebDevToolsAgentImpl::detach()
 {
     if (!attached())
         return;
     destroySession();
 }
 
 void WebDevToolsAgentImpl::continueProgram()
@@ skipping 48 matching lines @@
     m_client->setCPUThrottlingRate(rate);
 }
 
 void WebDevToolsAgentImpl::dispatchOnInspectorBackend(int sessionId, int callId, const WebString& method, const WebString& message)
 {
     if (!attached())
         return;
     if (WebDevToolsAgent::shouldInterruptForMethod(method))
         MainThreadDebugger::instance()->taskRunner()->runAllTasksDontWait();
     else
-        dispatchMessageFromFrontend(sessionId, message);
+        dispatchMessageFromFrontend(sessionId, method, message);
 }
 
-void WebDevToolsAgentImpl::dispatchMessageFromFrontend(int sessionId, const String& message)
+void WebDevToolsAgentImpl::dispatchMessageFromFrontend(int sessionId, const String& method, const String& message)
 {
     if (!attached() || sessionId != m_session->sessionId())
         return;
     InspectorTaskRunner::IgnoreInterruptsScope scope(MainThreadDebugger::instance()->taskRunner());
-    m_session->dispatchProtocolMessage(message);
+    m_session->dispatchProtocolMessage(method, message);
 }
 
 void WebDevToolsAgentImpl::inspectElementAt(const WebPoint& pointInRootFrame)
 {
     if (!m_domAgent)
         return;
     HitTestRequest::HitTestRequestType hitType = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::AllowChildFrameContent;
     HitTestRequest request(hitType);
     WebMouseEvent dummyEvent;
     dummyEvent.type = WebInputEvent::MouseDown;
@@ skipping 61 matching lines @@
 }
 
 WebString WebDevToolsAgentImpl::evaluateInWebInspectorOverlay(const WebString& script)
 {
     if (!m_overlay)
         return WebString();
 
     return m_overlay->evaluateInOverlayForTest(script);
 }
 
-void WebDevToolsAgentImpl::flushPendingProtocolNotifications()
+void WebDevToolsAgentImpl::flushProtocolNotifications()
 {
     if (m_session)
-        m_session->flushPendingProtocolNotifications();
+        m_session->flushProtocolNotifications();
 }
 
 void WebDevToolsAgentImpl::willProcessTask()
 {
     if (!attached())
         return;
     ThreadDebugger::idleFinished(V8PerIsolateData::mainThreadIsolate());
 }
 
 void WebDevToolsAgentImpl::didProcessTask()
 {
     if (!attached())
         return;
     ThreadDebugger::idleStarted(V8PerIsolateData::mainThreadIsolate());
-    flushPendingProtocolNotifications();
+    flushProtocolNotifications();
 }
 
 void WebDevToolsAgentImpl::runDebuggerTask(int sessionId, PassOwnPtr<WebDevToolsAgent::MessageDescriptor> descriptor)
 {
     WebDevToolsAgent* webagent = descriptor->agent();
     if (!webagent)
         return;
 
     WebDevToolsAgentImpl* agentImpl = static_cast<WebDevToolsAgentImpl*>(webagent);
     if (agentImpl->attached())
-        agentImpl->dispatchMessageFromFrontend(sessionId, descriptor->message());
+        agentImpl->dispatchMessageFromFrontend(sessionId, descriptor->method(), descriptor->message());
 }
 
 void WebDevToolsAgent::interruptAndDispatch(int sessionId, MessageDescriptor* rawDescriptor)
 {
     // rawDescriptor can't be a PassOwnPtr because interruptAndDispatch is a WebKit API function.
     MainThreadDebugger::interruptMainThreadAndRun(threadSafeBind(WebDevToolsAgentImpl::runDebuggerTask, sessionId, passed(adoptPtr(rawDescriptor))));
 }
 
 bool WebDevToolsAgent::shouldInterruptForMethod(const WebString& method)
 {
     return method == "Debugger.pause"
         || method == "Debugger.setBreakpoint"
         || method == "Debugger.setBreakpointByUrl"
         || method == "Debugger.removeBreakpoint"
         || method == "Debugger.setBreakpointsActive";
 }
 
 } // namespace blink