[WONT COMMIT] ServiceWorker: Move unregister function from WebSWProvider to WebSWRegistration (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/stl_util.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 267 matching lines @@
     // We are instructed to adopt a handle but we already have one, so
     // adopt and destroy a handle ref.
     ServiceWorkerRegistrationHandleReference::Adopt(
         info, thread_safe_sender_.get());
   }
   return registration->second;
 }
 
 WebServiceWorkerRegistrationImpl*
 ServiceWorkerDispatcher::CreateServiceWorkerRegistration(
+    int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     bool adopt_handle) {
   DCHECK(!FindServiceWorkerRegistration(info, adopt_handle));
   if (info.handle_id == kInvalidServiceWorkerRegistrationHandleId)
     return NULL;
 
   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());
+  return new WebServiceWorkerRegistrationImpl(provider_id, handle_ref.Pass());
 }
 
 // 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 36 matching lines @@
   provider->second->OnDisassociateRegistration();
   worker_to_provider_.erase(provider->second->installing_handle_id());
   worker_to_provider_.erase(provider->second->waiting_handle_id());
   worker_to_provider_.erase(provider->second->active_handle_id());
   worker_to_provider_.erase(provider->second->controller_handle_id());
 }
 
 void ServiceWorkerDispatcher::OnRegistered(
     int thread_id,
     int request_id,
+    int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::RegisterServiceWorker",
                                request_id,
                                "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(FindOrCreateRegistration(provider_id, info, attrs));
   pending_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUnregistered(int thread_id,
                                              int request_id,
                                              bool is_success) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::UnregisterServiceWorker",
       request_id,
       "OnUnregistered");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::UnregisterServiceWorker",
                          request_id);
   WebServiceWorkerUnregistrationCallbacks* callbacks =
       pending_unregistration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
   callbacks->onSuccess(&is_success);
   pending_unregistration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistration(
     int thread_id,
     int request_id,
+    int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistration",
       request_id,
       "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;
   if (info.handle_id != kInvalidServiceWorkerHandleId)
-    registration = FindOrCreateRegistration(info, attrs);
+    registration = FindOrCreateRegistration(provider_id, info, attrs);
 
   callbacks->onSuccess(registration);
   pending_get_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnRegistrationError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
@@ skipping 157 matching lines @@
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   bool found =
       provider->second->GetRegistrationInfoAndVersionAttributes(&info, &attrs);
   DCHECK(found);
 
   WebServiceWorkerRegistrationImpl* registration =
       FindServiceWorkerRegistration(info, false);
   if (!registration) {
-    registration = CreateServiceWorkerRegistration(info, false);
+    registration = CreateServiceWorkerRegistration(provider_id, info, false);
     registration->SetInstalling(GetServiceWorker(attrs.installing, false));
     registration->SetWaiting(GetServiceWorker(attrs.waiting, false));
     registration->SetActive(GetServiceWorker(attrs.active, false));
   }
 
   // Resolve the .ready promise with the registration object.
   client->second->setReadyRegistration(registration);
 }
 
 void ServiceWorkerDispatcher::OnSetControllerServiceWorker(
@@ skipping 98 matching lines @@
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorkerRegistration(
     int registration_handle_id) {
   DCHECK(ContainsKey(registrations_, registration_handle_id));
   registrations_.erase(registration_handle_id);
 }
 
 WebServiceWorkerRegistrationImpl*
 ServiceWorkerDispatcher::FindOrCreateRegistration(
+    int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   WebServiceWorkerRegistrationImpl* registration =
       FindServiceWorkerRegistration(info, true);
   if (!registration) {
-    registration = CreateServiceWorkerRegistration(info, true);
+    registration = CreateServiceWorkerRegistration(provider_id, info, true);
     registration->SetInstalling(GetServiceWorker(attrs.installing, true));
     registration->SetWaiting(GetServiceWorker(attrs.waiting, true));
     registration->SetActive(GetServiceWorker(attrs.active, true));
   } else {
     // |registration| must already have version attributes, so adopt and destroy
     // handle refs for them.
     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 registration;
 }
 
 }  // namespace content