Add two interfaces for ServiceWorkerProviderContext/ProviderHost

content/child/service_worker/service_worker_provider_context.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 "content/child/service_worker/service_worker_provider_context.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 28 matching lines @@
 // keep the associated registration and the controller until
 // ServiceWorkerContainer is initialized.
 class ServiceWorkerProviderContext::ControlleeDelegate
     : public ServiceWorkerProviderContext::Delegate {
  public:
   ControlleeDelegate() {}
   ~ControlleeDelegate() override {}
 
   void AssociateRegistration(
       std::unique_ptr<ServiceWorkerRegistrationHandleReference> registration,
-      std::unique_ptr<ServiceWorkerHandleReference> installing,
-      std::unique_ptr<ServiceWorkerHandleReference> waiting,
-      std::unique_ptr<ServiceWorkerHandleReference> active) override {
+      std::unique_ptr<ServiceWorkerHandleReference> /* installing */,
+      std::unique_ptr<ServiceWorkerHandleReference> /* waiting */,
+      std::unique_ptr<ServiceWorkerHandleReference> /* active */) override {
     DCHECK(!registration_);
     registration_ = std::move(registration);
   }
 
   void DisassociateRegistration() override {
     controller_.reset();
     registration_.reset();
   }
 
   void SetController(
       std::unique_ptr<ServiceWorkerHandleReference> controller) override {
     DCHECK(registration_);
     DCHECK(!controller ||
            controller->handle_id() != kInvalidServiceWorkerHandleId);
     controller_ = std::move(controller);
   }
 
   bool HasAssociatedRegistration() override { return !!registration_; }
 
   void GetAssociatedRegistration(
-      ServiceWorkerRegistrationObjectInfo* info,
-      ServiceWorkerVersionAttributes* attrs) override {
+      ServiceWorkerRegistrationObjectInfo* /* info */,
+      ServiceWorkerVersionAttributes* /* attrs */) override {
     NOTREACHED();
   }
 
   ServiceWorkerHandleReference* controller() override {
     return controller_.get();
   }
 
  private:
   std::unique_ptr<ServiceWorkerRegistrationHandleReference> registration_;
   std::unique_ptr<ServiceWorkerHandleReference> controller_;
@@ skipping 20 matching lines @@
     waiting_ = std::move(waiting);
     active_ = std::move(active);
   }
 
   void DisassociateRegistration() override {
     // ServiceWorkerGlobalScope is never disassociated.
     NOTREACHED();
   }
 
   void SetController(
-      std::unique_ptr<ServiceWorkerHandleReference> controller) override {
+      std::unique_ptr<ServiceWorkerHandleReference> /* controller */) override {
     NOTREACHED();
   }
 
   bool HasAssociatedRegistration() override { return !!registration_; }
 
   void GetAssociatedRegistration(
       ServiceWorkerRegistrationObjectInfo* info,
       ServiceWorkerVersionAttributes* attrs) override {
     DCHECK(HasAssociatedRegistration());
     *info = registration_->info();
@@ skipping 15 matching lines @@
   std::unique_ptr<ServiceWorkerHandleReference> installing_;
   std::unique_ptr<ServiceWorkerHandleReference> waiting_;
   std::unique_ptr<ServiceWorkerHandleReference> active_;
 
   DISALLOW_COPY_AND_ASSIGN(ControllerDelegate);
 };
 
 ServiceWorkerProviderContext::ServiceWorkerProviderContext(
     int provider_id,
     ServiceWorkerProviderType provider_type,
+    mojom::ServiceWorkerProviderAssociatedRequest request,
     ThreadSafeSender* thread_safe_sender)
     : provider_id_(provider_id),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      thread_safe_sender_(thread_safe_sender) {
+      thread_safe_sender_(thread_safe_sender),
+      binding_(this, std::move(request)) {
   if (provider_type == SERVICE_WORKER_PROVIDER_FOR_CONTROLLER)
     delegate_.reset(new ControllerDelegate);
   else
     delegate_.reset(new ControlleeDelegate);
 
   ServiceWorkerDispatcher* dispatcher =
       ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
           thread_safe_sender_.get(), main_thread_task_runner_.get());
   dispatcher->AddProviderContext(this);
 }
@@ skipping 48 matching lines @@
 
 void ServiceWorkerProviderContext::DestructOnMainThread() const {
   if (!main_thread_task_runner_->RunsTasksInCurrentSequence() &&
       main_thread_task_runner_->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   delete this;
 }
 
 }  // namespace content