[DevTools] Move subtargets functionality from ServiceWorker to Target domain.

content/browser/devtools/protocol/service_worker_handler.cc

Index: content/browser/devtools/protocol/service_worker_handler.cc
diff --git a/content/browser/devtools/protocol/service_worker_handler.cc b/content/browser/devtools/protocol/service_worker_handler.cc
index a5de8d577f7d2fa82cbf373e0c18f1d8020e4f2b..c34d15a1ec1847012b17943d55162a3037f1d831 100644
--- a/content/browser/devtools/protocol/service_worker_handler.cc
+++ b/content/browser/devtools/protocol/service_worker_handler.cc
@@ -32,11 +32,6 @@
 #include "content/public/common/push_messaging_status.h"
 #include "url/gurl.h"
 
-// Windows headers will redefine SendMessage.
-#ifdef SendMessage
-#undef SendMessage
-#endif
-
 namespace content {
 namespace devtools {
 namespace service_worker {
@@ -45,9 +40,6 @@ using Response = DevToolsProtocolClient::Response;
 
 namespace {
 
-using ScopeAgentsMap =
-    std::map<GURL, std::unique_ptr<ServiceWorkerDevToolsAgentHost::List>>;
-
 void ResultNoOp(bool success) {
 }
 
@@ -136,6 +128,13 @@ scoped_refptr<ServiceWorkerVersion> CreateVersionDictionaryValue(
           ->set_script_response_time(
                 version_info.script_response_time.ToDoubleT())
           ->set_controlled_clients(clients));
+  scoped_refptr<DevToolsAgentHostImpl> host(
+      ServiceWorkerDevToolsManager::GetInstance()
+          ->GetDevToolsAgentHostForWorker(
+              version_info.process_id,
+              version_info.devtools_agent_route_id));
+  if (host)
+    version->set_target_id(host->GetId());
   return version;
 }
 
@@ -151,69 +150,6 @@ scoped_refptr<ServiceWorkerRegistration> CreateRegistrationDictionaryValue(
   return registration;
 }
 
-void GetMatchingHostsByScopeMap(
-    const ServiceWorkerDevToolsAgentHost::List& agent_hosts,
-    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);
-    }
-  }
-}
-
-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);
-
-  ScopeAgentsMap scope_agents_map;
-  GetMatchingHostsByScopeMap(agent_hosts, urls, &scope_agents_map);
-
-  for (const auto& it : scope_agents_map)
-    AddEligibleHosts(*it.second.get(), &result);
-
-  return result;
-}
-
 void StopServiceWorkerOnIO(scoped_refptr<ServiceWorkerContextWrapper> context,
                            int64_t version_id) {
   if (content::ServiceWorkerVersion* version =
@@ -305,35 +241,6 @@ void ServiceWorkerHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
-void ServiceWorkerHandler::UpdateHosts() {
-  if (!enabled_)
-    return;
-
-  urls_.clear();
-  BrowserContext* browser_context = nullptr;
-  if (render_frame_host_) {
-    for (FrameTreeNode* node :
-         render_frame_host_->frame_tree_node()->frame_tree()->Nodes())
-      urls_.insert(node->current_url());
-
-    browser_context = render_frame_host_->GetProcess()->GetBrowserContext();
-  }
-
-  ServiceWorkerDevToolsAgentHost::Map old_hosts = attached_hosts_;
-  ServiceWorkerDevToolsAgentHost::Map new_hosts =
-      GetMatchingServiceWorkers(browser_context, urls_);
-
-  for (const auto& pair : old_hosts) {
-    if (new_hosts.find(pair.first) == new_hosts.end())
-      ReportWorkerTerminated(pair.second.get());
-  }
-
-  for (const auto& pair : new_hosts) {
-    if (old_hosts.find(pair.first) == old_hosts.end())
-      ReportWorkerCreated(pair.second.get());
-  }
-}
-
 void ServiceWorkerHandler::Detached() {
   Disable();
 }
@@ -345,8 +252,6 @@ Response ServiceWorkerHandler::Enable() {
     return Response::InternalError("Could not connect to the context");
   enabled_ = true;
 
-  ServiceWorkerDevToolsManager::GetInstance()->AddObserver(this);
-
   context_watcher_ = new ServiceWorkerContextWatcher(
       context_, base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated,
                            weak_factory_.GetWeakPtr()),
@@ -356,7 +261,6 @@ Response ServiceWorkerHandler::Enable() {
                  weak_factory_.GetWeakPtr()));
   context_watcher_->Start();
 
-  UpdateHosts();
   return Response::OK();
 }
 
@@ -365,36 +269,13 @@ Response ServiceWorkerHandler::Disable() {
     return Response::OK();
   enabled_ = false;
 
-  ServiceWorkerDevToolsManager::GetInstance()->RemoveObserver(this);
   ClearForceUpdate();
-  for (const auto& pair : attached_hosts_)
-    pair.second->DetachClient(this);
-  attached_hosts_.clear();
   DCHECK(context_watcher_);
   context_watcher_->Stop();
   context_watcher_ = nullptr;
   return Response::OK();
 }
 
-Response ServiceWorkerHandler::SendMessage(
-    const std::string& worker_id,
-    const std::string& message) {
-  auto it = attached_hosts_.find(worker_id);
-  if (it == attached_hosts_.end())
-    return Response::InternalError("Not connected to the worker");
-  it->second->DispatchProtocolMessage(message);
-  return Response::OK();
-}
-
-Response ServiceWorkerHandler::Stop(
-    const std::string& worker_id) {
-  auto it = attached_hosts_.find(worker_id);
-  if (it == attached_hosts_.end())
-    return Response::InternalError("Not connected to the worker");
-  it->second->UnregisterWorker();
-  return Response::OK();
-}
-
 Response ServiceWorkerHandler::Unregister(const std::string& scope_url) {
   if (!enabled_)
     return Response::OK();
@@ -516,31 +397,6 @@ Response ServiceWorkerHandler::DispatchSyncEvent(
   return Response::OK();
 }
 
-Response ServiceWorkerHandler::GetTargetInfo(
-    const std::string& target_id,
-    scoped_refptr<TargetInfo>* target_info) {
-  scoped_refptr<DevToolsAgentHost> agent_host(
-      DevToolsAgentHost::GetForId(target_id));
-  if (!agent_host)
-    return Response::InvalidParams("targetId");
-  *target_info =
-      TargetInfo::Create()
-          ->set_id(agent_host->GetId())
-          ->set_type(agent_host->GetType())
-          ->set_title(agent_host->GetTitle())
-          ->set_url(agent_host->GetURL().spec());
-  return Response::OK();
-}
-
-Response ServiceWorkerHandler::ActivateTarget(const std::string& target_id) {
-  scoped_refptr<DevToolsAgentHost> agent_host(
-      DevToolsAgentHost::GetForId(target_id));
-  if (!agent_host)
-    return Response::InvalidParams("targetId");
-  agent_host->Activate();
-  return Response::OK();
-}
-
 void ServiceWorkerHandler::OpenNewDevToolsWindow(int process_id,
                                                  int devtools_agent_route_id) {
   scoped_refptr<DevToolsAgentHostImpl> agent_host(
@@ -588,89 +444,6 @@ void ServiceWorkerHandler::OnErrorReported(
               ->set_column_number(info.column_number)));
 }
 
-void ServiceWorkerHandler::DispatchProtocolMessage(
-    DevToolsAgentHost* host,
-    const std::string& message) {
-
-  auto it = attached_hosts_.find(host->GetId());
-  if (it == attached_hosts_.end())
-    return;  // Already disconnected.
-
-  client_->DispatchMessage(
-      DispatchMessageParams::Create()->
-          set_worker_id(host->GetId())->
-          set_message(message));
-}
-
-void ServiceWorkerHandler::AgentHostClosed(
-    DevToolsAgentHost* host,
-    bool replaced_with_another_client) {
-  client_->WorkerTerminated(WorkerTerminatedParams::Create()->
-      set_worker_id(host->GetId()));
-  attached_hosts_.erase(host->GetId());
-}
-
-void ServiceWorkerHandler::WorkerCreated(
-    ServiceWorkerDevToolsAgentHost* host) {
-  BrowserContext* browser_context = nullptr;
-  if (render_frame_host_)
-    browser_context = render_frame_host_->GetProcess()->GetBrowserContext();
-
-  auto hosts = GetMatchingServiceWorkers(browser_context, urls_);
-  if (hosts.find(host->GetId()) != hosts.end() && !host->IsAttached() &&
-      !host->IsPausedForDebugOnStart())
-    host->PauseForDebugOnStart();
-}
-
-void ServiceWorkerHandler::WorkerReadyForInspection(
-    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;
-  host->AttachClient(this);
-  client_->WorkerCreated(WorkerCreatedParams::Create()
-                             ->set_worker_id(host->GetId())
-                             ->set_url(host->GetURL().spec())
-                             ->set_version_id(base::Int64ToString(
-                                 host->service_worker_version_id())));
-}
-
-void ServiceWorkerHandler::ReportWorkerTerminated(
-    ServiceWorkerDevToolsAgentHost* host) {
-  auto it = attached_hosts_.find(host->GetId());
-  if (it == attached_hosts_.end())
-    return;
-  host->DetachClient(this);
-  client_->WorkerTerminated(WorkerTerminatedParams::Create()->
-      set_worker_id(host->GetId()));
-  attached_hosts_.erase(it);
-}
-
 void ServiceWorkerHandler::ClearForceUpdate() {
   if (context_)
     context_->SetForceUpdateOnPageLoad(false);