Worker: Provide a way to access parent frame task runners from a worker thread

third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp

 /*
  * Copyright (C) 2013 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 20 matching lines @@
 #include "web/ServiceWorkerGlobalScopeProxy.h"
 
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/dom/MessagePort.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/origin_trials/OriginTrials.h"
+#include "core/workers/ParentFrameTaskRunners.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerThread.h"
 #include "modules/background_sync/SyncEvent.h"
 #include "modules/fetch/Headers.h"
 #include "modules/notifications/Notification.h"
 #include "modules/notifications/NotificationEvent.h"
 #include "modules/notifications/NotificationEventInit.h"
 #include "modules/push_messaging/PushEvent.h"
 #include "modules/push_messaging/PushMessageData.h"
 #include "modules/serviceworkers/ExtendableEvent.h"
@@ skipping 28 matching lines @@
   return new ServiceWorkerGlobalScopeProxy(embeddedWorker, document, client);
 }
 
 ServiceWorkerGlobalScopeProxy::~ServiceWorkerGlobalScopeProxy() {
   // Verify that the proxy has been detached.
   DCHECK(!m_embeddedWorker);
 }
 
 DEFINE_TRACE(ServiceWorkerGlobalScopeProxy) {
   visitor->trace(m_document);
+  visitor->trace(m_parentFrameTaskRunners);
   visitor->trace(m_pendingPreloadFetchEvents);
 }
 
 void ServiceWorkerGlobalScopeProxy::setRegistration(
     std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) {
   workerGlobalScope()->setRegistration(std::move(handle));
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchActivateEvent(int eventID) {
   WaitUntilObserver* observer = WaitUntilObserver::create(
@@ skipping 251 matching lines @@
 
 void ServiceWorkerGlobalScopeProxy::postMessageToPageInspector(
     const String& message) {
   DCHECK(m_embeddedWorker);
   document().postInspectorTask(
       BLINK_FROM_HERE,
       createCrossThreadTask(&WebEmbeddedWorkerImpl::postMessageToPageInspector,
                             crossThreadUnretained(m_embeddedWorker), message));
 }
 
+ParentFrameTaskRunners*
+ServiceWorkerGlobalScopeProxy::getParentFrameTaskRunners() {
+  return m_parentFrameTaskRunners.get();
+}
+
 void ServiceWorkerGlobalScopeProxy::didCreateWorkerGlobalScope(
     WorkerOrWorkletGlobalScope* workerGlobalScope) {
   DCHECK(!m_workerGlobalScope);
   m_workerGlobalScope =
       static_cast<ServiceWorkerGlobalScope*>(workerGlobalScope);
   client().workerContextStarted(this);
 }
 
 void ServiceWorkerGlobalScopeProxy::didInitializeWorkerContext() {
   ScriptState::Scope scope(
@@ skipping 39 matching lines @@
   client().workerContextDestroyed();
 }
 
 ServiceWorkerGlobalScopeProxy::ServiceWorkerGlobalScopeProxy(
     WebEmbeddedWorkerImpl& embeddedWorker,
     Document& document,
     WebServiceWorkerContextClient& client)
     : m_embeddedWorker(&embeddedWorker),
       m_document(&document),
       m_client(&client),
-      m_workerGlobalScope(nullptr) {}
+      m_workerGlobalScope(nullptr) {
+  // ServiceWorker is never associated with any document's frame. We have a

[falken, 2016/11/28 01:37:44]

"never associated" may be confusing since typically we'd say service worker may
be "associated" with many documents or none at all (indeed the next sentence
implies this). Maybe this comment can be expanded with something like: "Service
worker can sometimes run tasks that are initiated by/associated with a
document's frame but these documents can be from a different process. So we
intentionally populate the task runners with null document in order to use the
thread's default task runner. Note that |m_document| should not be used as it's
a dummy document for loading that doesn't represent the frame of any associated
document."

(same kind of thing for the shared worker comment).

[nhiroki, 2016/11/28 02:26:59]

Updated the comments.

+  // dummy document for loading but it doesn't really represent the frame of
+  // associated document(s). Here we intentionally populate the task runners
+  // with null document that will end up using the thread's default task runner.
+  m_parentFrameTaskRunners = ParentFrameTaskRunners::create(nullptr);
+}
 
 void ServiceWorkerGlobalScopeProxy::detach() {
   m_embeddedWorker = nullptr;
   m_document = nullptr;
   m_client = nullptr;
   m_workerGlobalScope = nullptr;
 }
 
 WebServiceWorkerContextClient& ServiceWorkerGlobalScopeProxy::client() const {
   DCHECK(m_client);
   return *m_client;
 }
 
 Document& ServiceWorkerGlobalScopeProxy::document() const {
   DCHECK(m_document);
   return *m_document;
 }
 
 ServiceWorkerGlobalScope* ServiceWorkerGlobalScopeProxy::workerGlobalScope()
     const {
   DCHECK(m_workerGlobalScope);
   return m_workerGlobalScope;
 }
 
 }  // namespace blink