third_party/WebKit/Source/web/WebSharedWorkerImpl.cpp

   1 /*
   2  * Copyright (C) 2009 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "web/WebSharedWorkerImpl.h"
  33
  34 #include "core/dom/CrossThreadTask.h"
  35 #include "core/dom/Document.h"
  36 #include "core/events/MessageEvent.h"
  37 #include "core/html/HTMLFormElement.h"
  38 #include "core/inspector/ConsoleMessage.h"
  39 #include "core/inspector/InspectorInstrumentation.h"
  40 #include "core/inspector/WorkerDebuggerAgent.h"
  41 #include "core/inspector/WorkerInspectorController.h"
  42 #include "core/loader/FrameLoadRequest.h"
  43 #include "core/loader/FrameLoader.h"
  44 #include "core/page/Page.h"
  45 #include "core/workers/SharedWorkerGlobalScope.h"
  46 #include "core/workers/SharedWorkerThread.h"
  47 #include "core/workers/WorkerClients.h"
  48 #include "core/workers/WorkerGlobalScope.h"
  49 #include "core/workers/WorkerInspectorProxy.h"
  50 #include "core/workers/WorkerLoaderProxy.h"
  51 #include "core/workers/WorkerScriptLoader.h"
  52 #include "core/workers/WorkerThreadStartupData.h"
  53 #include "platform/RuntimeEnabledFeatures.h"
  54 #include "platform/ThreadSafeFunctional.h"
  55 #include "platform/heap/Handle.h"
  56 #include "platform/network/ContentSecurityPolicyParsers.h"
  57 #include "platform/network/ResourceResponse.h"
  58 #include "platform/weborigin/KURL.h"
  59 #include "platform/weborigin/SecurityOrigin.h"
  60 #include "public/platform/WebFileError.h"
  61 #include "public/platform/WebMessagePortChannel.h"
  62 #include "public/platform/WebString.h"
  63 #include "public/platform/WebURL.h"
  64 #include "public/platform/WebURLRequest.h"
  65 #include "public/web/WebDevToolsAgent.h"
  66 #include "public/web/WebFrame.h"
  67 #include "public/web/WebServiceWorkerNetworkProvider.h"
  68 #include "public/web/WebSettings.h"
  69 #include "public/web/WebView.h"
  70 #include "public/web/WebWorkerContentSettingsClientProxy.h"
  71 #include "web/LocalFileSystemClient.h"
  72 #include "web/WebDataSourceImpl.h"
  73 #include "web/WebLocalFrameImpl.h"
  74 #include "web/WorkerContentSettingsClient.h"
  75 #include "wtf/Functional.h"
  76 #include "wtf/MainThread.h"
  77
  78 namespace blink {
  79
  80 // TODO(toyoshim): Share implementation with WebEmbeddedWorkerImpl as much as
  81 // possible.
  82
  83 WebSharedWorkerImpl::WebSharedWorkerImpl(WebSharedWorkerClient* client)
  84     : m_webView(nullptr)
  85     , m_mainFrame(nullptr)
  86     , m_askedToTerminate(false)
  87     , m_workerInspectorProxy(WorkerInspectorProxy::create())
  88     , m_client(client)
  89     , m_pauseWorkerContextOnStart(false)
  90     , m_isPausedOnStart(false)
  91 {
  92 }
  93
  94 WebSharedWorkerImpl::~WebSharedWorkerImpl()
  95 {
  96     ASSERT(m_webView);
  97     // Detach the client before closing the view to avoid getting called back.
  98     m_mainFrame->setClient(0);
  99
 100     m_webView->close();
 101     m_mainFrame->close();
 102     if (m_loaderProxy)
 103         m_loaderProxy->detachProvider(this);
 104 }
 105
 106 void WebSharedWorkerImpl::terminateWorkerThread()
 107 {
 108     if (m_askedToTerminate)
 109         return;
 110     m_askedToTerminate = true;
 111     if (m_mainScriptLoader) {
 112         m_mainScriptLoader->cancel();
 113         m_mainScriptLoader.clear();
 114         m_client->workerScriptLoadFailed();
 115         delete this;
 116         return;
 117     }
 118     if (m_workerThread)
 119         m_workerThread->terminate();
 120     m_workerInspectorProxy->workerThreadTerminated();
 121 }
 122
 123 void WebSharedWorkerImpl::initializeLoader()
 124 {
 125     // Create 'shadow page'. This page is never displayed, it is used to proxy the
 126     // loading requests from the worker context to the rest of WebKit and Chromium
 127     // infrastructure.
 128     ASSERT(!m_webView);
 129     m_webView = WebView::create(0);
 130     // FIXME: http://crbug.com/363843. This needs to find a better way to
 131     // not create graphics layers.
 132     m_webView->settings()->setAcceleratedCompositingEnabled(false);
 133     // FIXME: Settings information should be passed to the Worker process from Browser process when the worker
 134     // is created (similar to RenderThread::OnCreateNewView).
 135     m_mainFrame = toWebLocalFrameImpl(WebLocalFrame::create(WebTreeScopeType::Document, this));
 136     m_webView->setMainFrame(m_mainFrame.get());
 137     m_mainFrame->setDevToolsAgentClient(this);
 138
 139     // If we were asked to pause worker context on start and wait for debugger then it is the good time to do that.
 140     m_client->workerReadyForInspection();
 141     if (m_pauseWorkerContextOnStart) {
 142         m_isPausedOnStart = true;
 143         return;
 144     }
 145     loadShadowPage();
 146 }
 147
 148 WebApplicationCacheHost* WebSharedWorkerImpl::createApplicationCacheHost(WebLocalFrame*, WebApplicationCacheHostClient* appcacheHostClient)
 149 {
 150     return m_client->createApplicationCacheHost(appcacheHostClient);
 151 }
 152
 153 void WebSharedWorkerImpl::loadShadowPage()
 154 {
 155     // Construct substitute data source for the 'shadow page'. We only need it
 156     // to have same origin as the worker so the loading checks work correctly.
 157     CString content("");
 158     RefPtr<SharedBuffer> buffer(SharedBuffer::create(content.data(), content.length()));
 159     m_mainFrame->frame()->loader().load(FrameLoadRequest(0, ResourceRequest(m_url), SubstituteData(buffer, "text/html", "UTF-8", KURL())));
 160 }
 161
 162 void WebSharedWorkerImpl::willSendRequest(
 163     WebLocalFrame* frame, unsigned, WebURLRequest& request,
 164     const WebURLResponse& redirectResponse)
 165 {
 166     if (m_networkProvider)
 167         m_networkProvider->willSendRequest(frame->dataSource(), request);
 168 }
 169
 170 void WebSharedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame, bool)
 171 {
 172     ASSERT(!m_loadingDocument);
 173     ASSERT(!m_mainScriptLoader);
 174     m_networkProvider = adoptPtr(m_client->createServiceWorkerNetworkProvider(frame->dataSource()));
 175     m_mainScriptLoader = WorkerScriptLoader::create();
 176     m_mainScriptLoader->setRequestContext(WebURLRequest::RequestContextSharedWorker);
 177     m_loadingDocument = toWebLocalFrameImpl(frame)->frame()->document();
 178     m_mainScriptLoader->loadAsynchronously(
 179         *m_loadingDocument.get(),
 180         m_url,
 181         DenyCrossOriginRequests,
 182         bind(&WebSharedWorkerImpl::didReceiveScriptLoaderResponse, this),
 183         bind(&WebSharedWorkerImpl::onScriptLoaderFinished, this));
 184     // Do nothing here since onScriptLoaderFinished() might have been already
 185     // invoked and |this| might have been deleted at this point.
 186 }
 187
 188 bool WebSharedWorkerImpl::isControlledByServiceWorker(WebDataSource& dataSource)
 189 {
 190     return m_networkProvider && m_networkProvider->isControlledByServiceWorker(dataSource);
 191 }
 192
 193 int64_t WebSharedWorkerImpl::serviceWorkerID(WebDataSource& dataSource)
 194 {
 195     if (!m_networkProvider)
 196         return -1;
 197     return m_networkProvider->serviceWorkerID(dataSource);
 198 }
 199
 200 void WebSharedWorkerImpl::sendProtocolMessage(int callId, const WebString& message, const WebString& state)
 201 {
 202     m_client->sendDevToolsMessage(callId, message, state);
 203 }
 204
 205 void WebSharedWorkerImpl::resumeStartup()
 206 {
 207     bool isPausedOnStart = m_isPausedOnStart;
 208     m_isPausedOnStart = false;
 209     if (isPausedOnStart)
 210         loadShadowPage();
 211 }
 212
 213 // WorkerReportingProxy --------------------------------------------------------
 214
 215 void WebSharedWorkerImpl::reportException(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL, int exceptionId)
 216 {
 217     // Not suppported in SharedWorker.
 218 }
 219
 220 void WebSharedWorkerImpl::reportConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage>)
 221 {
 222     // Not supported in SharedWorker.
 223 }
 224
 225 void WebSharedWorkerImpl::postMessageToPageInspector(const String& message)
 226 {
 227     m_mainFrame->frame()->document()->postInspectorTask(FROM_HERE, createCrossThreadTask(&WebSharedWorkerImpl::postMessageToPageInspectorOnMainThread, this, message));
 228 }
 229
 230 void WebSharedWorkerImpl::postMessageToPageInspectorOnMainThread(const String& message)
 231 {
 232     WorkerInspectorProxy::PageInspector* pageInspector = m_workerInspectorProxy->pageInspector();
 233     if (!pageInspector)
 234         return;
 235     pageInspector->dispatchMessageFromWorker(message);
 236
 237 }
 238
 239 void WebSharedWorkerImpl::workerGlobalScopeClosed()
 240 {
 241     Platform::current()->mainThread()->taskRunner()->postTask(FROM_HERE, threadSafeBind(&WebSharedWorkerImpl::workerGlobalScopeClosedOnMainThread, AllowCrossThreadAccess(this)));
 242 }
 243
 244 void WebSharedWorkerImpl::workerGlobalScopeClosedOnMainThread()
 245 {
 246     m_client->workerContextClosed();
 247
 248     terminateWorkerThread();
 249 }
 250
 251 void WebSharedWorkerImpl::workerGlobalScopeStarted(WorkerGlobalScope*)
 252 {
 253 }
 254
 255 void WebSharedWorkerImpl::workerThreadTerminated()
 256 {
 257     Platform::current()->mainThread()->taskRunner()->postTask(FROM_HERE, threadSafeBind(&WebSharedWorkerImpl::workerThreadTerminatedOnMainThread, AllowCrossThreadAccess(this)));
 258 }
 259
 260 void WebSharedWorkerImpl::workerThreadTerminatedOnMainThread()
 261 {
 262     m_client->workerContextDestroyed();
 263     // The lifetime of this proxy is controlled by the worker context.
 264     delete this;
 265 }
 266
 267 // WorkerLoaderProxyProvider -----------------------------------------------------------
 268
 269 void WebSharedWorkerImpl::postTaskToLoader(PassOwnPtr<ExecutionContextTask> task)
 270 {
 271     m_mainFrame->frame()->document()->postTask(FROM_HERE, task);
 272 }
 273
 274 bool WebSharedWorkerImpl::postTaskToWorkerGlobalScope(PassOwnPtr<ExecutionContextTask> task)
 275 {
 276     m_workerThread->postTask(FROM_HERE, task);
 277     return true;
 278 }
 279
 280 void WebSharedWorkerImpl::connect(WebMessagePortChannel* webChannel)
 281 {
 282     workerThread()->postTask(
 283         FROM_HERE, createCrossThreadTask(&connectTask, adoptPtr(webChannel)));
 284 }
 285
 286 void WebSharedWorkerImpl::connectTask(PassOwnPtr<WebMessagePortChannel> channel, ExecutionContext* context)
 287 {
 288     // Wrap the passed-in channel in a MessagePort, and send it off via a connect event.
 289     MessagePort* port = MessagePort::create(*context);
 290     port->entangle(channel);
 291     WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(context);
 292     ASSERT_WITH_SECURITY_IMPLICATION(workerGlobalScope->isSharedWorkerGlobalScope());
 293     workerGlobalScope->dispatchEvent(createConnectEvent(port));
 294 }
 295
 296 void WebSharedWorkerImpl::startWorkerContext(const WebURL& url, const WebString& name, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType policyType)
 297 {
 298     m_url = url;
 299     m_name = name;
 300     initializeLoader();
 301 }
 302
 303 void WebSharedWorkerImpl::didReceiveScriptLoaderResponse()
 304 {
 305     InspectorInstrumentation::didReceiveScriptResponse(m_loadingDocument.get(), m_mainScriptLoader->identifier());
 306     m_client->selectAppCacheID(m_mainScriptLoader->appCacheID());
 307 }
 308
 309 void WebSharedWorkerImpl::onScriptLoaderFinished()
 310 {
 311     ASSERT(m_loadingDocument);
 312     ASSERT(m_mainScriptLoader);
 313     if (m_askedToTerminate)
 314         return;
 315     if (m_mainScriptLoader->failed()) {
 316         m_mainScriptLoader->cancel();
 317         m_client->workerScriptLoadFailed();
 318
 319         // The SharedWorker was unable to load the initial script, so
 320         // shut it down right here.
 321         delete this;
 322         return;
 323     }
 324
 325     Document* document = m_mainFrame->frame()->document();
 326     WorkerThreadStartMode startMode = DontPauseWorkerGlobalScopeOnStart;
 327     if (InspectorInstrumentation::shouldPauseDedicatedWorkerOnStart(document))
 328         startMode = PauseWorkerGlobalScopeOnStart;
 329
 330     // FIXME: this document's origin is pristine and without any extra privileges. (crbug.com/254993)
 331     SecurityOrigin* starterOrigin = document->securityOrigin();
 332
 333     OwnPtrWillBeRawPtr<WorkerClients> workerClients = WorkerClients::create();
 334     provideLocalFileSystemToWorker(workerClients.get(), LocalFileSystemClient::create());
 335     WebSecurityOrigin webSecurityOrigin(m_loadingDocument->securityOrigin());
 336     provideContentSettingsClientToWorker(workerClients.get(), adoptPtr(m_client->createWorkerContentSettingsClientProxy(webSecurityOrigin)));
 337     RefPtrWillBeRawPtr<ContentSecurityPolicy> contentSecurityPolicy = m_mainScriptLoader->releaseContentSecurityPolicy();
 338     OwnPtr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(
 339         m_url,
 340         m_loadingDocument->userAgent(m_url),
 341         m_mainScriptLoader->script(),
 342         nullptr,
 343         startMode,
 344         contentSecurityPolicy ? contentSecurityPolicy->headers() : nullptr,
 345         starterOrigin,
 346         workerClients.release());
 347     m_loaderProxy = WorkerLoaderProxy::create(this);
 348     setWorkerThread(SharedWorkerThread::create(m_name, m_loaderProxy, *this));
 349     InspectorInstrumentation::scriptImported(m_loadingDocument.get(), m_mainScriptLoader->identifier(), m_mainScriptLoader->script());
 350     m_mainScriptLoader.clear();
 351
 352     workerThread()->start(startupData.release());
 353     m_workerInspectorProxy->workerThreadCreated(m_loadingDocument.get(), workerThread(), m_url);
 354     m_client->workerScriptLoaded();
 355 }
 356
 357 void WebSharedWorkerImpl::terminateWorkerContext()
 358 {
 359     terminateWorkerThread();
 360 }
 361
 362 void WebSharedWorkerImpl::pauseWorkerContextOnStart()
 363 {
 364     m_pauseWorkerContextOnStart = true;
 365 }
 366
 367 void WebSharedWorkerImpl::attachDevTools(const WebString& hostId)
 368 {
 369     WebDevToolsAgent* devtoolsAgent = m_mainFrame->devToolsAgent();
 370     if (devtoolsAgent)
 371         devtoolsAgent->attach(hostId);
 372 }
 373
 374 void WebSharedWorkerImpl::reattachDevTools(const WebString& hostId, const WebString& savedState)
 375 {
 376     WebDevToolsAgent* devtoolsAgent = m_mainFrame->devToolsAgent();
 377     if (devtoolsAgent)
 378         devtoolsAgent->reattach(hostId, savedState);
 379     resumeStartup();
 380 }
 381
 382 void WebSharedWorkerImpl::detachDevTools()
 383 {
 384     WebDevToolsAgent* devtoolsAgent = m_mainFrame->devToolsAgent();
 385     if (devtoolsAgent)
 386         devtoolsAgent->detach();
 387 }
 388
 389 void WebSharedWorkerImpl::dispatchDevToolsMessage(const WebString& message)
 390 {
 391     if (m_askedToTerminate)
 392         return;
 393     WebDevToolsAgent* devtoolsAgent = m_mainFrame->devToolsAgent();
 394     if (devtoolsAgent)
 395         devtoolsAgent->dispatchOnInspectorBackend(message);
 396 }
 397
 398 WebSharedWorker* WebSharedWorker::create(WebSharedWorkerClient* client)
 399 {
 400     return new WebSharedWorkerImpl(client);
 401 }
 402
 403 } // namespace blink