Make ServiceWorkerDispatcher reuse existing WebServiceWorkerImpls.

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 "content/child/child_thread.h"
@@ skipping 130 matching lines @@
 ServiceWorkerDispatcher* ServiceWorkerDispatcher::GetThreadSpecificInstance() {
   if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted)
     return NULL;
   return g_dispatcher_tls.Pointer()->Get();
 }
 
 void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() {
   delete this;
 }
 
+WebServiceWorkerImpl* ServiceWorkerDispatcher::GetServiceWorker(
+    const ServiceWorkerObjectInfo& info,
+    bool adopt_handle) {
+  WorkerObjectMap::iterator existing_worker =
+      service_workers_.find(info.handle_id);
+
+  if (existing_worker != service_workers_.end()) {
+    if (adopt_handle) {
+      // We are instructed to adopt a handle but we already have one, so
+      // adopt and destroy a handle ref.
+      ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_);

[falken, 2014/06/02 05:40:11]

I'm not sure I understand this, incrementing then decrementing ref count seems
like it should be a no-op. Why is it necessary to call Adopt?

Also, in what circumstances do we expect adopt_handle to be true although
there's an existing handle? I guess if navigator.serviceworker.register resolves
with an existing service worker, right?

[falken, 2014/06/02 05:56:19]

In chatting with dominicc, I realized I totally missed that Adopt isn't
incrementing ref count. This makes sense to me now.

+    }
+    return existing_worker->second;
+  }
+
+  scoped_ptr<ServiceWorkerHandleReference> handle_ref =
+      adopt_handle
+          ? ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_)
+          : ServiceWorkerHandleReference::Create(info, thread_safe_sender_);
+  // WebServiceWorkerImpl constructor calls AddServiceWorker.
+  return new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_);
+}
+
 void ServiceWorkerDispatcher::OnRegistered(
     int thread_id,
     int request_id,
     const ServiceWorkerObjectInfo& info) {
   WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks =
       pending_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  // The browser has to generate the registration_id so the same
-  // worker can be called from different renderer contexts. However,
-  // the impl object doesn't have to be the same instance across calls
-  // unless we require the DOM objects to be identical when there's a
-  // duplicate registration. So for now we mint a new object each
-  // time.
-  //
-  // WebServiceWorkerImpl's ctor internally calls AddServiceWorker.
-  scoped_ptr<WebServiceWorkerImpl> worker(
-      new WebServiceWorkerImpl(info, thread_safe_sender_));
-  callbacks->onSuccess(worker.release());
+  callbacks->onSuccess(GetServiceWorker(info, true));
   pending_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUnregistered(
     int thread_id,
     int request_id) {
   WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks =
       pending_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
@@ skipping 39 matching lines @@
     const ServiceWorkerObjectInfo& info) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider != provider_contexts_.end()) {
     provider->second->OnSetCurrentServiceWorker(provider_id, info);
     worker_to_provider_[info.handle_id] = provider->second;
   }
 
   ScriptClientMap::iterator found = script_clients_.find(provider_id);
   if (found != script_clients_.end()) {
     // Populate the .current field with the new worker object.
-    scoped_ptr<ServiceWorkerHandleReference> handle_ref(
-        ServiceWorkerHandleReference::Create(info, thread_safe_sender_));
-    found->second->setCurrentServiceWorker(
-        new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_));
+    found->second->setCurrentServiceWorker(GetServiceWorker(info, false));
   }
 }
 
 void ServiceWorkerDispatcher::OnPostMessage(
     int thread_id,
     int provider_id,
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids,
     const std::vector<int>& new_routing_ids) {
   // Make sure we're on the main document thread. (That must be the only
@@ skipping 25 matching lines @@
   DCHECK(!ContainsKey(service_workers_, handle_id));
   service_workers_[handle_id] = worker;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorker(int handle_id) {
   DCHECK(ContainsKey(service_workers_, handle_id));
   service_workers_.erase(handle_id);
 }
 
 }  // namespace content