ServiceWorker: Call SyncMatchingRegistration when document_url is changed

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 <utility>
 
 #include "base/guid.h"
 #include "base/stl_util.h"
@@ skipping 85 matching lines @@
 ServiceWorkerProviderHost::~ServiceWorkerProviderHost() {
   if (context_)
     context_->UnregisterProviderHostByClientID(client_uuid_);
 
   // 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);
 
-  for (auto& key_registration : matching_registrations_) {
-    DecreaseProcessReference(key_registration.second->pattern());
-    key_registration.second->RemoveListener(this);
-  }
+  RemoveAllMatchingRegistration();
 
   for (const GURL& pattern : associated_patterns_)
     DecreaseProcessReference(pattern);
 }
 
 int ServiceWorkerProviderHost::frame_id() const {
   if (provider_type_ == SERVICE_WORKER_PROVIDER_FOR_WINDOW)
     return route_id_;
   return MSG_ROUTING_NONE;
 }
@@ skipping 55 matching lines @@
     return;
   ServiceWorkerVersion* active_version = registration->active_version();
   DCHECK_EQ(active_version->status(), ServiceWorkerVersion::ACTIVATING);
   SetControllerVersionAttribute(active_version,
                                 true /* notify_controllerchange */);
 }
 
 void ServiceWorkerProviderHost::SetDocumentUrl(const GURL& url) {
   DCHECK(!url.has_ref());
   document_url_ = url;
+  SyncMatchingRegistrations();

[nhiroki, 2016/08/22 06:35:49]

We may not have to sync up matching registrations if SetDocumentUrl() is called
for controller via ServiceWorkerDispatcherHost::OnSetHostedVersion().

if (IsProviderForClient())
  SyncMatchingRegistrations();

[shimazu, 2016/08/22 09:29:40]

Done.

 }
 
 void ServiceWorkerProviderHost::SetTopmostFrameUrl(const GURL& url) {
   topmost_frame_url_ = url;
 }
 
 void ServiceWorkerProviderHost::SetControllerVersionAttribute(
     ServiceWorkerVersion* version,
     bool notify_controllerchange) {
   CHECK(!version || IsContextSecureForServiceWorker());
@@ skipping 104 matching lines @@
 
 void ServiceWorkerProviderHost::RemoveMatchingRegistration(
     ServiceWorkerRegistration* registration) {
   size_t key = registration->pattern().spec().size();
   DCHECK(base::ContainsKey(matching_registrations_, key));
   DecreaseProcessReference(registration->pattern());
   registration->RemoveListener(this);
   matching_registrations_.erase(key);
 }
 
-void ServiceWorkerProviderHost::AddAllMatchingRegistrations() {
-  DCHECK(context_);
-  const std::map<int64_t, ServiceWorkerRegistration*>& registrations =
-      context_->GetLiveRegistrations();
-  for (const auto& key_registration : registrations) {
-    ServiceWorkerRegistration* registration = key_registration.second;
-    if (!registration->is_uninstalled() &&
-        ServiceWorkerUtils::ScopeMatches(registration->pattern(),
-                                         document_url_))
-      AddMatchingRegistration(registration);
-  }
-}
-
 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();
@@ skipping 262 matching lines @@
       associated_registration_->waiting_version());
   attrs.active = GetOrCreateServiceWorkerHandle(
       associated_registration_->active_version());
 
   // Association message should be sent only for controllees.
   DCHECK(IsProviderForClient());
   dispatcher_host_->Send(new ServiceWorkerMsg_AssociateRegistration(
       render_thread_id_, provider_id(), handle->GetObjectInfo(), attrs));
 }
 
+void ServiceWorkerProviderHost::SyncMatchingRegistrations() {
+  DCHECK(context_);
+  RemoveAllMatchingRegistration();
+  const auto& registrations = context_->GetLiveRegistrations();
+  for (const auto& key_registration : registrations) {
+    ServiceWorkerRegistration* registration = key_registration.second;
+    if (!registration->is_uninstalled() &&
+        ServiceWorkerUtils::ScopeMatches(registration->pattern(),
+                                         document_url_))
+      AddMatchingRegistration(registration);
+  }
+}
+
+void ServiceWorkerProviderHost::RemoveAllMatchingRegistration() {
+  for (const auto& it : matching_registrations_) {
+    ServiceWorkerRegistration* registration = it.second.get();
+    DecreaseProcessReference(registration->pattern());
+    registration->RemoveListener(this);
+  }
+  matching_registrations_.clear();
+}
+
 void ServiceWorkerProviderHost::IncreaseProcessReference(
     const GURL& pattern) {
   if (context_ && context_->process_manager()) {
     context_->process_manager()->AddProcessReferenceToPattern(
         pattern, render_process_id_);
   }
 }
 
 void ServiceWorkerProviderHost::DecreaseProcessReference(
     const GURL& pattern) {
@@ skipping 51 matching lines @@
       Send(new ServiceWorkerMsg_SetControllerServiceWorker(
           render_thread_id_, provider_id(),
           GetOrCreateServiceWorkerHandle(
               associated_registration_->active_version()),
           false /* shouldNotifyControllerChange */));
     }
   }
 }
 
 }  // namespace content