[OnionSoup] Make SWContainer a supplement of Document

After https://crrev.com/c/1238079, blink::SWContainerClient becomes a
supplement of Document and its only user is blink::SWContainer.
This indirection looks redundant, so this CL refactors SWContainer to be
also a supplement of Document and makes it take over all code logic of
SWContainerClient, then removes SWContainerClient completely.

BUG=789857

Change-Id: If2ecede8530c5d3a922f2388853b46b860fbbb2f
Reviewed-on: https://chromium-review.googlesource.com/c/1286434
Commit-Queue: Leon Han <leon.han@intel.com>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#604175}

third_party/blink/public/platform/modules/service_worker/web_service_worker_provider.h

@@ -50,10 +50,9 @@ struct WebServiceWorkerError;
 //
 // It is implemented by content::WebServiceWorkerProviderImpl.
 //
-// WebServiceWorkerProvider is created in ServiceWorkerContainerClient::From(),
-// which is used to instantiate navigator.serviceWorker. It is
-// owned by ServiceWorkerContainerClient, which is a
-// garbage collected Supplement for Document.
+// WebServiceWorkerProvider is created in ServiceWorkerContainer::From(),
+// which is used to instantiate navigator.serviceWorker. It is owned by
+// ServiceWorkerContainer, which is a garbage collected Supplement for Document.
 //
 // Each ServiceWorkerContainer instance has a WebServiceWorkerProvider.
 // ServiceWorkerContainer is called the "client" of the

third_party/blink/renderer/modules/service_worker/BUILD.gn

@@ -30,8 +30,6 @@ blink_modules_sources("service_worker") {
     "service_worker_clients.h",
     "service_worker_container.cc",
     "service_worker_container.h",
-    "service_worker_container_client.cc",
-    "service_worker_container_client.h",
     "service_worker_content_settings_proxy.cc",
     "service_worker_content_settings_proxy.h",
     "service_worker_error.cc",

third_party/blink/renderer/modules/service_worker/navigation_preload_manager.cc

@@ -8,7 +8,6 @@
 
 #include "third_party/blink/renderer/bindings/core/v8/callback_promise_adapter.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
-#include "third_party/blink/renderer/modules/service_worker/service_worker_container_client.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_registration.h"
 #include "third_party/blink/renderer/platform/network/http_parsers.h"
 

third_party/blink/renderer/modules/service_worker/navigator_service_worker.cc

@@ -122,23 +122,13 @@ ServiceWorkerContainer* NavigatorServiceWorker::serviceWorker(
              frame->GetSecurityContext()->GetSecurityOrigin()->IsLocal()) {
     UseCounter::Count(frame, WebFeature::kFileAccessedServiceWorker);
   }
-  if (!service_worker_ && frame) {
-    // We need to create a new ServiceWorkerContainer when the frame
-    // navigates to a new document. In practice, this happens only when the
-    // frame navigates from the initial empty page to a new same-origin page.
-    DCHECK(frame->DomWindow());
-    service_worker_ = ServiceWorkerContainer::Create(
-        frame->DomWindow()->GetExecutionContext(), this);
-  }
-  return service_worker_.Get();
-}
-
-void NavigatorServiceWorker::ClearServiceWorker() {
-  service_worker_ = nullptr;
+  if (!frame)
+    return nullptr;
+  return ServiceWorkerContainer::From(
+      To<Document>(frame->DomWindow()->GetExecutionContext()));
 }
 
 void NavigatorServiceWorker::Trace(blink::Visitor* visitor) {
-  visitor->Trace(service_worker_);
   Supplement<Navigator>::Trace(visitor);
 }
 

third_party/blink/renderer/modules/service_worker/navigator_service_worker.h

@@ -35,16 +35,12 @@ class MODULES_EXPORT NavigatorServiceWorker final
   static ServiceWorkerContainer* serviceWorker(ScriptState*,
                                                Navigator&,
                                                String& error_message);
-  void ClearServiceWorker();
-
   void Trace(blink::Visitor*) override;
 
  private:
   explicit NavigatorServiceWorker(Navigator&);
   ServiceWorkerContainer* serviceWorker(LocalFrame*, ExceptionState&);
   ServiceWorkerContainer* serviceWorker(LocalFrame*, String& error_message);
