[DevTools] Introduce InspectorSession.

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 282 matching lines @@
     return agent;
 }
 
 WebDevToolsAgentImpl::WebDevToolsAgentImpl(
     WebLocalFrameImpl* webLocalFrameImpl,
     WebDevToolsAgentClient* client,
     InspectorOverlay* overlay,
     bool includeViewAgents)
     : m_client(client)
     , m_webLocalFrameImpl(webLocalFrameImpl)
-    , m_attached(false)
 #if DCHECK_IS_ON()
     , m_hasBeenDisposed(false)
 #endif
     , m_instrumentingAgents(m_webLocalFrameImpl->frame()->instrumentingAgents())
     , m_resourceContentLoader(InspectorResourceContentLoader::create(m_webLocalFrameImpl->frame()))
     , m_overlay(overlay)
     , m_inspectedFrames(InspectedFrames::create(m_webLocalFrameImpl->frame()))
     , m_resourceContainer(new InspectorResourceContainer(m_inspectedFrames))
     , m_domAgent(nullptr)
     , m_pageAgent(nullptr)
     , m_resourceAgent(nullptr)
     , m_layerTreeAgent(nullptr)
     , m_tracingAgent(nullptr)
-    , m_agents(m_instrumentingAgents.get())
     , m_includeViewAgents(includeViewAgents)
-    , m_sessionId(0)
-    , m_stateMuted(false)
     , m_layerTreeId(0)
 {
     DCHECK(isMainThread());
     DCHECK(m_webLocalFrameImpl->frame());
 }
 
 WebDevToolsAgentImpl::~WebDevToolsAgentImpl()
 {
 #if DCHECK_IS_ON()
     DCHECK(m_hasBeenDisposed);
 #endif
 }
 
 void WebDevToolsAgentImpl::dispose()
 {
     // Explicitly dispose of the agent before destructing to ensure
     // same behavior (and correctness) with and without Oilpan.
-    if (m_attached)
+    if (attached())
         Platform::current()->currentThread()->removeTaskObserver(this);
 #if DCHECK_IS_ON()
     DCHECK(!m_hasBeenDisposed);
     m_hasBeenDisposed = true;
 #endif
 }
 
 // static
 void WebDevToolsAgentImpl::webViewImplClosed(WebViewImpl* webViewImpl)
 {
@@ skipping 12 matching lines @@
     visitor->trace(m_instrumentingAgents);
     visitor->trace(m_resourceContentLoader);
     visitor->trace(m_overlay);
     visitor->trace(m_inspectedFrames);
     visitor->trace(m_resourceContainer);
     visitor->trace(m_domAgent);
     visitor->trace(m_pageAgent);
     visitor->trace(m_resourceAgent);
     visitor->trace(m_layerTreeAgent);
     visitor->trace(m_tracingAgent);
-    visitor->trace(m_agents);
+    visitor->trace(m_session);
 }
 
 void WebDevToolsAgentImpl::willBeDestroyed()
 {
     DCHECK(m_webLocalFrameImpl->frame());
     DCHECK(m_inspectedFrames->root()->view());
-
     detach();
     m_resourceContentLoader->dispose();
-    m_agents.discardAgents();
-    m_instrumentingAgents->reset();
-    m_v8Session.clear();
 }
 
-void WebDevToolsAgentImpl::initializeAgents()
+void WebDevToolsAgentImpl::initializeSession(int sessionId, const String& hostId)
 {
+    m_session = new InspectorSession(this, sessionId, m_instrumentingAgents.get(), 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()));
     V8RuntimeAgent* runtimeAgent = m_v8Session->runtimeAgent();
 
-    m_agents.append(PageRuntimeAgent::create(this, runtimeAgent, m_inspectedFrames.get()));
+    m_session->append(PageRuntimeAgent::create(this, runtimeAgent, m_inspectedFrames.get()));
 
     InspectorDOMAgent* domAgent = InspectorDOMAgent::create(isolate, m_inspectedFrames.get(), runtimeAgent, m_overlay.get());
     m_domAgent = domAgent;
-    m_agents.append(domAgent);
+    m_session->append(domAgent);
 
     InspectorLayerTreeAgent* layerTreeAgent = InspectorLayerTreeAgent::create(m_inspectedFrames.get());
     m_layerTreeAgent = layerTreeAgent;
-    m_agents.append(layerTreeAgent);
+    m_session->append(layerTreeAgent);
 
     InspectorResourceAgent* resourceAgent = InspectorResourceAgent::create(m_inspectedFrames.get());
     m_resourceAgent = resourceAgent;
-    m_agents.append(resourceAgent);
+    m_session->append(resourceAgent);
 
     InspectorCSSAgent* cssAgent = InspectorCSSAgent::create(m_domAgent, m_inspectedFrames.get(), m_resourceAgent, m_resourceContentLoader.get(), m_resourceContainer.get());
-    m_agents.append(cssAgent);
+    m_session->append(cssAgent);
 
-    m_agents.append(InspectorAnimationAgent::create(m_inspectedFrames.get(), m_domAgent, cssAgent, runtimeAgent));
+    m_session->append(InspectorAnimationAgent::create(m_inspectedFrames.get(), m_domAgent, cssAgent, runtimeAgent));
 
-    m_agents.append(InspectorMemoryAgent::create());
+    m_session->append(InspectorMemoryAgent::create());
 
-    m_agents.append(InspectorApplicationCacheAgent::create(m_inspectedFrames.get()));
+    m_session->append(InspectorApplicationCacheAgent::create(m_inspectedFrames.get()));
 
-    m_agents.append(InspectorIndexedDBAgent::create(m_inspectedFrames.get()));
+    m_session->append(InspectorIndexedDBAgent::create(m_inspectedFrames.get()));
 
     InspectorDebuggerAgent* debuggerAgent = PageDebuggerAgent::create(m_v8Session->debuggerAgent(), m_inspectedFrames.get());
-    m_agents.append(debuggerAgent);
+    m_session->append(debuggerAgent);
 
     PageConsoleAgent* pageConsoleAgent = PageConsoleAgent::create(runtimeAgent, m_v8Session->debuggerAgent(), m_domAgent, m_inspectedFrames.get());
-    m_agents.append(pageConsoleAgent);
+    m_session->append(pageConsoleAgent);
 
     InspectorWorkerAgent* workerAgent = InspectorWorkerAgent::create(m_inspectedFrames.get(), pageConsoleAgent);
-    m_agents.append(workerAgent);
+    m_session->append(workerAgent);
 
     InspectorTracingAgent* tracingAgent = InspectorTracingAgent::create(this, workerAgent, m_inspectedFrames.get());
     m_tracingAgent = tracingAgent;
-    m_agents.append(tracingAgent);
+    m_session->append(tracingAgent);
 
-    m_agents.append(InspectorDOMDebuggerAgent::create(isolate, m_domAgent, runtimeAgent, debuggerAgent->v8Agent()));
+    m_session->append(InspectorDOMDebuggerAgent::create(isolate, m_domAgent, runtimeAgent, debuggerAgent->v8Agent()));
 
-    m_agents.append(InspectorInputAgent::create(m_inspectedFrames.get()));
+    m_session->append(InspectorInputAgent::create(m_inspectedFrames.get()));
 
-    m_agents.append(InspectorProfilerAgent::create(m_v8Session->profilerAgent(), m_overlay.get()));
+    m_session->append(InspectorProfilerAgent::create(m_v8Session->profilerAgent(), m_overlay.get()));
 
-    m_agents.append(InspectorHeapProfilerAgent::create(isolate, m_v8Session->heapProfilerAgent()));
+    m_session->append(InspectorHeapProfilerAgent::create(isolate, m_v8Session->heapProfilerAgent()));
 
     InspectorPageAgent* pageAgent = InspectorPageAgent::create(m_inspectedFrames.get(), this, m_resourceContentLoader.get(), debuggerAgent);
     m_pageAgent = pageAgent;
