ServiceWorker: Make "ready" fetches registration from browser process(2/3).

content/browser/service_worker/service_worker_provider_host.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/browser/service_worker/service_worker_provider_host.h"
 
 #include "base/stl_util.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
@@ skipping 58 matching lines @@
   render_frame_host->GetView()->Focus();
 
   // Move the web contents to the foreground.
   web_contents->Activate();
 
   return GetClientInfoOnUIThread(render_process_id, render_frame_id);
 }
 
 }  // anonymous namespace
 
+ServiceWorkerProviderHost::OneShotGetReadyCallback::OneShotGetReadyCallback(
+    const GetRegistrationForReadyCallback& callback)
+    : callback(callback),
+      called(false) {
+}
+
+ServiceWorkerProviderHost::OneShotGetReadyCallback::~OneShotGetReadyCallback() {
+}
+
 ServiceWorkerProviderHost::ServiceWorkerProviderHost(
     int render_process_id,
     int render_frame_id,
     int provider_id,
     ServiceWorkerProviderType provider_type,
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerDispatcherHost* dispatcher_host)
     : render_process_id_(render_process_id),
       render_frame_id_(render_frame_id),
       render_thread_id_(kDocumentMainThreadId),
@@ skipping 10 matching lines @@
     render_thread_id_ = kInvalidEmbeddedWorkerThreadId;
   }
 }
 
 ServiceWorkerProviderHost::~ServiceWorkerProviderHost() {
   // Clear docurl so the deferred activation of a waiting worker
   // won't associate the new version with a provider being destroyed.
   document_url_ = GURL();
   if (controlling_version_.get())
     controlling_version_->RemoveControllee(this);
-  if (associated_registration_.get()) {
-    DecreaseProcessReference(associated_registration_->pattern());
-    associated_registration_->RemoveListener(this);
+
+  for (auto& key_registration : matching_registrations_) {
+    DecreaseProcessReference(key_registration.second->pattern());
+    key_registration.second->RemoveListener(this);
   }
 
   for (const GURL& pattern : associated_patterns_)
     DecreaseProcessReference(pattern);
 }
 
+void ServiceWorkerProviderHost::OnVersionAttributesChanged(
+    ServiceWorkerRegistration* registration,
+    ChangedVersionAttributesMask changed_mask,
+    const ServiceWorkerRegistrationInfo& info) {
+  ReturnRegistrationForReadyIfNeeded();
+}
+
 void ServiceWorkerProviderHost::OnRegistrationFailed(
     ServiceWorkerRegistration* registration) {
-  DCHECK_EQ(associated_registration_.get(), registration);
-  DisassociateRegistration();
+  if (associated_registration_ == registration)
+    DisassociateRegistration();
+  RemoveMatchingRegistration(registration);
+}
+
+void ServiceWorkerProviderHost::OnRegistrationFinishedUninstalling(
+    ServiceWorkerRegistration* registration) {
+  RemoveMatchingRegistration(registration);
 }
 
 void ServiceWorkerProviderHost::OnSkippedWaiting(
     ServiceWorkerRegistration* registration) {
-  DCHECK_EQ(associated_registration_.get(), registration);
+  if (associated_registration_ != registration)
+    return;
   // A client is "using" a registration if it is controlled by the active
   // worker of the registration. skipWaiting doesn't cause a client to start
   // using the registration.
   if (!controlling_version_)
     return;
   ServiceWorkerVersion* active_version = registration->active_version();
   DCHECK_EQ(active_version->status(), ServiceWorkerVersion::ACTIVATING);
   SetControllerVersionAttribute(active_version);
 }
 
@@ skipping 50 matching lines @@
     return false;
   }
 
   running_hosted_version_ = live_version;
   return true;
 }
 
 void ServiceWorkerProviderHost::AssociateRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(CanAssociateRegistration(registration));
-  IncreaseProcessReference(registration->pattern());
   associated_registration_ = registration;
-  associated_registration_->AddListener(this);
+  AddMatchingRegistration(registration);
   SendAssociateRegistrationMessage();
   SetControllerVersionAttribute(registration->active_version());
 }
 
 void ServiceWorkerProviderHost::DisassociateRegistration() {
   queued_events_.clear();
   if (!associated_registration_.get())
     return;
-  DecreaseProcessReference(associated_registration_->pattern());
-  associated_registration_->RemoveListener(this);
   associated_registration_ = NULL;
   SetControllerVersionAttribute(NULL);
 
   if (!dispatcher_host_)
     return;
 
   // Disassociation message should be sent only for controllees.
   DCHECK_EQ(SERVICE_WORKER_PROVIDER_FOR_CONTROLLEE, provider_type_);
   Send(new ServiceWorkerMsg_DisassociateRegistration(
       render_thread_id_, provider_id()));
 }
 
