[3/5 chromium] Shows the clients which are controlled by ServiceWorker in DevTools.

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"
 #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_watcher.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_version.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 "content/public/browser/web_contents.h"
 #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 {
@@ skipping 39 matching lines @@
     case content::ServiceWorkerVersion::ACTIVATED:
       return kServiceWorkerVersionStatusActivated;
     case content::ServiceWorkerVersion::REDUNDANT:
       return kServiceWorkerVersionStatusRedundant;
   }
   return "";
 }
 
 scoped_refptr<ServiceWorkerVersion> CreateVersionDictionaryValue(
     const ServiceWorkerVersionInfo& version_info) {
+  std::vector<std::string> clients;
+  for (const auto& client : version_info.clients) {
+    int render_process_id = client.second.process_id;
+    int render_frame_id = client.second.frame_id;
+    int shared_worker_route_id = client.second.shared_worker_route_id;
+    if (render_frame_id != MSG_ROUTING_NONE) {
+      RenderFrameHostImpl* render_frame_host =
+          RenderFrameHostImpl::FromID(render_process_id, render_frame_id);
+      WebContents* web_contents =
+          WebContents::FromRenderFrameHost(render_frame_host);
+      scoped_refptr<DevToolsAgentHost> agent_host(
+          DevToolsAgentHost::GetOrCreateFor(web_contents));
+      if (agent_host)
+        clients.push_back(agent_host->GetId());
+    } else if (shared_worker_route_id != MSG_ROUTING_NONE) {
+      scoped_refptr<DevToolsAgentHost> agent_host(
+          DevToolsAgentHost::GetForWorker(render_process_id,
+                                          shared_worker_route_id));
+      if (agent_host)
+        clients.push_back(agent_host->GetId());
+    }
+  }
   scoped_refptr<ServiceWorkerVersion> version(
       ServiceWorkerVersion::Create()
           ->set_version_id(base::Int64ToString(version_info.version_id))
           ->set_registration_id(
                 base::Int64ToString(version_info.registration_id))
           ->set_script_url(version_info.script_url.spec())
           ->set_running_status(
                 GetVersionRunningStatusString(version_info.running_status))
           ->set_status(GetVersionStatusString(version_info.status))
           ->set_script_last_modified(
                 version_info.script_last_modified.ToDoubleT())
           ->set_script_response_time(
-              version_info.script_response_time.ToDoubleT()));
+                version_info.script_response_time.ToDoubleT())
+          ->set_controlled_clients(clients));
   return version;
 }
 
 scoped_refptr<ServiceWorkerRegistration> CreateRegistrationDictionaryValue(
     const ServiceWorkerRegistrationInfo& registration_info) {
   scoped_refptr<ServiceWorkerRegistration> registration(
       ServiceWorkerRegistration::Create()
           ->set_registration_id(
                 base::Int64ToString(registration_info.registration_id))
           ->set_scope_url(registration_info.pattern.spec())
@@ skipping 67 matching lines @@
 }
 
 Response CreateContextErrorResponse() {
   return Response::InternalError("Could not connect to the context");
 }
 
 Response CreateInvalidVersionIdErrorResponse() {
   return Response::InternalError("Invalid version ID");
 }
 
+const std::string GetDevToolsAgentHostTypeString(
+    content::DevToolsAgentHost::Type type) {
+  switch (type) {
+    case DevToolsAgentHost::TYPE_WEB_CONTENTS:
+      return "web_contents";
+    case DevToolsAgentHost::TYPE_FRAME:
+      return "frame";
+    case DevToolsAgentHost::TYPE_SHARED_WORKER:
+      return "shared_worker";
+    case DevToolsAgentHost::TYPE_SERVICE_WORKER:
+      return "service_worker";
+    case DevToolsAgentHost::TYPE_EXTERNAL:
+      return "external";
+    case DevToolsAgentHost::TYPE_BROWSER:
+      return "browser";
+    default:
+      NOTREACHED() << type;
+  }
+  return "";
+}
+
 }  // namespace
 
 ServiceWorkerHandler::ServiceWorkerHandler()
     : enabled_(false), weak_factory_(this) {
 }
 
 ServiceWorkerHandler::~ServiceWorkerHandler() {
   Disable();
 }
 
@@ skipping 196 matching lines @@
     return CreateContextErrorResponse();
   int64 id = 0;
   if (!base::StringToInt64(registration_id, &id))
     return CreateInvalidVersionIdErrorResponse();
   BrowserContext::DeliverPushMessage(
       render_frame_host_->GetProcess()->GetBrowserContext(), GURL(origin), id,
       data, base::Bind(&PushDeliveryNoOp));
   return Response::OK();
 }
 
+// TODO(horo): I will remove it in crrev.com/1143363009.
 Response ServiceWorkerHandler::GetTargetInfo(DevToolsCommandId command_id,
                                              const std::string& target_id) {
   return Response::InternalError("Not implemented yet");
 }
 
+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(GetDevToolsAgentHostTypeString(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,
@@ skipping 116 matching lines @@
     return;
   host->DetachClient();
   client_->WorkerTerminated(WorkerTerminatedParams::Create()->
       set_worker_id(host->GetId()));
   attached_hosts_.erase(it);
 }
 
 }  // namespace service_worker
 }  // namespace devtools
 }  // namespace content