-
-  Member<ServiceWorkerContainer> service_worker_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/service_worker/service_worker.cc

@@ -41,7 +41,7 @@
 #include "third_party/blink/renderer/core/messaging/message_port.h"
 #include "third_party/blink/renderer/core/messaging/post_message_options.h"
 #include "third_party/blink/renderer/modules/event_target_modules.h"
-#include "third_party/blink/renderer/modules/service_worker/service_worker_container_client.h"
+#include "third_party/blink/renderer/modules/service_worker/service_worker_container.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_global_scope.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
@@ -161,7 +161,7 @@ ServiceWorker* ServiceWorker::From(ExecutionContext* context,
     return scope->GetOrCreateServiceWorker(std::move(info));
   }
 
-  return ServiceWorkerContainerClient::From(To<Document>(context))
+  return ServiceWorkerContainer::From(To<Document>(context))
       ->GetOrCreateServiceWorker(std::move(info));
 }
 

third_party/blink/renderer/modules/service_worker/service_worker_container.cc

@@ -34,7 +34,6 @@
 
 #include "base/macros.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_error_type.mojom-blink.h"
-#include "third_party/blink/public/platform/modules/service_worker/web_service_worker_provider.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/renderer/bindings/core/v8/callback_promise_adapter.h"
@@ -49,14 +48,14 @@
 #include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
 #include "third_party/blink/renderer/core/frame/deprecation.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
+#include "third_party/blink/renderer/core/frame/local_frame.h"
+#include "third_party/blink/renderer/core/frame/local_frame_client.h"
 #include "third_party/blink/renderer/core/frame/use_counter.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
 #include "third_party/blink/renderer/core/messaging/blink_transferable_message.h"
 #include "third_party/blink/renderer/core/messaging/message_port.h"
 #include "third_party/blink/renderer/modules/event_target_modules.h"
-#include "third_party/blink/renderer/modules/service_worker/navigator_service_worker.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker.h"
-#include "third_party/blink/renderer/modules/service_worker/service_worker_container_client.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_error.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_registration.h"
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
@@ -137,7 +136,7 @@ class ServiceWorkerContainer::GetRegistrationForReadyCallback
     if (ready_->GetExecutionContext() &&
         !ready_->GetExecutionContext()->IsContextDestroyed()) {
       ready_->Resolve(
-          ServiceWorkerContainerClient::From(
+          ServiceWorkerContainer::From(
               To<Document>(ready_->GetExecutionContext()))
               ->GetOrCreateServiceWorkerRegistration(std::move(info)));
     }
@@ -148,10 +147,37 @@ class ServiceWorkerContainer::GetRegistrationForReadyCallback
   DISALLOW_COPY_AND_ASSIGN(GetRegistrationForReadyCallback);
 };
 