-    m_agents.append(pageAgent);
+    m_session->append(pageAgent);
 
     runtimeAgent->setClearConsoleCallback(bind<>(&InspectorConsoleAgent::clearAllMessages, pageConsoleAgent));
     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_agents.append(InspectorRenderingAgent::create(m_webLocalFrameImpl, m_overlay.get()));
-        m_agents.append(InspectorEmulationAgent::create(m_webLocalFrameImpl, this));
+        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_agents.append(InspectorDatabaseAgent::create(page));
-        m_agents.append(DeviceOrientationInspectorAgent::create(page));
-        m_agents.append(InspectorAccessibilityAgent::create(page));
-        m_agents.append(InspectorDOMStorageAgent::create(page));
-        m_agents.append(InspectorCacheStorageAgent::create());
+        m_session->append(InspectorDatabaseAgent::create(page));
+        m_session->append(DeviceOrientationInspectorAgent::create(page));
+        m_session->append(InspectorAccessibilityAgent::create(page));
+        m_session->append(InspectorDOMStorageAgent::create(page));
+        m_session->append(InspectorCacheStorageAgent::create());
     }
 
     if (m_overlay)
         m_overlay->init(cssAgent, debuggerAgent, m_domAgent);
+
+    Platform::current()->currentThread()->addTaskObserver(this);
+    InspectorInstrumentation::registerInstrumentingAgents(m_instrumentingAgents.get());
 }
 
-void WebDevToolsAgentImpl::destroyAgents()
+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_agents.discardAgents();
-    m_instrumentingAgents->reset();
+    m_session->detach();
     m_v8Session.clear();
