ServiceWorker: Fix matching registration info missing during shift-reload.

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/guid.h"
 #include "base/stl_util.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
@@ skipping 284 matching lines @@
   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;
 }
 
+void ServiceWorkerProviderHost::CopyMatchingRegistrations() {
+  for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
+            context_->GetProviderHostIterator();
+       !it->IsAtEnd(); it->Advance()) {
+    ServiceWorkerProviderHost* host = it->GetProviderHost();

[michaeln, 2015/06/17 21:20:14]

need to compare host process_ids as well

[xiang, 2015/06/19 07:43:24]

Done.

+    if (host->render_frame_id_ != render_frame_id_)
+      continue;
+    if (host->document_url_ != document_url_)
+      continue;

[falken, 2015/06/17 15:08:35]

I wonder if we can really be sure an old provider host is found. Would an
alternative approach be to just iterate over live registrations and add matching
ones?

[michaeln, 2015/06/17 21:20:14]

In the reload case, there will be an old provider, but your question about
whether 'skip' might apply to other cases is a good one. Seems like a method to
AddMatchingRegistrations() might be more robust?

[xiang, 2015/06/19 07:43:24]

I feel finding the old SWPH maybe faster than get all living registrations info
which contains vector creation and iterate between them.

I took a look of 'skip_service_worker', found it should be safe to say when both
'skip' and 'main resource' are true the request should be started by a force
reload.

Also I added a LOAD_BYPASS_CACHE to make this operation more explicit.

[michaeln, 2015/06/22 20:33:52]

I think agree with falken about doing this as AddMatchingRegistrations() instead
of copying from an old host. If we 'skip' service workers for any reason on page
load, we'd want to do this, right?

About performance, just add these getters to ServiceWorkerContextCore.

const std::map<int64, ServiceWorkerRegistration*>& GetLiveRegistrations() const
{ return live_registrations_; }
const std::map<int64, ServiceWorkerVersion*>& GetLiveVersions() const { return
live_versions_; }

[xiang, 2015/06/23 09:01:36]

Thanks for the suggestion, CL changed.

+    for (auto& key_registration : host->matching_registrations_)
+      AddMatchingRegistration(key_registration.second.get());
+    break;
+  }
+}
+
 void ServiceWorkerProviderHost::NotifyControllerLost() {
   SetControllerVersionAttribute(nullptr, true /* notify_controllerchange */);
 }
 
 scoped_ptr<ServiceWorkerRequestHandler>
 ServiceWorkerProviderHost::CreateRequestHandler(
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     ResourceType resource_type,
     RequestContextType request_context_type,
@@ skipping 335 matching lines @@
   return context_ != NULL;
 }
 
 void ServiceWorkerProviderHost::Send(IPC::Message* message) const {
   DCHECK(dispatcher_host_);
   DCHECK(IsReadyToSendMessages());
   dispatcher_host_->Send(message);
 }
 
 }  // namespace content