ServiceWorker: Ensure that ServiceWorkerDispatcher always adopts passed handle references (1)

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 "base/thread_task_runner_handle.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/service_worker/service_worker_dispatcher.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
@@ skipping 145 matching lines @@
 
 ServiceWorkerProviderContext::~ServiceWorkerProviderContext() {
   if (ServiceWorkerDispatcher* dispatcher =
           ServiceWorkerDispatcher::GetThreadSpecificInstance()) {
     // Remove this context from the dispatcher living on the main thread.
     dispatcher->RemoveProviderContext(this);
   }
 }
 
 void ServiceWorkerProviderContext::OnAssociateRegistration(
-    const ServiceWorkerRegistrationObjectInfo& info,
-    const ServiceWorkerVersionAttributes& attrs) {
+    scoped_ptr<ServiceWorkerRegistrationHandleReference> registration,
+    scoped_ptr<ServiceWorkerHandleReference> installing,
+    scoped_ptr<ServiceWorkerHandleReference> waiting,
+    scoped_ptr<ServiceWorkerHandleReference> active) {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
-  delegate_->AssociateRegistration(
-      ServiceWorkerRegistrationHandleReference::Adopt(
-          info, thread_safe_sender_.get()),
-      ServiceWorkerHandleReference::Adopt(attrs.installing,
-                                          thread_safe_sender_.get()),
-      ServiceWorkerHandleReference::Adopt(attrs.waiting,
-                                          thread_safe_sender_.get()),
-      ServiceWorkerHandleReference::Adopt(attrs.active,
-                                          thread_safe_sender_.get()));
+  delegate_->AssociateRegistration(registration.Pass(), installing.Pass(),
+                                   waiting.Pass(), active.Pass());
 }
 
 void ServiceWorkerProviderContext::OnDisassociateRegistration() {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
   delegate_->DisassociateRegistration();
 }
 
 void ServiceWorkerProviderContext::OnSetControllerServiceWorker(
     scoped_ptr<ServiceWorkerHandleReference> controller) {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 14 matching lines @@
 
 void ServiceWorkerProviderContext::DestructOnMainThread() const {
   if (!main_thread_task_runner_->RunsTasksOnCurrentThread() &&
       main_thread_task_runner_->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   delete this;
 }
 
 }  // namespace content