+    m_session.clear();
+
+    Platform::current()->currentThread()->removeTaskObserver(this);
+    InspectorInstrumentation::unregisterInstrumentingAgents(m_instrumentingAgents.get());
 }
 
 void WebDevToolsAgentImpl::attach(const WebString& hostId, int sessionId)
 {
-    if (m_attached)
+    if (attached())
         return;
-
-    // Set the attached bit first so that sync notifications were delivered.
-    m_attached = true;
-    m_sessionId = sessionId;
-
-    initializeAgents();
-    m_resourceAgent->setHostId(hostId);
-
-    m_inspectorFrontend = adoptPtr(new protocol::Frontend(this));
-    // We can reconnect to existing front-end -> unmute state.
-    m_stateMuted = false;
-    m_agents.setFrontend(m_inspectorFrontend.get());
-
-    InspectorInstrumentation::registerInstrumentingAgents(m_instrumentingAgents.get());
-    InspectorInstrumentation::frontendCreated();
-
-    m_inspectorBackendDispatcher = protocol::Dispatcher::create(this);
-    m_agents.registerInDispatcher(m_inspectorBackendDispatcher.get());
-
-    Platform::current()->currentThread()->addTaskObserver(this);
+    initializeSession(sessionId, hostId);
+    m_session->attach(nullptr);
 }
 
 void WebDevToolsAgentImpl::reattach(const WebString& hostId, int sessionId, const WebString& savedState)
 {
-    if (m_attached)
+    if (attached())
         return;
-
-    attach(hostId, sessionId);
-    m_agents.restore(savedState);
+    initializeSession(sessionId, hostId);
+    String state = savedState;
+    m_session->attach(&state);
 }
 
 void WebDevToolsAgentImpl::detach()
 {
-    if (!m_attached)
+    if (!attached())
         return;
-
-    Platform::current()->currentThread()->removeTaskObserver(this);
-
-    m_inspectorBackendDispatcher->clearFrontend();
-    m_inspectorBackendDispatcher.clear();
-
-    // Destroying agents would change the state, but we don't want that.
-    // Pre-disconnect state will be used to restore inspector agents.
-    m_stateMuted = true;
-    m_agents.clearFrontend();
-    m_inspectorFrontend.clear();
-
-    destroyAgents();
-    InspectorInstrumentation::frontendDeleted();
-    InspectorInstrumentation::unregisterInstrumentingAgents(m_instrumentingAgents.get());
-
-    m_sessionId = 0;
-    m_attached = false;
+    destroySession();
 }
 
 void WebDevToolsAgentImpl::continueProgram()
 {
     ClientMessageLoopAdapter::continueProgram();
 }
 
 void WebDevToolsAgentImpl::didCommitLoadForLocalFrame(LocalFrame* frame)
 {
     m_resourceContainer->didCommitLoadForLocalFrame(frame);
     m_resourceContentLoader->didCommitLoadForLocalFrame(frame);
-    m_agents.didCommitLoadForLocalFrame(frame);
+    if (m_session)
+        m_session->didCommitLoadForLocalFrame(frame);
 }
 
 bool WebDevToolsAgentImpl::screencastEnabled()
 {
     return m_pageAgent && m_pageAgent->screencastEnabled();
 }
 
 void WebDevToolsAgentImpl::willAddPageOverlay(const GraphicsLayer* layer)
 {
     if (m_layerTreeAgent)
@@ skipping 23 matching lines @@
     m_client->disableTracing();
 }
 
 void WebDevToolsAgentImpl::setCPUThrottlingRate(double rate)
 {
     m_client->setCPUThrottlingRate(rate);
 }
 
 void WebDevToolsAgentImpl::dispatchOnInspectorBackend(int sessionId, const WebString& message)
 {
-    if (!m_attached)
+    if (!attached())
         return;
     if (WebDevToolsAgent::shouldInterruptForMessage(message))
         MainThreadDebugger::instance()->taskRunner()->runAllTasksDontWait();
     else
         dispatchMessageFromFrontend(sessionId, message);
 }
 
 void WebDevToolsAgentImpl::dispatchMessageFromFrontend(int sessionId, const String& message)
 {
+    if (!attached() || sessionId != m_session->sessionId())
+        return;
     InspectorTaskRunner::IgnoreInterruptsScope scope(MainThreadDebugger::instance()->taskRunner());
-    if (m_inspectorBackendDispatcher)
-        m_inspectorBackendDispatcher->dispatch(sessionId, message);
+    m_session->dispatchProtocolMessage(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;
     dummyEvent.x = pointInRootFrame.x;
     dummyEvent.y = pointInRootFrame.y;
     IntPoint transformedPoint = PlatformMouseEventBuilder(m_webLocalFrameImpl->frameView(), dummyEvent).position();
     HitTestResult result(request, m_webLocalFrameImpl->frameView()->rootFrameToContents(transformedPoint));
     m_webLocalFrameImpl->frame()->contentLayoutItem().hitTest(result);
     Node* node = result.innerNode();
     if (!node && m_webLocalFrameImpl->frame()->document())
         node = m_webLocalFrameImpl->frame()->document()->documentElement();
     m_domAgent->inspect(node);
 }
 
 void WebDevToolsAgentImpl::failedToRequestDevTools()
 {
     ClientMessageLoopAdapter::resumeForCreateWindow();
 }
 
-void WebDevToolsAgentImpl::sendProtocolResponse(int sessionId, int callId, PassOwnPtr<protocol::DictionaryValue> message)
+void WebDevToolsAgentImpl::sendProtocolMessage(int sessionId, int callId, const String& response, const String& state)
 {
-    if (!m_attached)
-        return;
-    flushPendingProtocolNotifications();
-    String stateToSend;
-    if (!m_stateMuted) {
-        stateToSend = m_agents.state();
-        if (stateToSend == m_stateCookie)
-            stateToSend = String();
-        else
-            m_stateCookie = stateToSend;
-    }
-
-    m_client->sendProtocolMessage(sessionId, callId, message->toJSONString(), stateToSend);
-}
-
-void WebDevToolsAgentImpl::sendProtocolNotification(PassOwnPtr<protocol::DictionaryValue> message)
-{
-    if (!m_attached)
-        return;
-    m_notificationQueue.append(std::make_pair(m_sessionId, message));
-}
-
-void WebDevToolsAgentImpl::flush()
-{
-    flushPendingProtocolNotifications();
+    ASSERT(attached());
+    m_client->sendProtocolMessage(sessionId, callId, response, state);
 }
 
 void WebDevToolsAgentImpl::resumeStartup()
 {
     // If we've paused for createWindow, handle it ourselves.
     if (ClientMessageLoopAdapter::resumeForCreateWindow())
         return;
     // Otherwise, pass to the client (embedded workers do it differently).
     m_client->resumeStartup();
 }
 
 void WebDevToolsAgentImpl::pageLayoutInvalidated(bool resized)
 {
     if (m_overlay)
         m_overlay->pageLayoutInvalidated(resized);
 }
 
 void WebDevToolsAgentImpl::setPausedInDebuggerMessage(const String& message)
 {
     if (m_overlay)
         m_overlay->setPausedInDebuggerMessage(message);
 }
 
 void WebDevToolsAgentImpl::waitForCreateWindow(LocalFrame* frame)
 {
-    if (!m_attached)
+    if (!attached())
         return;
     if (m_client->requestDevToolsForFrame(WebLocalFrameImpl::fromFrame(frame)))
         ClientMessageLoopAdapter::pauseForCreateWindow(m_webLocalFrameImpl);
 }
 
 WebString WebDevToolsAgentImpl::evaluateInWebInspectorOverlay(const WebString& script)
 {
     if (!m_overlay)
         return WebString();
 
     return m_overlay->evaluateInOverlayForTest(script);
 }
 
 void WebDevToolsAgentImpl::flushPendingProtocolNotifications()
 {
-    if (m_attached) {
-        m_agents.flushPendingProtocolNotifications();
-        for (size_t i = 0; i < m_notificationQueue.size(); ++i)
-            m_client->sendProtocolMessage(m_notificationQueue[i].first, 0, m_notificationQueue[i].second->toJSONString(), WebString());
-    }
-    m_notificationQueue.clear();
+    if (m_session)
+        m_session->flushPendingProtocolNotifications();
 }
 
 void WebDevToolsAgentImpl::willProcessTask()
 {
-    if (!m_attached)
+    if (!attached())
         return;
     if (InspectorProfilerAgent* profilerAgent = m_instrumentingAgents->inspectorProfilerAgent())
         profilerAgent->willProcessTask();
 }
 
 void WebDevToolsAgentImpl::didProcessTask()
 {
-    if (!m_attached)
+    if (!attached())
         return;
     if (InspectorProfilerAgent* profilerAgent = m_instrumentingAgents->inspectorProfilerAgent())
         profilerAgent->didProcessTask();
     flushPendingProtocolNotifications();
 }
 
 void WebDevToolsAgentImpl::runDebuggerTask(int sessionId, PassOwnPtr<WebDevToolsAgent::MessageDescriptor> descriptor)
 {
     WebDevToolsAgent* webagent = descriptor->agent();
     if (!webagent)
         return;
 
     WebDevToolsAgentImpl* agentImpl = static_cast<WebDevToolsAgentImpl*>(webagent);
-    if (agentImpl->m_attached)
+    if (agentImpl->attached())
         agentImpl->dispatchMessageFromFrontend(sessionId, 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, adoptPtr(rawDescriptor)));
 }
 
 bool WebDevToolsAgent::shouldInterruptForMessage(const WebString& message)
 {
     String16 commandName;
     if (!protocol::Dispatcher::getCommandName(message, &commandName))
         return false;
     return commandName == "Debugger.pause"
         || commandName == "Debugger.setBreakpoint"
         || commandName == "Debugger.setBreakpointByUrl"
         || commandName == "Debugger.removeBreakpoint"
         || commandName == "Debugger.setBreakpointsActive";
 }
 
 } // namespace blink