+void ServiceWorkerProviderHost::AddMatchingRegistration(
+    ServiceWorkerRegistration* registration) {
+  DCHECK(ServiceWorkerUtils::ScopeMatches(
+        registration->pattern(), document_url_));
+  size_t key = registration->pattern().spec().size();
+  if (ContainsKey(matching_registrations_, key))
+    return;
+  IncreaseProcessReference(registration->pattern());
+  registration->AddListener(this);
+  matching_registrations_[key] = registration;
+  ReturnRegistrationForReadyIfNeeded();
+}
+
+void ServiceWorkerProviderHost::RemoveMatchingRegistration(
+    ServiceWorkerRegistration* registration) {
+  size_t key = registration->pattern().spec().size();
+  DCHECK(ContainsKey(matching_registrations_, key));
+  DecreaseProcessReference(registration->pattern());
+  registration->RemoveListener(this);
+  matching_registrations_.erase(key);
+}
+
+ServiceWorkerRegistration*
+ServiceWorkerProviderHost::MatchRegistration() const {
+  ServiceWorkerRegistrationMap::const_reverse_iterator it =
+      matching_registrations_.rbegin();
+  for (; it != matching_registrations_.rend(); ++it) {
+    if (it->second->is_uninstalled())
+      continue;
+    if (it->second->is_uninstalling())
+      return nullptr;
+    return it->second.get();
+  }
+  return nullptr;
+}
+
 scoped_ptr<ServiceWorkerRequestHandler>
 ServiceWorkerProviderHost::CreateRequestHandler(
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     scoped_refptr<ResourceRequestBody> body) {
   if (IsHostToRunningServiceWorker()) {
@@ skipping 91 matching lines @@
   is_claiming_ = true;
   if (registration == associated_registration_) {
     SetControllerVersionAttribute(registration->active_version());
   } else if (allow_association_) {
     DisassociateRegistration();
     AssociateRegistration(registration);
   }
   is_claiming_ = false;
 }
 
+bool ServiceWorkerProviderHost::GetRegistrationForReady(
+    const GetRegistrationForReadyCallback& callback) {
+  if (get_ready_callback_)
+    return false;
+  get_ready_callback_.reset(new OneShotGetReadyCallback(callback));
+  ReturnRegistrationForReadyIfNeeded();
+  return true;
+}
+
 void ServiceWorkerProviderHost::PrepareForCrossSiteTransfer() {
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, render_process_id_);
   DCHECK_NE(MSG_ROUTING_NONE, render_frame_id_);
   DCHECK_EQ(kDocumentMainThreadId, render_thread_id_);
   DCHECK_NE(SERVICE_WORKER_PROVIDER_UNKNOWN, provider_type_);
 
   for (const GURL& pattern : associated_patterns_)
     DecreaseProcessReference(pattern);
 
+  for (auto& key_registration : matching_registrations_)
+    DecreaseProcessReference(key_registration.second->pattern());
+
   if (associated_registration_.get()) {
-    DecreaseProcessReference(associated_registration_->pattern());
     if (dispatcher_host_) {
       Send(new ServiceWorkerMsg_DisassociateRegistration(
           render_thread_id_, provider_id()));
     }
   }
 
   render_process_id_ = ChildProcessHost::kInvalidUniqueID;
   render_frame_id_ = MSG_ROUTING_NONE;
   render_thread_id_ = kInvalidEmbeddedWorkerThreadId;
   provider_id_ = kInvalidServiceWorkerProviderId;
@@ skipping 14 matching lines @@
   render_process_id_ = new_process_id;
   render_frame_id_ = new_frame_id;
   render_thread_id_ = kDocumentMainThreadId;
   provider_id_ = new_provider_id;
   provider_type_ = new_provider_type;
   dispatcher_host_ = new_dispatcher_host;
 
   for (const GURL& pattern : associated_patterns_)
     IncreaseProcessReference(pattern);
 
+  for (auto& key_registration : matching_registrations_)
+    IncreaseProcessReference(key_registration.second->pattern());
+
   if (associated_registration_.get()) {
-    IncreaseProcessReference(associated_registration_->pattern());
     SendAssociateRegistrationMessage();
     if (dispatcher_host_ && associated_registration_->active_version()) {
       Send(new ServiceWorkerMsg_SetControllerServiceWorker(
           render_thread_id_, provider_id(),
           CreateAndRegisterServiceWorkerHandle(
               associated_registration_->active_version()),
           false /* shouldNotifyControllerChange */));
     }
   }
 }
@@ skipping 105 matching lines @@
 }
 
 void ServiceWorkerProviderHost::DecreaseProcessReference(
     const GURL& pattern) {
   if (context_ && context_->process_manager()) {
     context_->process_manager()->RemoveProcessReferenceFromPattern(
         pattern, render_process_id_);
   }
 }
 
+void ServiceWorkerProviderHost::ReturnRegistrationForReadyIfNeeded() {
+  if (!get_ready_callback_ || get_ready_callback_->called)
+    return;
+  ServiceWorkerRegistration* registration = MatchRegistration();
+  if (!registration)
+    return;
+  if (registration->active_version()) {
+    get_ready_callback_->callback.Run(registration);
+    get_ready_callback_->callback.Reset();
+    get_ready_callback_->called = true;
+    return;
+  }
+}
+
 bool ServiceWorkerProviderHost::IsReadyToSendMessages() const {
   return render_thread_id_ != kInvalidEmbeddedWorkerThreadId;
 }
 
 bool ServiceWorkerProviderHost::IsContextAlive() {
   return context_ != NULL;
 }
 
 void ServiceWorkerProviderHost::Send(IPC::Message* message) const {
   DCHECK(dispatcher_host_);
   DCHECK(IsReadyToSendMessages());
   dispatcher_host_->Send(message);
 }
 
 }  // namespace content