DevTools: support scopes and iframes when debugging service workers.

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/strings/string_number_conversions.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_manager.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"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "url/gurl.h"
 
@@ skipping 74 matching lines @@
         CreateVersionDictionaryValue(registration_info.waiting_version));
   }
   if (registration_info.installing_version.version_id !=
       kInvalidServiceWorkerVersionId) {
     registration->set_installing_version(
         CreateVersionDictionaryValue(registration_info.installing_version));
   }
   return registration;
 }
 
+scoped_refptr<ServiceWorkerDevToolsAgentHost> GetMatchingServiceWorker(
+    const ServiceWorkerDevToolsAgentHost::List& agent_hosts,
+    const GURL& url) {
+  scoped_refptr<ServiceWorkerDevToolsAgentHost> best_host;
+  std::string best_scope;
+  for (auto host : agent_hosts) {
+    if (host->GetURL().host() != url.host())
+      continue;
+    std::string path = host->GetURL().path();
+    std::string file = host->GetURL().ExtractFileName();
+    std::string scope = path.substr(0, path.length() - file.length());
+    if (scope.length() > best_scope.length()) {
+      best_host = host;
+      best_scope = scope;
+    }
+  }
+  return best_host;
+}
+
+ServiceWorkerDevToolsAgentHost::Map GetMatchingServiceWorkers(
+    const std::set<GURL>& urls) {
+  ServiceWorkerDevToolsAgentHost::List agent_hosts;
+  ServiceWorkerDevToolsManager::GetInstance()->
+      AddAllAgentHosts(&agent_hosts);
+  ServiceWorkerDevToolsAgentHost::Map result;
+  for (const GURL& url : urls) {
+    scoped_refptr<ServiceWorkerDevToolsAgentHost> host =
+        GetMatchingServiceWorker(agent_hosts, url);
+    if (host)
+      result[host->GetId()] = host;
+  }
+  return result;
+}
+
+bool CollectURLs(std::set<GURL>* urls, FrameTreeNode* tree_node) {
+  urls->insert(tree_node->current_url());
+  return false;
+}
+
 }  // namespace
 
 using Response = DevToolsProtocolClient::Response;
 
 class ServiceWorkerHandler::ContextObserver
     : public ServiceWorkerContextObserver,
       public base::RefCountedThreadSafe<ContextObserver> {
  public:
   ContextObserver(scoped_refptr<ServiceWorkerContextWrapper> context,
                   base::WeakPtr<ServiceWorkerHandler> handler);
@@ skipping 144 matching lines @@
 
 ServiceWorkerHandler::ServiceWorkerHandler()
     : enabled_(false), weak_factory_(this) {
 }
 
 ServiceWorkerHandler::~ServiceWorkerHandler() {
   Disable();
 }
 
 void ServiceWorkerHandler::SetRenderFrameHost(
-    RenderFrameHost* render_frame_host) {
+    RenderFrameHostImpl* render_frame_host) {
+  render_frame_host_ = render_frame_host;
+  // Do not call UpdateHosts yet, wait for load to commit.
   if (!render_frame_host) {
     context_ = nullptr;
     return;
   }
   StoragePartition* partition = BrowserContext::GetStoragePartition(
       render_frame_host->GetProcess()->GetBrowserContext(),
       render_frame_host->GetSiteInstance());
   DCHECK(partition);
   context_ = static_cast<ServiceWorkerContextWrapper*>(
       partition->GetServiceWorkerContext());
 }
 
 void ServiceWorkerHandler::SetClient(scoped_ptr<Client> client) {
   client_.swap(client);
 }
 
-void ServiceWorkerHandler::SetURL(const GURL& url) {
-  url_ = url;
-  if (enabled_) {
-    for (auto pair : attached_hosts_) {
-      if (!MatchesInspectedPage(pair.second.get()))
-        WorkerDestroyed(pair.second.get());
-    }
+void ServiceWorkerHandler::UpdateHosts() {
+  if (!enabled_)
+    return;
 
-    ServiceWorkerDevToolsAgentHost::List agent_hosts;
-    ServiceWorkerDevToolsManager::GetInstance()->
-        AddAllAgentHosts(&agent_hosts);
-    for (auto host : agent_hosts) {
-      if (!MatchesInspectedPage(host.get()))
-        continue;
-      if (attached_hosts_.find(host->GetId()) != attached_hosts_.end())
-        continue;
-      // TODO(pfeldman): workers are created concurrently, we need
-      // to get notification earlier to go through the Created/Ready
-      // lifecycle.
-      WorkerReadyForInspection(host.get());
-    }
+  urls_.clear();
+  if (render_frame_host_) {
+    render_frame_host_->frame_tree_node()->frame_tree()->ForEach(
+        base::Bind(&CollectURLs, &urls_));
+  }
+
+  ServiceWorkerDevToolsAgentHost::Map old_hosts = attached_hosts_;
+  ServiceWorkerDevToolsAgentHost::Map new_hosts =
+      GetMatchingServiceWorkers(urls_);
+
+  for (auto pair : old_hosts) {
+    if (new_hosts.find(pair.first) == new_hosts.end())
+      ReportWorkerTerminated(pair.second.get());
+  }
+
+  for (auto pair : new_hosts) {
+    if (old_hosts.find(pair.first) == old_hosts.end())
+      ReportWorkerCreated(pair.second.get());
   }
 }
 
 void ServiceWorkerHandler::Detached() {
   Disable();
 }
 
 Response ServiceWorkerHandler::Enable() {
   if (enabled_)
     return Response::OK();
   if (!context_)
     return Response::InternalError("Could not connect to the context");
   enabled_ = true;
 
   ServiceWorkerDevToolsManager::GetInstance()->AddObserver(this);
-
-  ServiceWorkerDevToolsAgentHost::List agent_hosts;
-  ServiceWorkerDevToolsManager::GetInstance()->AddAllAgentHosts(&agent_hosts);
-  for (auto host : agent_hosts)
-    WorkerReadyForInspection(host.get());
-
   context_observer_ = new ContextObserver(context_, weak_factory_.GetWeakPtr());
   context_observer_->Start();
+  UpdateHosts();
   return Response::OK();
 }
 
 Response ServiceWorkerHandler::Disable() {
   if (!enabled_)
     return Response::OK();
   enabled_ = false;
 
   ServiceWorkerDevToolsManager::GetInstance()->RemoveObserver(this);
   for (const auto& pair : attached_hosts_)
@@ skipping 67 matching lines @@
 }
 
 void ServiceWorkerHandler::AgentHostClosed(
     DevToolsAgentHost* host,
     bool replaced_with_another_client) {
   WorkerDestroyed(static_cast<ServiceWorkerDevToolsAgentHost*>(host));
 }
 
 void ServiceWorkerHandler::WorkerCreated(
     ServiceWorkerDevToolsAgentHost* host) {
-  if (!MatchesInspectedPage(host))
-    return;
-  host->PauseForDebugOnStart();
+  auto hosts = GetMatchingServiceWorkers(urls_);
+  if (hosts.find(host->GetId()) != hosts.end())
+    host->PauseForDebugOnStart();
 }
 
 void ServiceWorkerHandler::WorkerReadyForInspection(
     ServiceWorkerDevToolsAgentHost* host) {
-  if (host->IsAttached() || !MatchesInspectedPage(host))
+  UpdateHosts();
+}
+
+void ServiceWorkerHandler::WorkerDestroyed(
+    ServiceWorkerDevToolsAgentHost* host) {
+  UpdateHosts();
+}
+
+void ServiceWorkerHandler::ReportWorkerCreated(
+    ServiceWorkerDevToolsAgentHost* host) {
+  if (host->IsAttached())
     return;
-
   attached_hosts_[host->GetId()] = host;
   host->AttachClient(this);
   client_->WorkerCreated(WorkerCreatedParams::Create()->
       set_worker_id(host->GetId())->
       set_url(host->GetURL().spec()));
 }
 
-void ServiceWorkerHandler::WorkerDestroyed(
+void ServiceWorkerHandler::ReportWorkerTerminated(
     ServiceWorkerDevToolsAgentHost* host) {
   auto it = attached_hosts_.find(host->GetId());
   if (it == attached_hosts_.end())
     return;
   it->second->DetachClient();
   client_->WorkerTerminated(WorkerTerminatedParams::Create()->
       set_worker_id(host->GetId()));
   attached_hosts_.erase(it);
 }
 
-bool ServiceWorkerHandler::MatchesInspectedPage(
-    ServiceWorkerDevToolsAgentHost* host) {
-  // TODO(pfeldman): match based on scope.
-  // TODO(pfeldman): match iframes.
-  return host->GetURL().host() == url_.host();
-}
-
 }  // namespace service_worker
 }  // namespace devtools
 }  // namespace content