DevTools: Switch shared workers inspection on to the main thread.

Source/web/WebSharedWorkerImpl.cpp

 /*
  * Copyright (C) 2009 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 43 matching lines @@
 #include "platform/heap/Handle.h"
 #include "platform/network/ContentSecurityPolicyParsers.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/WebFileError.h"
 #include "public/platform/WebMessagePortChannel.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLRequest.h"
+#include "public/web/WebDevToolsAgent.h"
 #include "public/web/WebFrame.h"
 #include "public/web/WebSettings.h"
 #include "public/web/WebView.h"
 #include "public/web/WebWorkerPermissionClientProxy.h"
 #include "web/DatabaseClientImpl.h"
 #include "web/LocalFileSystemClient.h"
 #include "web/WebDataSourceImpl.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WorkerPermissionClient.h"
 #include "wtf/Functional.h"
@@ skipping 78 matching lines @@
 }
 
 WebSharedWorkerImpl::WebSharedWorkerImpl(WebSharedWorkerClient* client)
     : m_webView(0)
     , m_mainFrame(0)
     , m_askedToTerminate(false)
     , m_workerInspectorProxy(WorkerInspectorProxy::create())
     , m_client(WeakReference<WebSharedWorkerClient>::create(client))
     , m_clientWeakPtr(WeakPtr<WebSharedWorkerClient>(m_client))
     , m_pauseWorkerContextOnStart(false)
-    , m_attachDevToolsOnStart(false)
+    , m_isPausedOnStart(false)
 {
     initializeWebKitStaticValues();
 }
 
 WebSharedWorkerImpl::~WebSharedWorkerImpl()
 {
     ASSERT(m_webView);
     // Detach the client before closing the view to avoid getting called back.
     toWebLocalFrameImpl(m_mainFrame)->setClient(0);
 
@@ skipping 27 matching lines @@
     ASSERT(!m_webView);
     m_webView = WebView::create(0);
     m_webView->settings()->setOfflineWebApplicationCacheEnabled(RuntimeEnabledFeatures::applicationCacheEnabled());
     // FIXME: http://crbug.com/363843. This needs to find a better way to
     // not create graphics layers.
     m_webView->settings()->setAcceleratedCompositingEnabled(false);
     // FIXME: Settings information should be passed to the Worker process from Browser process when the worker
     // is created (similar to RenderThread::OnCreateNewView).
     m_mainFrame = WebLocalFrame::create(this);
     m_webView->setMainFrame(m_mainFrame);
+    m_webView->setDevToolsAgentClient(this);
 
     WebLocalFrameImpl* webFrame = toWebLocalFrameImpl(m_webView->mainFrame());
 
     // Construct substitute data source for the 'shadow page'. We only need it
     // to have same origin as the worker so the loading checks work correctly.
     CString content("");
     int length = static_cast<int>(content.length());
     RefPtr<SharedBuffer> buffer(SharedBuffer::create(content.data(), length));
     webFrame->frame()->loader().load(FrameLoadRequest(0, ResourceRequest(url), SubstituteData(buffer, "text/html", "UTF-8", KURL())));
 }
 
 WebApplicationCacheHost* WebSharedWorkerImpl::createApplicationCacheHost(WebLocalFrame*, WebApplicationCacheHostClient* appcacheHostClient)
 {
     if (client())
         return client()->createApplicationCacheHost(appcacheHostClient);
     return 0;
 }
 
 void WebSharedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame)
 {
+    // If we were asked to pause worker context on start and wait for debugger then it is the good time to do that.
+    client()->workerReadyForInspection();
+    if (m_pauseWorkerContextOnStart) {
+        m_isPausedOnStart = true;
+        return;
+    }
+    startScriptLoader(frame);
+}
+
+void WebSharedWorkerImpl::sendMessageToInspectorFrontend(const WebString& message)
+{
+    client()->dispatchDevToolsMessage(message);
+}
+
+void WebSharedWorkerImpl::resumeStartup()
+{
+    bool isPausedOnStart = m_isPausedOnStart;
+    m_isPausedOnStart = false;
+    if (isPausedOnStart)
+        startScriptLoader(toWebLocalFrameImpl(m_mainFrame));
+}
+
+void WebSharedWorkerImpl::saveAgentRuntimeState(const WebString& inspectorState)
+{
+    client()->saveDevToolsAgentState(inspectorState);
+}
+
+void WebSharedWorkerImpl::startScriptLoader(WebLocalFrame* frame)
+{
     ASSERT(!m_loadingDocument);
     ASSERT(!m_mainScriptLoader);
     m_mainScriptLoader = Loader::create();
     m_loadingDocument = toWebLocalFrameImpl(frame)->frame()->document();
     m_mainScriptLoader->load(
         m_loadingDocument.get(),
         m_url,
         bind(&WebSharedWorkerImpl::didReceiveScriptLoaderResponse, this),
         bind(&WebSharedWorkerImpl::onScriptLoaderFinished, this));
 }
 
 // WorkerReportingProxy --------------------------------------------------------
 
 void WebSharedWorkerImpl::reportException(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL)
 {
     // Not suppported in SharedWorker.
 }
 
 void WebSharedWorkerImpl::reportConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage>)
 {
     // Not supported in SharedWorker.
 }
 
 void WebSharedWorkerImpl::postMessageToPageInspector(const String& message)
 {
-    // Note that we need to keep the closure creation on a separate line so
-    // that the temporary created by isolatedCopy() will always be destroyed
-    // before the copy in the closure is used on the main thread.
-    const Closure& boundFunction = bind(&WebSharedWorkerClient::dispatchDevToolsMessage, m_clientWeakPtr, message.isolatedCopy());
-    callOnMainThread(boundFunction);
     toWebLocalFrameImpl(m_mainFrame)->frame()->document()->postInspectorTask(createCrossThreadTask(&WebSharedWorkerImpl::postMessageToPageInspectorOnMainThread, this, message));
 }
 
 void WebSharedWorkerImpl::postMessageToPageInspectorOnMainThread(const String& message)
 {
     WorkerInspectorProxy::PageInspector* pageInspector = m_workerInspectorProxy->pageInspector();
     if (!pageInspector)
         return;
     pageInspector->dispatchMessageFromWorker(message);
 
 }
 
 void WebSharedWorkerImpl::updateInspectorStateCookie(const String& cookie)
 {
-    // Note that we need to keep the closure creation on a separate line so
-    // that the temporary created by isolatedCopy() will always be destroyed
-    // before the copy in the closure is used on the main thread.
-    const Closure& boundFunction = bind(&WebSharedWorkerClient::saveDevToolsAgentState, m_clientWeakPtr, cookie.isolatedCopy());
-    callOnMainThread(boundFunction);
 }
 
 void WebSharedWorkerImpl::workerGlobalScopeClosed()
 {
     callOnMainThread(bind(&WebSharedWorkerImpl::workerGlobalScopeClosedOnMainThread, this));
 }
 
 void WebSharedWorkerImpl::workerGlobalScopeClosedOnMainThread()
 {
     if (client())
@@ skipping 57 matching lines @@
     initializeLoader(url);
 }
 
 void WebSharedWorkerImpl::didReceiveScriptLoaderResponse()
 {
     InspectorInstrumentation::didReceiveScriptResponse(m_loadingDocument.get(), m_mainScriptLoader->identifier());
     if (client())
         client()->selectAppCacheID(m_mainScriptLoader->appCacheID());
 }
 
-static void connectToWorkerContextInspectorTask(ExecutionContext* context, bool)
-{
-    toWorkerGlobalScope(context)->workerInspectorController()->connectFrontend();
-}
-
 void WebSharedWorkerImpl::onScriptLoaderFinished()
 {
     ASSERT(m_loadingDocument);
     ASSERT(m_mainScriptLoader);
     if (m_askedToTerminate)
         return;
     if (m_mainScriptLoader->failed()) {
         m_mainScriptLoader->cancel();
         if (client())
             client()->workerScriptLoadFailed();
 
         // The SharedWorker was unable to load the initial script, so
         // shut it down right here.
         delete this;
         return;
     }
-    WorkerThreadStartMode startMode = m_pauseWorkerContextOnStart ? PauseWorkerGlobalScopeOnStart : DontPauseWorkerGlobalScopeOnStart;
+
+    Document* document = toWebLocalFrameImpl(m_mainFrame)->frame()->document();
+    WorkerThreadStartMode startMode = DontPauseWorkerGlobalScopeOnStart;
+    if (InspectorInstrumentation::shouldPauseDedicatedWorkerOnStart(document))

[horo, 2014/09/04 05:44:02]

nit: It is better to rename "shouldPauseDedicatedWorkerOnStart" in other CL.

+        startMode = PauseWorkerGlobalScopeOnStart;
+
     OwnPtrWillBeRawPtr<WorkerClients> workerClients = WorkerClients::create();
     provideLocalFileSystemToWorker(workerClients.get(), LocalFileSystemClient::create());
     provideDatabaseClientToWorker(workerClients.get(), DatabaseClientImpl::create());
     WebSecurityOrigin webSecurityOrigin(m_loadingDocument->securityOrigin());
     providePermissionClientToWorker(workerClients.get(), adoptPtr(client()->createWorkerPermissionClientProxy(webSecurityOrigin)));
     OwnPtrWillBeRawPtr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(m_url, m_loadingDocument->userAgent(m_url), m_mainScriptLoader->script(), startMode, m_contentSecurityPolicy, static_cast<ContentSecurityPolicyHeaderType>(m_policyType), workerClients.release());
     setWorkerThread(SharedWorkerThread::create(m_name, *this, *this, startupData.release()));
     InspectorInstrumentation::scriptImported(m_loadingDocument.get(), m_mainScriptLoader->identifier(), m_mainScriptLoader->script());
     m_mainScriptLoader.clear();
 
-    if (m_attachDevToolsOnStart)
-        workerThread()->postDebuggerTask(createCrossThreadTask(connectToWorkerContextInspectorTask, true));
-
     workerThread()->start();
     m_workerInspectorProxy->workerThreadCreated(m_loadingDocument.get(), workerThread(), m_url);
-    if (client()) {
+    if (client())
         client()->workerScriptLoaded();
-        client()->workerReadyForInspection();
-    }
 }
 
 void WebSharedWorkerImpl::terminateWorkerContext()
 {
     stopWorkerThread();
 }
 
 void WebSharedWorkerImpl::clientDestroyed()
 {
     m_client.clear();
 }
 
 void WebSharedWorkerImpl::pauseWorkerContextOnStart()
 {
     m_pauseWorkerContextOnStart = true;
 }
 
-static void resumeWorkerContextTask(ExecutionContext* context, bool)
-{
-    toWorkerGlobalScope(context)->workerInspectorController()->resume();
-}
-
 void WebSharedWorkerImpl::resumeWorkerContext()
 {
-    m_pauseWorkerContextOnStart = false;
-    if (workerThread())
-        workerThread()->postDebuggerTask(createCrossThreadTask(resumeWorkerContextTask, true));
-}
-
-void WebSharedWorkerImpl::attachDevTools()
-{
-    if (workerThread())
-        workerThread()->postDebuggerTask(createCrossThreadTask(connectToWorkerContextInspectorTask, true));
-    else
-        m_attachDevToolsOnStart = true;
 }
 
 void WebSharedWorkerImpl::attachDevTools(const WebString& hostId)
 {
-    attachDevTools();
-}
-
-static void reconnectToWorkerContextInspectorTask(ExecutionContext* context, const String& savedState)
-{
-    WorkerInspectorController* ic = toWorkerGlobalScope(context)->workerInspectorController();
-    ic->restoreInspectorStateFromCookie(savedState);
-    ic->resume();
-}
-
-void WebSharedWorkerImpl::reattachDevTools(const WebString& savedState)
-{
-    workerThread()->postDebuggerTask(createCrossThreadTask(reconnectToWorkerContextInspectorTask, String(savedState)));
+    WebDevToolsAgent* devtoolsAgent = m_webView->devToolsAgent();
+    if (devtoolsAgent)
+        devtoolsAgent->attach(hostId);
 }
 
 void WebSharedWorkerImpl::reattachDevTools(const WebString& hostId, const WebString& savedState)
 {
-    reattachDevTools(savedState);
-}
-
-static void disconnectFromWorkerContextInspectorTask(ExecutionContext* context, bool)
-{
-    toWorkerGlobalScope(context)->workerInspectorController()->disconnectFrontend();
+    WebDevToolsAgent* devtoolsAgent = m_webView->devToolsAgent();
+    if (devtoolsAgent)
+        devtoolsAgent->reattach(hostId, savedState);
 }
 
 void WebSharedWorkerImpl::detachDevTools()
 {
-    m_attachDevToolsOnStart = false;
-    workerThread()->postDebuggerTask(createCrossThreadTask(disconnectFromWorkerContextInspectorTask, true));
-}
-
-static void dispatchOnInspectorBackendTask(ExecutionContext* context, const String& message)
-{
-    toWorkerGlobalScope(context)->workerInspectorController()->dispatchMessageFromFrontend(message);
+    WebDevToolsAgent* devtoolsAgent = m_webView->devToolsAgent();
+    if (devtoolsAgent)
+        devtoolsAgent->detach();
 }
 
 void WebSharedWorkerImpl::dispatchDevToolsMessage(const WebString& message)
 {
     if (m_askedToTerminate)
         return;
-    workerThread()->postDebuggerTask(createCrossThreadTask(dispatchOnInspectorBackendTask, String(message)));
-    workerThread()->interruptAndDispatchInspectorCommands();
+    WebDevToolsAgent* devtoolsAgent = m_webView->devToolsAgent();
+    if (devtoolsAgent)
+        devtoolsAgent->dispatchOnInspectorBackend(message);
 }
 
 WebSharedWorker* WebSharedWorker::create(WebSharedWorkerClient* client)
 {
     return new WebSharedWorkerImpl(client);
 }
 
 } // namespace blink