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

content/child/service_worker/service_worker_dispatcher.cc

 // Copyright 2013 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_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 341 matching lines @@
 
 // We can assume that this message handler is called before the worker context
 // starts because script loading happens after this association.
 void ServiceWorkerDispatcher::OnAssociateRegistrationWithServiceWorker(
     int thread_id,
     int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   DCHECK_EQ(kDocumentMainThreadId, thread_id);
 
+  // Adopt the references sent from the browser process and pass them to the
+  // provider context if it exists.
+  scoped_ptr<ServiceWorkerRegistrationHandleReference> registration =
+      Adopt(info);
+  scoped_ptr<ServiceWorkerHandleReference> installing = Adopt(attrs.installing);
+  scoped_ptr<ServiceWorkerHandleReference> waiting = Adopt(attrs.waiting);
+  scoped_ptr<ServiceWorkerHandleReference> active = Adopt(attrs.active);
   ProviderContextMap::iterator context = provider_contexts_.find(provider_id);
-  if (context == provider_contexts_.end())
-    return;
-  context->second->OnAssociateRegistration(info, attrs);
+  if (context != provider_contexts_.end()) {
+    context->second->OnAssociateRegistration(
+        registration.Pass(), installing.Pass(), waiting.Pass(), active.Pass());
+  }
 }
 
 void ServiceWorkerDispatcher::OnAssociateRegistration(
     int thread_id,
     int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
-  ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
-  if (provider == provider_contexts_.end())
-    return;
-  provider->second->OnAssociateRegistration(info, attrs);
+  // Adopt the references sent from the browser process and pass them to the
+  // provider context if it exists.
+  scoped_ptr<ServiceWorkerRegistrationHandleReference> registration =
+      Adopt(info);
+  scoped_ptr<ServiceWorkerHandleReference> installing = Adopt(attrs.installing);
+  scoped_ptr<ServiceWorkerHandleReference> waiting = Adopt(attrs.waiting);
+  scoped_ptr<ServiceWorkerHandleReference> active = Adopt(attrs.active);
+  ProviderContextMap::iterator context = provider_contexts_.find(provider_id);
+  if (context != provider_contexts_.end()) {
+    context->second->OnAssociateRegistration(
+        registration.Pass(), installing.Pass(), waiting.Pass(), active.Pass());
+  }
 }
 
 void ServiceWorkerDispatcher::OnDisassociateRegistration(
     int thread_id,
     int provider_id) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider == provider_contexts_.end())
     return;
   provider->second->OnDisassociateRegistration();
 }
@@ skipping 382 matching lines @@
   DCHECK(!ContainsKey(registrations_, registration_handle_id));
   registrations_[registration_handle_id] = registration;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorkerRegistration(
     int registration_handle_id) {
   DCHECK(ContainsKey(registrations_, registration_handle_id));
   registrations_.erase(registration_handle_id);
 }
 
+scoped_ptr<ServiceWorkerRegistrationHandleReference>
+ServiceWorkerDispatcher::Adopt(
+    const ServiceWorkerRegistrationObjectInfo& info) {
+  return ServiceWorkerRegistrationHandleReference::Adopt(
+      info, thread_safe_sender_.get());
+}
+
+scoped_ptr<ServiceWorkerHandleReference> ServiceWorkerDispatcher::Adopt(
+    const ServiceWorkerObjectInfo& info) {
+  return ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
+}
+
 }  // namespace content