-ServiceWorkerContainer* ServiceWorkerContainer::Create(
-    ExecutionContext* execution_context,
-    NavigatorServiceWorker* navigator) {
-  return new ServiceWorkerContainer(execution_context, navigator);
+const char ServiceWorkerContainer::kSupplementName[] = "ServiceWorkerContainer";
+
+ServiceWorkerContainer* ServiceWorkerContainer::From(Document* document) {
+  if (!document)
+    return nullptr;
+
+  ServiceWorkerContainer* container =
+      Supplement<Document>::From<ServiceWorkerContainer>(document);
+  if (!container) {
+    // TODO(leonhsl): Figure out whether it's really necessary to create an
+    // instance when there's no frame or frame client for |document|.
+    container = new ServiceWorkerContainer(document);
+    Supplement<Document>::ProvideTo(*document, container);
+    if (document->GetFrame() && document->GetFrame()->Client()) {
+      std::unique_ptr<WebServiceWorkerProvider> provider =
+          document->GetFrame()->Client()->CreateServiceWorkerProvider();
+      if (provider) {
+        provider->SetClient(container);
+        container->provider_ = std::move(provider);
+      }
+    }
+  }
+  return container;
+}
+
+ServiceWorkerContainer* ServiceWorkerContainer::CreateForTesting(
+    Document* document,
+    std::unique_ptr<WebServiceWorkerProvider> provider) {
+  ServiceWorkerContainer* container = new ServiceWorkerContainer(document);
+  container->provider_ = std::move(provider);
+  return container;
 }
 
 ServiceWorkerContainer::~ServiceWorkerContainer() {
@@ -164,14 +190,15 @@ void ServiceWorkerContainer::ContextDestroyed(ExecutionContext*) {
     provider_ = nullptr;
   }
   controller_ = nullptr;
-  navigator_->ClearServiceWorker();
 }
 
 void ServiceWorkerContainer::Trace(blink::Visitor* visitor) {
   visitor->Trace(controller_);
   visitor->Trace(ready_);
-  visitor->Trace(navigator_);
+  visitor->Trace(service_worker_registration_objects_);
+  visitor->Trace(service_worker_objects_);
   EventTargetWithInlineData::Trace(visitor);
+  Supplement<Document>::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
 }
 
@@ -476,27 +503,48 @@ void ServiceWorkerContainer::CountFeature(mojom::WebFeature feature) {
     Deprecation::CountDeprecation(GetExecutionContext(), feature);
 }
 
+ExecutionContext* ServiceWorkerContainer::GetExecutionContext() const {
+  return GetSupplementable();
+}
+
 const AtomicString& ServiceWorkerContainer::InterfaceName() const {
   return EventTargetNames::ServiceWorkerContainer;
 }
 
-ServiceWorkerContainer::ServiceWorkerContainer(
-    ExecutionContext* execution_context,
-    NavigatorServiceWorker* navigator)
-    : ContextLifecycleObserver(execution_context),
-      provider_(nullptr),
-      navigator_(navigator) {
-  if (!execution_context)
-    return;
+ServiceWorkerRegistration*
+ServiceWorkerContainer::GetOrCreateServiceWorkerRegistration(
+    WebServiceWorkerRegistrationObjectInfo info) {
+  if (info.registration_id == mojom::blink::kInvalidServiceWorkerRegistrationId)
+    return nullptr;
+
+  ServiceWorkerRegistration* registration =
+      service_worker_registration_objects_.at(info.registration_id);
+  if (registration) {
+    registration->Attach(std::move(info));
+    return registration;
+  }
 
-  if (ServiceWorkerContainerClient* client =
-          ServiceWorkerContainerClient::From(To<Document>(execution_context))) {
-    provider_ = client->Provider();
-    if (provider_)
-      provider_->SetClient(this);
+  registration =
+      new ServiceWorkerRegistration(GetSupplementable(), std::move(info));
+  service_worker_registration_objects_.Set(info.registration_id, registration);
+  return registration;
+}
+
+ServiceWorker* ServiceWorkerContainer::GetOrCreateServiceWorker(
+    WebServiceWorkerObjectInfo info) {
+  if (info.version_id == mojom::blink::kInvalidServiceWorkerVersionId)
+    return nullptr;
+  ServiceWorker* worker = service_worker_objects_.at(info.version_id);
+  if (!worker) {
+    worker = new ServiceWorker(GetSupplementable(), std::move(info));
+    service_worker_objects_.Set(info.version_id, worker);
   }
+  return worker;
 }
 
+ServiceWorkerContainer::ServiceWorkerContainer(Document* document)
+    : Supplement<Document>(*document), ContextLifecycleObserver(document) {}
+
 ServiceWorkerContainer::ReadyProperty*
 ServiceWorkerContainer::CreateReadyProperty() {
   return new ReadyProperty(GetExecutionContext(), this, ReadyProperty::kReady);

third_party/blink/renderer/modules/service_worker/service_worker_container.h

@@ -38,6 +38,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_property.h"
 #include "third_party/blink/renderer/core/dom/context_lifecycle_observer.h"
+#include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/dom/events/event_target.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/modules/service_worker/registration_options.h"
@@ -50,11 +51,10 @@
 namespace blink {
 
 class ExecutionContext;
-class NavigatorServiceWorker;
-class WebServiceWorkerProvider;
 
 class MODULES_EXPORT ServiceWorkerContainer final
     : public EventTargetWithInlineData,
+      public Supplement<Document>,
       public ContextLifecycleObserver,
       public WebServiceWorkerProviderClient {
   DEFINE_WRAPPERTYPEINFO();
@@ -64,15 +64,19 @@ class MODULES_EXPORT ServiceWorkerContainer final
   using RegistrationCallbacks =
       WebServiceWorkerProvider::WebServiceWorkerRegistrationCallbacks;
 
-  static ServiceWorkerContainer* Create(ExecutionContext*,
-                                        NavigatorServiceWorker*);
+  static const char kSupplementName[];
+
+  static ServiceWorkerContainer* From(Document*);
+
+  static ServiceWorkerContainer* CreateForTesting(
+      Document*,
+      std::unique_ptr<WebServiceWorkerProvider>);
   ~ServiceWorkerContainer() override;
 
   void Trace(blink::Visitor*) override;
 
   ServiceWorker* controller() { return controller_; }
   ScriptPromise ready(ScriptState*);
-  WebServiceWorkerProvider* Provider() { return provider_; }
 
   ScriptPromise registerServiceWorker(ScriptState*,
                                       const String& pattern,
@@ -90,16 +94,23 @@ class MODULES_EXPORT ServiceWorkerContainer final
   void CountFeature(mojom::WebFeature) override;
 
   // EventTarget overrides.
-  ExecutionContext* GetExecutionContext() const override {
-    return ContextLifecycleObserver::GetExecutionContext();
-  }
+  ExecutionContext* GetExecutionContext() const override;
   const AtomicString& InterfaceName() const override;
 
   DEFINE_ATTRIBUTE_EVENT_LISTENER(controllerchange);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(message);
 
+  // Returns the ServiceWorkerRegistration object described by the given info.
+  // Creates a new object if needed, or else returns the existing one.
+  ServiceWorkerRegistration* GetOrCreateServiceWorkerRegistration(
+      WebServiceWorkerRegistrationObjectInfo);
+
+  // Returns the ServiceWorker object described by the given info. Creates a new
+  // object if needed, or else returns the existing one.
+  ServiceWorker* GetOrCreateServiceWorker(WebServiceWorkerObjectInfo);
+
  private:
-  ServiceWorkerContainer(ExecutionContext*, NavigatorServiceWorker*);
+  explicit ServiceWorkerContainer(Document*);
 
   class GetRegistrationForReadyCallback;
   using ReadyProperty =
@@ -108,10 +119,24 @@ class MODULES_EXPORT ServiceWorkerContainer final
                             Member<ServiceWorkerRegistration>>;
   ReadyProperty* CreateReadyProperty();
 
-  WebServiceWorkerProvider* provider_;
+  std::unique_ptr<WebServiceWorkerProvider> provider_;
   Member<ServiceWorker> controller_;
   Member<ReadyProperty> ready_;
-  Member<NavigatorServiceWorker> navigator_;
+
+  // Map from service worker registration id to JavaScript
+  // ServiceWorkerRegistration object in current execution context.
+  HeapHashMap<int64_t,
+              WeakMember<ServiceWorkerRegistration>,
+              WTF::IntHash<int64_t>,
+              WTF::UnsignedWithZeroKeyHashTraits<int64_t>>
+      service_worker_registration_objects_;
+  // Map from service worker version id to JavaScript ServiceWorker object in
+  // current execution context.
+  HeapHashMap<int64_t,
+              WeakMember<ServiceWorker>,
+              WTF::IntHash<int64_t>,
+              WTF::UnsignedWithZeroKeyHashTraits<int64_t>>
+      service_worker_objects_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/service_worker/service_worker_container_client.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "third_party/blink/renderer/modules/service_worker/service_worker_container_client.h"
-
-#include <memory>
-#include "third_party/blink/public/platform/modules/service_worker/web_service_worker_provider.h"
-#include "third_party/blink/renderer/core/frame/local_frame.h"
-#include "third_party/blink/renderer/core/frame/local_frame_client.h"
-
-namespace blink {
-
-ServiceWorkerContainerClient::ServiceWorkerContainerClient(
-    Document& document,
-    std::unique_ptr<WebServiceWorkerProvider> provider)
-    : Supplement<Document>(document), provider_(std::move(provider)) {}
-
-ServiceWorkerContainerClient::~ServiceWorkerContainerClient() = default;
-
-const char ServiceWorkerContainerClient::kSupplementName[] =
-    "ServiceWorkerContainerClient";
-
-ServiceWorkerRegistration*
-ServiceWorkerContainerClient::GetOrCreateServiceWorkerRegistration(
-    WebServiceWorkerRegistrationObjectInfo info) {
-  if (info.registration_id == mojom::blink::kInvalidServiceWorkerRegistrationId)
-    return nullptr;
-
-  ServiceWorkerRegistration* registration =
-      service_worker_registration_objects_.at(info.registration_id);
-  if (registration) {
-    registration->Attach(std::move(info));
-    return registration;
-  }
-
-  registration =
-      new ServiceWorkerRegistration(GetSupplementable(), std::move(info));
-  service_worker_registration_objects_.Set(info.registration_id, registration);
-  return registration;
-}
-
-ServiceWorker* ServiceWorkerContainerClient::GetOrCreateServiceWorker(
-    WebServiceWorkerObjectInfo info) {
-  if (info.version_id == mojom::blink::kInvalidServiceWorkerVersionId)
-    return nullptr;
-  ServiceWorker* worker = service_worker_objects_.at(info.version_id);
-  if (!worker) {
-    worker = new ServiceWorker(GetSupplementable(), std::move(info));
-    service_worker_objects_.Set(info.version_id, worker);
-  }
-  return worker;
-}
-
-ServiceWorkerContainerClient* ServiceWorkerContainerClient::From(
-    Document* document) {
-  if (!document)
-    return nullptr;
-  if (!document->GetFrame() || !document->GetFrame()->Client())
-    return nullptr;
-
-  ServiceWorkerContainerClient* client =
-      Supplement<Document>::From<ServiceWorkerContainerClient>(document);
-  if (!client) {
-    client = new ServiceWorkerContainerClient(
-        *document,
-        document->GetFrame()->Client()->CreateServiceWorkerProvider());
-    Supplement<Document>::ProvideTo(*document, client);
-  }
-  return client;
-}
-
-void ServiceWorkerContainerClient::Trace(blink::Visitor* visitor) {
-  visitor->Trace(service_worker_registration_objects_);
-  visitor->Trace(service_worker_objects_);
-  Supplement<Document>::Trace(visitor);
-}
-
-}  // namespace blink

third_party/blink/renderer/modules/service_worker/service_worker_container_client.h

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_SERVICE_WORKER_SERVICE_WORKER_CONTAINER_CLIENT_H_
-#define THIRD_PARTY_BLINK_RENDERER_MODULES_SERVICE_WORKER_SERVICE_WORKER_CONTAINER_CLIENT_H_
-
-#include <memory>
-
-#include "base/macros.h"
-#include "third_party/blink/renderer/core/dom/document.h"
-#include "third_party/blink/renderer/modules/modules_export.h"
-#include "third_party/blink/renderer/modules/service_worker/service_worker.h"
-#include "third_party/blink/renderer/modules/service_worker/service_worker_registration.h"
-#include "third_party/blink/renderer/platform/bindings/name_client.h"
-#include "third_party/blink/renderer/platform/heap/handle.h"
-#include "third_party/blink/renderer/platform/wtf/forward.h"
-
-namespace blink {
-
-class WebServiceWorkerProvider;
-
-// This mainly exists to provide access to WebServiceWorkerProvider.
-// Owned by Document.
-class MODULES_EXPORT ServiceWorkerContainerClient final
-    : public GarbageCollectedFinalized<ServiceWorkerContainerClient>,
-      public Supplement<Document>,
-      public NameClient {
-  USING_GARBAGE_COLLECTED_MIXIN(ServiceWorkerContainerClient);
-
- public:
-  static const char kSupplementName[];
-
-  ServiceWorkerContainerClient(Document&,
-                               std::unique_ptr<WebServiceWorkerProvider>);
-  virtual ~ServiceWorkerContainerClient();
-
-  // Returns the ServiceWorkerRegistration object described by the object info
-  // in current execution context. Creates a new object if needed, or else
-  // returns the existing one.
-  ServiceWorkerRegistration* GetOrCreateServiceWorkerRegistration(
-      WebServiceWorkerRegistrationObjectInfo);
-
-  // Returns the ServiceWorker object described by the object info in current
-  // execution context. Creates a new object if needed, or else returns the
-  // existing one.
-  ServiceWorker* GetOrCreateServiceWorker(WebServiceWorkerObjectInfo);
-
-  WebServiceWorkerProvider* Provider() { return provider_.get(); }
-
-  static ServiceWorkerContainerClient* From(Document*);
-
-  void Trace(blink::Visitor* visitor) override;
-
-  const char* NameInHeapSnapshot() const override {
-    return "ServiceWorkerContainerClient";
-  }
-
- private:
-  std::unique_ptr<WebServiceWorkerProvider> provider_;
-  // Map from service worker registration id to JavaScript
-  // ServiceWorkerRegistration object in current execution context.
-  HeapHashMap<int64_t,
-              WeakMember<ServiceWorkerRegistration>,
-              WTF::IntHash<int64_t>,
-              WTF::UnsignedWithZeroKeyHashTraits<int64_t>>
-      service_worker_registration_objects_;
-  // Map from service worker version id to JavaScript ServiceWorker object in
-  // current execution context.
-  HeapHashMap<int64_t,
-              WeakMember<ServiceWorker>,
-              WTF::IntHash<int64_t>,
-              WTF::UnsignedWithZeroKeyHashTraits<int64_t>>
-      service_worker_objects_;
-
-  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerContainerClient);
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_SERVICE_WORKER_SERVICE_WORKER_CONTAINER_CLIENT_H_

third_party/blink/renderer/modules/service_worker/service_worker_container_test.cc

@@ -24,7 +24,6 @@
 #include "third_party/blink/renderer/core/page/focus_controller.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
 #include "third_party/blink/renderer/modules/service_worker/navigator_service_worker.h"
-#include "third_party/blink/renderer/modules/service_worker/service_worker_container_client.h"
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
 #include "third_party/blink/renderer/platform/weborigin/kurl.h"
 #include "third_party/blink/renderer/platform/weborigin/security_origin.h"
@@ -154,21 +153,11 @@ class ServiceWorkerContainerTest : public PageTestBase {
     V8GCController::CollectAllGarbageForTesting(GetIsolate());
   }
 
-  ExecutionContext* GetExecutionContext() { return &GetDocument(); }
-  NavigatorServiceWorker* GetNavigatorServiceWorker() {
-    return NavigatorServiceWorker::From(GetDocument());
-  }
   v8::Isolate* GetIsolate() { return v8::Isolate::GetCurrent(); }
   ScriptState* GetScriptState() {
     return ToScriptStateForMainWorld(GetDocument().GetFrame());
   }
 
-  void Provide(std::unique_ptr<WebServiceWorkerProvider> provider) {
-    Supplement<Document>::ProvideTo(
-        GetDocument(),
-        new ServiceWorkerContainerClient(GetDocument(), std::move(provider)));
-  }
-
   void SetPageURL(const String& url) {
     // For URL completion.
     GetDocument().SetURL(KURL(NullURL(), url));
@@ -187,10 +176,10 @@ class ServiceWorkerContainerTest : public PageTestBase {
                             const ScriptValueTest& value_test) {
     // When the registration is rejected, a register call must not reach
     // the provider.
-    Provide(std::make_unique<NotReachedWebServiceWorkerProvider>());
-
-    ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
-        GetExecutionContext(), GetNavigatorServiceWorker());
+    ServiceWorkerContainer* container =
+        ServiceWorkerContainer::CreateForTesting(
+            &GetDocument(),
+            std::make_unique<NotReachedWebServiceWorkerProvider>());
     ScriptState::Scope script_scope(GetScriptState());
     RegistrationOptions options;
     options.setScope(scope);
@@ -201,10 +190,10 @@ class ServiceWorkerContainerTest : public PageTestBase {
 
   void TestGetRegistrationRejected(const String& document_url,
                                    const ScriptValueTest& value_test) {
-    Provide(std::make_unique<NotReachedWebServiceWorkerProvider>());
-
-    ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
-        GetExecutionContext(), GetNavigatorServiceWorker());
+    ServiceWorkerContainer* container =
+        ServiceWorkerContainer::CreateForTesting(
+            &GetDocument(),
+            std::make_unique<NotReachedWebServiceWorkerProvider>());
     ScriptState::Scope script_scope(GetScriptState());
     ScriptPromise promise =
         container->getRegistration(GetScriptState(), document_url);
@@ -334,10 +323,8 @@ TEST_F(ServiceWorkerContainerTest,
   SetPageURL("http://localhost/x/index.html");
 
   StubWebServiceWorkerProvider stub_provider;
-  Provide(stub_provider.Provider());
-
-  ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
-      GetExecutionContext(), GetNavigatorServiceWorker());
+  ServiceWorkerContainer* container = ServiceWorkerContainer::CreateForTesting(
+      &GetDocument(), stub_provider.Provider());
 
   // register
   {
@@ -363,10 +350,8 @@ TEST_F(ServiceWorkerContainerTest,
   SetPageURL("http://localhost/x/index.html");
 
   StubWebServiceWorkerProvider stub_provider;
-  Provide(stub_provider.Provider());
-
-  ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
-      GetExecutionContext(), GetNavigatorServiceWorker());
+  ServiceWorkerContainer* container = ServiceWorkerContainer::CreateForTesting(
+      &GetDocument(), stub_provider.Provider());
 
   {
     ScriptState::Scope script_scope(GetScriptState());
@@ -385,10 +370,8 @@ TEST_F(ServiceWorkerContainerTest,
   SetPageURL("http://localhost/x/index.html");
 
   StubWebServiceWorkerProvider stub_provider;
-  Provide(stub_provider.Provider());
-
-  ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
-      GetExecutionContext(), GetNavigatorServiceWorker());
+  ServiceWorkerContainer* container = ServiceWorkerContainer::CreateForTesting(
+      &GetDocument(), stub_provider.Provider());
 
   // register
   {
@@ -413,10 +396,8 @@ TEST_F(ServiceWorkerContainerTest, Register_TypeOptionDelegatesToProvider) {
   SetPageURL("http://localhost/x/index.html");
 
   StubWebServiceWorkerProvider stub_provider;
-  Provide(stub_provider.Provider());
-
-  ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
-      GetExecutionContext(), GetNavigatorServiceWorker());
+  ServiceWorkerContainer* container = ServiceWorkerContainer::CreateForTesting(
+      &GetDocument(), stub_provider.Provider());
 
   // register
   {

third_party/blink/renderer/modules/service_worker/service_worker_global_scope.h

@@ -109,9 +109,8 @@ class MODULES_EXPORT ServiceWorkerGlobalScope final : public WorkerGlobalScope {
 
   void SetRegistration(WebServiceWorkerRegistrationObjectInfo info);
 
-  // Returns the ServiceWorker object described by the object info in current
-  // execution context. Creates a new object if needed, or else returns the
-  // existing one.
+  // Returns the ServiceWorker object described by the given info. Creates a new
+  // object if needed, or else returns the existing one.
   ServiceWorker* GetOrCreateServiceWorker(WebServiceWorkerObjectInfo);
 
   // EventTarget

third_party/blink/renderer/modules/service_worker/service_worker_registration.cc

@@ -14,7 +14,7 @@
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/modules/event_target_modules.h"
 #include "third_party/blink/renderer/modules/service_worker/navigation_preload_state.h"
-#include "third_party/blink/renderer/modules/service_worker/service_worker_container_client.h"
+#include "third_party/blink/renderer/modules/service_worker/service_worker_container.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_error.h"
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
 
@@ -120,7 +120,7 @@ void DidSetNavigationPreloadHeader(ScriptPromiseResolver* resolver,
 ServiceWorkerRegistration* ServiceWorkerRegistration::Take(
     ScriptPromiseResolver* resolver,
     WebServiceWorkerRegistrationObjectInfo info) {
-  return ServiceWorkerContainerClient::From(
+  return ServiceWorkerContainer::From(
              To<Document>(resolver->GetExecutionContext()))
       ->GetOrCreateServiceWorkerRegistration(std::move(info));
 }

third_party/blink/renderer/modules/service_worker/service_worker_registration.h

@@ -46,7 +46,7 @@ class ServiceWorkerRegistration final
 
   // Eager finalization needed to promptly invalidate the corresponding entry of
   // the (registration id, WeakMember<ServiceWorkerRegistration>) map inside
-  // ServiceWorkerContainerClient.
+  // ServiceWorkerContainer.
   EAGERLY_FINALIZE();
 
   // Called in 2 scenarios: