DevTools: Attach all Service Workers except for old redundant ones.

content/browser/devtools/protocol/service_worker_handler.cc

 // Copyright 2015 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/devtools/protocol/service_worker_handler.h"
 
 #include "base/bind.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 23 matching lines @@
 #endif
 
 namespace content {
 namespace devtools {
 namespace service_worker {
 
 using Response = DevToolsProtocolClient::Response;
 
 namespace {
 
+using ScopeAgentsMap =
+    std::map<GURL, std::unique_ptr<ServiceWorkerDevToolsAgentHost::List>>;
+
 void ResultNoOp(bool success) {
 }
 void StatusNoOp(ServiceWorkerStatusCode status) {
 }
 void PushDeliveryNoOp(PushDeliveryStatus status) {
 }
 
 const std::string GetVersionRunningStatusString(
     content::ServiceWorkerVersion::RunningStatus running_status) {
   switch (running_status) {
@@ skipping 76 matching lines @@
   scoped_refptr<ServiceWorkerRegistration> registration(
       ServiceWorkerRegistration::Create()
           ->set_registration_id(
               base::Int64ToString(registration_info.registration_id))
           ->set_scope_url(registration_info.pattern.spec())
           ->set_is_deleted(registration_info.delete_flag ==
                            ServiceWorkerRegistrationInfo::IS_DELETED));
   return registration;
 }
 
-scoped_refptr<ServiceWorkerDevToolsAgentHost> GetMatchingServiceWorker(
+void GetMatchingHostsByScopeMap(
     const ServiceWorkerDevToolsAgentHost::List& agent_hosts,
-    const GURL& url) {
-  scoped_refptr<ServiceWorkerDevToolsAgentHost> best_host;
-  bool best_host_scope_matched = false;
-  int best_host_scope_length = 0;
+    const std::set<GURL>& urls,
+    ScopeAgentsMap* scope_agents_map) {
+  std::set<base::StringPiece> host_name_set;
+  for (const GURL& url : urls)
+    host_name_set.insert(url.host_piece());
+  for (const auto& host : agent_hosts) {
+    if (host_name_set.find(host->scope().host_piece()) == host_name_set.end())
+      continue;
+    const auto& it = scope_agents_map->find(host->scope());
+    if (it == scope_agents_map->end()) {
+      std::unique_ptr<ServiceWorkerDevToolsAgentHost::List> new_list(
+          new ServiceWorkerDevToolsAgentHost::List());
+      new_list->push_back(host);
+      (*scope_agents_map)[host->scope()] = std::move(new_list);
+    } else {
+      it->second->push_back(host);
+    }
+  }
+}
 
-  for (auto host : agent_hosts) {
-    if (host->GetURL().host_piece() != url.host_piece())
+GURL GetBestMatchingScope(const ScopeAgentsMap& scope_agents_map,
+                          const GURL& url) {
+  GURL best_scope;
+  bool best_scope_matched = false;
+  int best_scope_length = 0;
+
+  for (const auto& it : scope_agents_map) {
+    if (it.first.host_piece() != url.host_piece())
       continue;
-    const bool scope_matched =
-        ServiceWorkerUtils::ScopeMatches(host->scope(), url);
-    const int scope_length = host->scope().spec().length();
+    const bool scope_matched = ServiceWorkerUtils::ScopeMatches(it.first, url);
+    const int scope_length = it.first.spec().length();
     bool replace = false;
-    if (!best_host)
+    if (!best_scope.is_empty())
       replace = true;
-    else if (best_host_scope_matched)
-      replace = scope_matched && scope_length >= best_host_scope_length;
+    else if (best_scope_matched)
+      replace = scope_matched && scope_length >= best_scope_length;
     else
-      replace = scope_matched || scope_length >= best_host_scope_length;
+      replace = scope_matched || scope_length >= best_scope_length;
 
     if (replace) {
-      best_host = host;
-      best_host_scope_matched = scope_matched;
-      best_host_scope_length = scope_length;
+      best_scope = it.first;
+      best_scope_matched = scope_matched;
+      best_scope_length = scope_length;
     }
   }
-  return best_host;
+  return best_scope;
+}
+
+void AddEligibleHosts(const ServiceWorkerDevToolsAgentHost::List& list,
+                      ServiceWorkerDevToolsAgentHost::Map* result) {
+  base::Time last_installed_time;
+  base::Time last_doomed_time;
+  for (const auto& host : list) {
+    if (host->version_installed_time() > last_installed_time)
+      last_installed_time = host->version_installed_time();
+    if (host->version_doomed_time() > last_doomed_time)
+      last_doomed_time = host->version_doomed_time();
+  }
+  for (const auto& host : list) {
+    // We don't attech old redundant Service Workers when there is newer
+    // installed Service Worker.
+    if (host->version_doomed_time().is_null() ||
+        (last_installed_time < last_doomed_time &&
+         last_doomed_time == host->version_doomed_time())) {
+      (*result)[host->GetId()] = host;
+    }
+  }
 }
 
 ServiceWorkerDevToolsAgentHost::Map GetMatchingServiceWorkers(
     BrowserContext* browser_context,
     const std::set<GURL>& urls) {
   ServiceWorkerDevToolsAgentHost::Map result;
   if (!browser_context)
     return result;
+
   ServiceWorkerDevToolsAgentHost::List agent_hosts;
   ServiceWorkerDevToolsManager::GetInstance()
       ->AddAllAgentHostsForBrowserContext(browser_context, &agent_hosts);
-  for (const GURL& url : urls) {
-    scoped_refptr<ServiceWorkerDevToolsAgentHost> host =
-        GetMatchingServiceWorker(agent_hosts, url);
-    if (host)
-      result[host->GetId()] = host;
+
+  ScopeAgentsMap scope_agents_map;
+  GetMatchingHostsByScopeMap(agent_hosts, urls, &scope_agents_map);
+
+  std::set<GURL> matching_scopes;
+  for (const GURL& url : urls)
+    matching_scopes.insert(GetBestMatchingScope(scope_agents_map, url));
+
+  for (const auto& it : scope_agents_map) {
+    if (matching_scopes.find(it.first) == matching_scopes.end())
+      continue;
+    AddEligibleHosts(*it.second.get(), &result);
   }
   return result;
 }
 
 void StopServiceWorkerOnIO(scoped_refptr<ServiceWorkerContextWrapper> context,
                            int64_t version_id) {
   if (content::ServiceWorkerVersion* version =
           context->GetLiveVersion(version_id)) {
     version->StopWorker(base::Bind(&StatusNoOp));
   }
@@ skipping 358 matching lines @@
     ServiceWorkerDevToolsAgentHost* host) {
   if (ServiceWorkerDevToolsManager::GetInstance()
           ->debug_service_worker_on_start()) {
     // When debug_service_worker_on_start is true, a new DevTools window will
     // be opend in ServiceWorkerDevToolsManager::WorkerReadyForInspection.
     return;
   }
   UpdateHosts();
 }
 
+void ServiceWorkerHandler::WorkerVersionInstalled(
+    ServiceWorkerDevToolsAgentHost* host) {
+  UpdateHosts();
+}
+void ServiceWorkerHandler::WorkerVersionDoomed(
+    ServiceWorkerDevToolsAgentHost* host) {
+  UpdateHosts();
+}
+
 void ServiceWorkerHandler::WorkerDestroyed(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateHosts();
 }
 
 void ServiceWorkerHandler::ReportWorkerCreated(
     ServiceWorkerDevToolsAgentHost* host) {
   if (host->IsAttached())
     return;
   attached_hosts_[host->GetId()] = host;
@@ skipping 17 matching lines @@
 }
 
 void ServiceWorkerHandler::ClearForceUpdate() {
   if (context_)
     context_->SetForceUpdateOnPageLoad(false);
 }
 
 }  // namespace service_worker
 }  // namespace devtools
 }  // namespace content