ServiceWorker: Make APIs that return ServiceWorkerRegistration coin a new JS object (2/3)

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 279 matching lines @@
 
   scoped_ptr<ServiceWorkerHandleReference> handle_ref =
       adopt_handle
           ? ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get())
           : ServiceWorkerHandleReference::Create(info,
                                                  thread_safe_sender_.get());
   // WebServiceWorkerImpl constructor calls AddServiceWorker.
   return new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_.get());
 }
 
-WebServiceWorkerRegistrationImpl*
-ServiceWorkerDispatcher::CreateServiceWorkerRegistration(
+scoped_ptr<WebServiceWorkerRegistrationImpl>
+ServiceWorkerDispatcher::CreateRegistration(
     const ServiceWorkerRegistrationObjectInfo& info,
-    bool adopt_handle) {
-  DCHECK(!ContainsKey(registrations_, info.handle_id));
-  if (info.handle_id == kInvalidServiceWorkerRegistrationHandleId)
-    return NULL;
+    const ServiceWorkerVersionAttributes& attrs) {
+  return CreateRegistrationInternal(
+      ServiceWorkerRegistrationHandleReference::Create(
+          info, thread_safe_sender_.get()),
+      attrs, false /* adopt_handle */);
+}
 
-  scoped_ptr<ServiceWorkerRegistrationHandleReference> handle_ref =
-      adopt_handle ? ServiceWorkerRegistrationHandleReference::Adopt(
-                         info, thread_safe_sender_.get())
-                   : ServiceWorkerRegistrationHandleReference::Create(
-                         info, thread_safe_sender_.get());
-
-  // WebServiceWorkerRegistrationImpl constructor calls
-  // AddServiceWorkerRegistration.
-  return new WebServiceWorkerRegistrationImpl(handle_ref.Pass());
+scoped_ptr<WebServiceWorkerRegistrationImpl>
+ServiceWorkerDispatcher::AdoptRegistration(
+    const ServiceWorkerRegistrationObjectInfo& info,
+    const ServiceWorkerVersionAttributes& attrs) {
+  return CreateRegistrationInternal(
+      ServiceWorkerRegistrationHandleReference::Adopt(
+          info, thread_safe_sender_.get()),
+      attrs, true /* adopt_handle */);
 }
 
 // We can assume that this message handler is called before the worker context
 // starts because script loading happens after this association.
 // TODO(nhiroki): This association information could be pushed into
 // EmbeddedWorkerMsg_StartWorker message and handed over to the worker thread
 // without a lock in ServiceWorkerProviderContext.
 void ServiceWorkerDispatcher::OnAssociateRegistrationWithServiceWorker(
     int thread_id,
     int provider_id,
@@ skipping 51 matching lines @@
                                "OnRegistered");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::RegisterServiceWorker",
                          request_id);
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  callbacks->onSuccess(FindOrCreateRegistration(info, attrs));
+  callbacks->onSuccess(AdoptRegistration(info, attrs).release());
   pending_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUpdated(int thread_id, int request_id) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::UpdateServiceWorker",
                                request_id, "OnUpdated");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::UpdateServiceWorker",
                          request_id);
@@ skipping 39 matching lines @@
       "OnDidGetRegistration");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistration",
                          request_id);
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_get_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  WebServiceWorkerRegistrationImpl* registration = NULL;
+  scoped_ptr<WebServiceWorkerRegistrationImpl> registration;
   if (info.handle_id != kInvalidServiceWorkerHandleId)
-    registration = FindOrCreateRegistration(info, attrs);
+    registration = AdoptRegistration(info, attrs);
 
-  callbacks->onSuccess(registration);
+  callbacks->onSuccess(registration.release());
   pending_get_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistrations(
     int thread_id,
     int request_id,
     const std::vector<ServiceWorkerRegistrationObjectInfo>& infos,
     const std::vector<ServiceWorkerVersionAttributes>& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
@@ skipping 11 matching lines @@
     return;
 
   typedef blink::WebVector<blink::WebServiceWorkerRegistration*>
       WebServiceWorkerRegistrationArray;
   WebServiceWorkerRegistrationArray* registrations =
       new WebServiceWorkerRegistrationArray(infos.size());
   for (size_t i = 0; i < infos.size(); ++i) {
     if (infos[i].handle_id != kInvalidServiceWorkerHandleId) {
       ServiceWorkerRegistrationObjectInfo info(infos[i]);
       ServiceWorkerVersionAttributes attr(attrs[i]);
-      (*registrations)[i] = FindOrCreateRegistration(info, attr);
+      (*registrations)[i] = AdoptRegistration(info, attr).release();
     }
   }
 
   callbacks->onSuccess(registrations);
   pending_get_registrations_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistrationForReady(
     int thread_id,
     int request_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistrationForReady",
       request_id,
       "OnDidGetRegistrationForReady");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistrationForReady",
                          request_id);
   WebServiceWorkerGetRegistrationForReadyCallbacks* callbacks =
       get_for_ready_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  WebServiceWorkerRegistrationImpl* registration = NULL;
-  DCHECK(info.handle_id != kInvalidServiceWorkerHandleId);
-  registration = FindOrCreateRegistration(info, attrs);
-  callbacks->onSuccess(registration);
+  callbacks->onSuccess(AdoptRegistration(info, attrs).release());
   get_for_ready_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnRegistrationError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::RegisterServiceWorker",
@@ skipping 244 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);
 }
 
-WebServiceWorkerRegistrationImpl*
-ServiceWorkerDispatcher::FindOrCreateRegistration(
-    const ServiceWorkerRegistrationObjectInfo& info,
-    const ServiceWorkerVersionAttributes& attrs) {
-  RegistrationObjectMap::iterator found = registrations_.find(info.handle_id);
-  if (found != registrations_.end()) {
-    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());
-    return found->second;
-  }
-
-  bool adopt_handle = true;
-  WebServiceWorkerRegistrationImpl* registration =
-      CreateServiceWorkerRegistration(info, adopt_handle);
+scoped_ptr<WebServiceWorkerRegistrationImpl>
+ServiceWorkerDispatcher::CreateRegistrationInternal(
+    scoped_ptr<ServiceWorkerRegistrationHandleReference> handle_ref,
+    const ServiceWorkerVersionAttributes& attrs,
+    bool adopt_handle) {
+  // WebServiceWorkerRegistrationImpl constructor calls
+  // AddServiceWorkerRegistration.
+  scoped_ptr<WebServiceWorkerRegistrationImpl> registration(
+      new WebServiceWorkerRegistrationImpl(handle_ref.Pass()));
   registration->SetInstalling(GetServiceWorker(attrs.installing, adopt_handle));
   registration->SetWaiting(GetServiceWorker(attrs.waiting, adopt_handle));
   registration->SetActive(GetServiceWorker(attrs.active, adopt_handle));
-  return registration;
+  return registration.Pass();
 }
 
 }  // namespace content