src/third_party/WebKit/Source/web/WebEmbeddedWorkerImpl.cpp

   1 /*
   2  * Copyright (C) 2013 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/WebEmbeddedWorkerImpl.h"
  33
  34 #include "core/dom/CrossThreadTask.h"
  35 #include "core/dom/Document.h"
  36 #include "core/inspector/WorkerDebuggerAgent.h"
  37 #include "core/inspector/WorkerInspectorController.h"
  38 #include "core/loader/FrameLoadRequest.h"
  39 #include "core/loader/SubstituteData.h"
  40 #include "core/workers/WorkerClients.h"
  41 #include "core/workers/WorkerGlobalScope.h"
  42 #include "core/workers/WorkerLoaderProxy.h"
  43 #include "core/workers/WorkerScriptLoader.h"
  44 #include "core/workers/WorkerScriptLoaderClient.h"
  45 #include "core/workers/WorkerThreadStartupData.h"
  46 #include "modules/serviceworkers/ServiceWorkerThread.h"
  47 #include "platform/NotImplemented.h"
  48 #include "platform/SharedBuffer.h"
  49 #include "platform/heap/Handle.h"
  50 #include "platform/network/ContentSecurityPolicyParsers.h"
  51 #include "public/web/WebServiceWorkerContextClient.h"
  52 #include "public/web/WebServiceWorkerNetworkProvider.h"
  53 #include "public/web/WebView.h"
  54 #include "public/web/WebWorkerPermissionClientProxy.h"
  55 #include "web/ServiceWorkerGlobalScopeClientImpl.h"
  56 #include "web/ServiceWorkerGlobalScopeProxy.h"
  57 #include "web/WebDataSourceImpl.h"
  58 #include "web/WebLocalFrameImpl.h"
  59 #include "web/WorkerPermissionClient.h"
  60 #include "wtf/Functional.h"
  61
  62 using namespace WebCore;
  63
  64 namespace blink {
  65
  66 // A thin wrapper for one-off script loading.
  67 class WebEmbeddedWorkerImpl::Loader : public WorkerScriptLoaderClient {
  68 public:
  69     static PassOwnPtr<Loader> create()
  70     {
  71         return adoptPtr(new Loader());
  72     }
  73
  74     virtual ~Loader()
  75     {
  76         m_scriptLoader->setClient(0);
  77     }
  78
  79     void load(ExecutionContext* loadingContext, const KURL& scriptURL, const Closure& callback)
  80     {
  81         ASSERT(loadingContext);
  82         m_callback = callback;
  83         m_scriptLoader->setTargetType(ResourceRequest::TargetIsServiceWorker);
  84         m_scriptLoader->loadAsynchronously(
  85             *loadingContext, scriptURL, DenyCrossOriginRequests, this);
  86     }
  87
  88     virtual void notifyFinished() OVERRIDE
  89     {
  90         m_callback();
  91     }
  92
  93     void cancel()
  94     {
  95         m_scriptLoader->cancel();
  96     }
  97
  98     bool failed() const { return m_scriptLoader->failed(); }
  99     const KURL& url() const { return m_scriptLoader->responseURL(); }
 100     String script() const { return m_scriptLoader->script(); }
 101
 102 private:
 103     Loader() : m_scriptLoader(WorkerScriptLoader::create())
 104     {
 105     }
 106
 107     RefPtr<WorkerScriptLoader> m_scriptLoader;
 108     Closure m_callback;
 109 };
 110
 111 class WebEmbeddedWorkerImpl::LoaderProxy : public WorkerLoaderProxy {
 112 public:
 113     static PassOwnPtr<LoaderProxy> create(WebEmbeddedWorkerImpl& embeddedWorker)
 114     {
 115         return adoptPtr(new LoaderProxy(embeddedWorker));
 116     }
 117
 118     virtual void postTaskToLoader(PassOwnPtr<ExecutionContextTask> task) OVERRIDE
 119     {
 120         toWebLocalFrameImpl(m_embeddedWorker.m_mainFrame)->frame()->document()->postTask(task);
 121     }
 122
 123     virtual bool postTaskToWorkerGlobalScope(PassOwnPtr<ExecutionContextTask> task) OVERRIDE
 124     {
 125         if (m_embeddedWorker.m_askedToTerminate || !m_embeddedWorker.m_workerThread)
 126             return false;
 127         return m_embeddedWorker.m_workerThread->runLoop().postTask(task);
 128     }
 129
 130 private:
 131     explicit LoaderProxy(WebEmbeddedWorkerImpl& embeddedWorker)
 132         : m_embeddedWorker(embeddedWorker)
 133     {
 134     }
 135
 136     // Not owned, embedded worker owns this.
 137     WebEmbeddedWorkerImpl& m_embeddedWorker;
 138 };
 139
 140 WebEmbeddedWorker* WebEmbeddedWorker::create(
 141     WebServiceWorkerContextClient* client,
 142     WebWorkerPermissionClientProxy* permissionClient)
 143 {
 144     return new WebEmbeddedWorkerImpl(adoptPtr(client), adoptPtr(permissionClient));
 145 }
 146
 147 WebEmbeddedWorkerImpl::WebEmbeddedWorkerImpl(
 148     PassOwnPtr<WebServiceWorkerContextClient> client,
 149     PassOwnPtr<WebWorkerPermissionClientProxy> permissionClient)
 150     : m_workerContextClient(client)
 151     , m_permissionClient(permissionClient)
 152     , m_webView(0)
 153     , m_mainFrame(0)
 154     , m_askedToTerminate(false)
 155 {
 156 }
 157
 158 WebEmbeddedWorkerImpl::~WebEmbeddedWorkerImpl()
 159 {
 160     ASSERT(m_webView);
 161
 162     // Detach the client before closing the view to avoid getting called back.
 163     toWebLocalFrameImpl(m_mainFrame)->setClient(0);
 164
 165     m_webView->close();
 166     m_mainFrame->close();
 167 }
 168
 169 void WebEmbeddedWorkerImpl::startWorkerContext(
 170     const WebEmbeddedWorkerStartData& data)
 171 {
 172     ASSERT(!m_askedToTerminate);
 173     ASSERT(!m_mainScriptLoader);
 174     m_workerStartData = data;
 175
 176     prepareShadowPageForLoader();
 177 }
 178
 179 void WebEmbeddedWorkerImpl::terminateWorkerContext()
 180 {
 181     if (m_askedToTerminate)
 182         return;
 183     m_askedToTerminate = true;
 184     if (m_mainScriptLoader)
 185         m_mainScriptLoader->cancel();
 186     if (m_workerThread)
 187         m_workerThread->stop();
 188 }
 189
 190 namespace {
 191
 192 void resumeWorkerContextTask(ExecutionContext* context, bool)
 193 {
 194     toWorkerGlobalScope(context)->workerInspectorController()->resume();
 195 }
 196
 197 void connectToWorkerContextInspectorTask(ExecutionContext* context, bool)
 198 {
 199     toWorkerGlobalScope(context)->workerInspectorController()->connectFrontend();
 200 }
 201
 202 void reconnectToWorkerContextInspectorTask(ExecutionContext* context, const String& savedState)
 203 {
 204     WorkerInspectorController* ic = toWorkerGlobalScope(context)->workerInspectorController();
 205     ic->restoreInspectorStateFromCookie(savedState);
 206     ic->resume();
 207 }
 208
 209 void disconnectFromWorkerContextInspectorTask(ExecutionContext* context, bool)
 210 {
 211     toWorkerGlobalScope(context)->workerInspectorController()->disconnectFrontend();
 212 }
 213
 214 void dispatchOnInspectorBackendTask(ExecutionContext* context, const String& message)
 215 {
 216     toWorkerGlobalScope(context)->workerInspectorController()->dispatchMessageFromFrontend(message);
 217 }
 218
 219 } // namespace
 220
 221 void WebEmbeddedWorkerImpl::resumeWorkerContext()
 222 {
 223     if (m_workerThread)
 224         m_workerThread->runLoop().postDebuggerTask(createCallbackTask(resumeWorkerContextTask, true));
 225 }
 226
 227 void WebEmbeddedWorkerImpl::attachDevTools()
 228 {
 229     if (m_workerThread)
 230         m_workerThread->runLoop().postDebuggerTask(createCallbackTask(connectToWorkerContextInspectorTask, true));
 231 }
 232
 233 void WebEmbeddedWorkerImpl::reattachDevTools(const WebString& savedState)
 234 {
 235     m_workerThread->runLoop().postDebuggerTask(createCallbackTask(reconnectToWorkerContextInspectorTask, String(savedState)));
 236 }
 237
 238 void WebEmbeddedWorkerImpl::detachDevTools()
 239 {
 240     m_workerThread->runLoop().postDebuggerTask(createCallbackTask(disconnectFromWorkerContextInspectorTask, true));
 241 }
 242
 243 void WebEmbeddedWorkerImpl::dispatchDevToolsMessage(const WebString& message)
 244 {
 245     m_workerThread->runLoop().postDebuggerTask(createCallbackTask(dispatchOnInspectorBackendTask, String(message)));
 246     WorkerDebuggerAgent::interruptAndDispatchInspectorCommands(m_workerThread.get());
 247 }
 248
 249 void WebEmbeddedWorkerImpl::prepareShadowPageForLoader()
 250 {
 251     // Create 'shadow page', which is never displayed and is used mainly to
 252     // provide a context for loading on the main thread.
 253     //
 254     // FIXME: This does mostly same as WebSharedWorkerImpl::initializeLoader.
 255     // This code, and probably most of the code in this class should be shared
 256     // with SharedWorker.
 257     ASSERT(!m_webView);
 258     m_webView = WebView::create(0);
 259     m_mainFrame = WebLocalFrame::create(this);
 260     m_webView->setMainFrame(m_mainFrame);
 261
 262     WebLocalFrameImpl* webFrame = toWebLocalFrameImpl(m_webView->mainFrame());
 263
 264     // Construct substitute data source for the 'shadow page'. We only need it
 265     // to have same origin as the worker so the loading checks work correctly.
 266     CString content("");
 267     int length = static_cast<int>(content.length());
 268     RefPtr<SharedBuffer> buffer(SharedBuffer::create(content.data(), length));
 269     webFrame->frame()->loader().load(FrameLoadRequest(0, ResourceRequest(m_workerStartData.scriptURL), SubstituteData(buffer, "text/html", "UTF-8", KURL())));
 270 }
 271
 272 void WebEmbeddedWorkerImpl::willSendRequest(
 273     WebLocalFrame* frame, unsigned, WebURLRequest& request,
 274     const WebURLResponse& redirectResponse)
 275 {
 276     if (m_networkProvider)
 277         m_networkProvider->willSendRequest(frame->dataSource(), request);
 278 }
 279
 280 void WebEmbeddedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame)
 281 {
 282     ASSERT(!m_mainScriptLoader);
 283     ASSERT(!m_networkProvider);
 284     ASSERT(m_mainFrame);
 285     ASSERT(m_workerContextClient);
 286     m_networkProvider = adoptPtr(m_workerContextClient->createServiceWorkerNetworkProvider(frame->dataSource()));
 287     m_mainScriptLoader = Loader::create();
 288     m_mainScriptLoader->load(
 289         toWebLocalFrameImpl(m_mainFrame)->frame()->document(),
 290         m_workerStartData.scriptURL,
 291         bind(&WebEmbeddedWorkerImpl::onScriptLoaderFinished, this));
 292 }
 293
 294 void WebEmbeddedWorkerImpl::onScriptLoaderFinished()
 295 {
 296     ASSERT(m_mainScriptLoader);
 297
 298     if (m_mainScriptLoader->failed() || m_askedToTerminate) {
 299         m_mainScriptLoader.clear();
 300         // This may delete 'this'.
 301         m_workerContextClient->workerContextFailedToStart();
 302         return;
 303     }
 304
 305     WorkerThreadStartMode startMode =
 306         (m_workerStartData.startMode == WebEmbeddedWorkerStartModePauseOnStart)
 307         ? PauseWorkerGlobalScopeOnStart : DontPauseWorkerGlobalScopeOnStart;
 308
 309     OwnPtrWillBeRawPtr<WorkerClients> workerClients = WorkerClients::create();
 310     providePermissionClientToWorker(workerClients.get(), m_permissionClient.release());
 311     provideServiceWorkerGlobalScopeClientToWorker(workerClients.get(), ServiceWorkerGlobalScopeClientImpl::create(*m_workerContextClient));
 312
 313     OwnPtrWillBeRawPtr<WorkerThreadStartupData> startupData =
 314         WorkerThreadStartupData::create(
 315             m_mainScriptLoader->url(),
 316             m_workerStartData.userAgent,
 317             m_mainScriptLoader->script(),
 318             startMode,
 319             // FIXME: fill appropriate CSP info and policy type.
 320             String(),
 321             ContentSecurityPolicyHeaderTypeEnforce,
 322             workerClients.release());
 323
 324     m_mainScriptLoader.clear();
 325
 326     m_workerGlobalScopeProxy = ServiceWorkerGlobalScopeProxy::create(*this, *toWebLocalFrameImpl(m_mainFrame)->frame()->document(), *m_workerContextClient);
 327     m_loaderProxy = LoaderProxy::create(*this);
 328
 329     m_workerThread = ServiceWorkerThread::create(*m_loaderProxy, *m_workerGlobalScopeProxy, startupData.release());
 330     m_workerThread->start();
 331 }
 332
 333 } // namespace blink