[DevTools] Remove Browser domain, switch clients to Target.

content/browser/devtools/protocol/target_handler.cc

 // Copyright 2016 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/target_handler.h"
 
+#include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.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"
 
 namespace content {
 namespace devtools {
 namespace target {
 
 using Response = DevToolsProtocolClient::Response;
@@ skipping 59 matching lines @@
 
   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;
 }
 
+scoped_refptr<TargetInfo> CreateInfo(DevToolsAgentHost* host) {
+  return TargetInfo::Create()
+      ->set_target_id(host->GetId())
+      ->set_title(host->GetTitle())
+      ->set_url(host->GetURL().spec())
+      ->set_type(host->GetType());
+}
+
 }  // namespace
 
 TargetHandler::TargetHandler()
     : discover_(false),
       auto_attach_(false),
       wait_for_debugger_on_start_(false),
       attach_to_frames_(false),
       render_frame_host_(nullptr) {
 }
 
@@ skipping 87 matching lines @@
   for (const auto& pair : new_hosts) {
     if (old_hosts.find(pair.first) == old_hosts.end())
       AttachToTargetInternal(pair.second.get(), waiting_for_debugger);
   }
 }
 
 void TargetHandler::TargetCreatedInternal(DevToolsAgentHost* host) {
   if (reported_hosts_.find(host->GetId()) != reported_hosts_.end())
     return;
   client_->TargetCreated(
-      TargetCreatedParams::Create()->set_target_info(
-          TargetInfo::Create()->set_target_id(host->GetId())
-                              ->set_title(host->GetTitle())
-                              ->set_url(host->GetURL().spec())
-                              ->set_type(host->GetType())));
+      TargetCreatedParams::Create()->set_target_info(CreateInfo(host)));
   reported_hosts_[host->GetId()] = host;
 }
 
 void TargetHandler::TargetDestroyedInternal(
     DevToolsAgentHost* host) {
   auto it = reported_hosts_.find(host->GetId());
   if (it == reported_hosts_.end())
     return;
   client_->TargetDestroyed(TargetDestroyedParams::Create()
       ->set_target_id(host->GetId()));
   reported_hosts_.erase(it);
 }
 
 bool TargetHandler::AttachToTargetInternal(
     DevToolsAgentHost* host, bool waiting_for_debugger) {
   if (!host->AttachClient(this))
     return false;
   attached_hosts_[host->GetId()] = host;
   client_->AttachedToTarget(AttachedToTargetParams::Create()
-      ->set_target_info(
-          TargetInfo::Create()->set_target_id(host->GetId())
-                              ->set_title(host->GetTitle())
-                              ->set_url(host->GetURL().spec())
-                              ->set_type(host->GetType()))
+      ->set_target_info(CreateInfo(host))
       ->set_waiting_for_debugger(waiting_for_debugger));
   return true;
 }
 
 void TargetHandler::DetachFromTargetInternal(DevToolsAgentHost* host) {
   auto it = attached_hosts_.find(host->GetId());
   if (it == attached_hosts_.end())
     return;
   host->DetachClient(this);
   client_->DetachedFromTarget(DetachedFromTargetParams::Create()->
@@ skipping 50 matching lines @@
   return Response::OK();
 }
 
 Response TargetHandler::SetRemoteLocations(
     const std::vector<std::unique_ptr<base::DictionaryValue>>& locations) {
   return Response::ServerError("Not supported");
 }
 
 Response TargetHandler::AttachToTarget(const std::string& target_id,
                                        bool* out_success) {
-  auto it = reported_hosts_.find(target_id);
-  if (it == reported_hosts_.end())
-    return Response::InvalidParams("No target with such id");
-  *out_success = AttachToTargetInternal(it->second, false);
+  // TODO(dgozman): only allow reported hosts.
+  scoped_refptr<DevToolsAgentHost> agent_host =
+      DevToolsAgentHost::GetForId(target_id);
+  if (!agent_host)
+    return Response::ServerError("No target with given id found");
+  *out_success = AttachToTargetInternal(agent_host.get(), false);
   return Response::OK();
 }
 
 Response TargetHandler::DetachFromTarget(const std::string& target_id) {
   auto it = attached_hosts_.find(target_id);
   if (it == attached_hosts_.end())
     return Response::InternalError("Not attached to the target");
   DevToolsAgentHost* agent_host = it->second.get();
   DetachFromTargetInternal(agent_host);
   return Response::OK();
 }
 
 Response TargetHandler::SendMessageToTarget(
     const std::string& target_id,
     const std::string& message) {
   auto it = attached_hosts_.find(target_id);
   if (it == attached_hosts_.end())
     return Response::InternalError("Not attached to the target");
   it->second->DispatchProtocolMessage(this, message);
   return Response::OK();
 }
 
 Response TargetHandler::GetTargetInfo(
     const std::string& target_id,
     scoped_refptr<TargetInfo>* target_info) {
   // TODO(dgozman): only allow reported hosts.
   scoped_refptr<DevToolsAgentHost> agent_host(
       DevToolsAgentHost::GetForId(target_id));
   if (!agent_host)
-    return Response::InvalidParams("No target with such id");
-  *target_info = TargetInfo::Create()
-      ->set_target_id(agent_host->GetId())
-      ->set_type(agent_host->GetType())
-      ->set_title(agent_host->GetTitle())
-      ->set_url(agent_host->GetURL().spec());
+    return Response::InvalidParams("No target with given id found");
+  *target_info = CreateInfo(agent_host.get());
   return Response::OK();
 }
 
 Response TargetHandler::ActivateTarget(const std::string& target_id) {
   // TODO(dgozman): only allow reported hosts.
   scoped_refptr<DevToolsAgentHost> agent_host(
       DevToolsAgentHost::GetForId(target_id));
   if (!agent_host)
-    return Response::InvalidParams("No target with such id");
+    return Response::InvalidParams("No target with given id found");
   agent_host->Activate();
   return Response::OK();
 }
 
+Response TargetHandler::CloseTarget(const std::string& target_id,
+                                    bool* out_success) {
+  scoped_refptr<DevToolsAgentHost> agent_host =
+      DevToolsAgentHost::GetForId(target_id);
+  if (!agent_host)
+    return Response::ServerError("No target with given id found");
+  *out_success = agent_host->Close();
+  return Response::OK();
+}
+
+Response TargetHandler::CreateBrowserContext(std::string* out_context_id) {
+  return Response::ServerError("Not supported");
+}
+
+Response TargetHandler::DisposeBrowserContext(const std::string& context_id,
+                                              bool* out_success) {
+  return Response::ServerError("Not supported");
+}
+
+Response TargetHandler::CreateTarget(const std::string& url,
+                                     const int* width,
+                                     const int* height,
+                                     const std::string* context_id,
+                                     std::string* out_target_id) {
+  DevToolsManagerDelegate* delegate =
+      DevToolsManager::GetInstance()->delegate();
+  if (!delegate)
+    return Response::ServerError("Not supported");
+  scoped_refptr<content::DevToolsAgentHost> agent_host =
+      delegate->CreateNewTarget(GURL(url));
+  if (!agent_host)
+    return Response::ServerError("Not supported");
+  *out_target_id = agent_host->GetId();
+  return Response::OK();
+}
+
+Response TargetHandler::GetTargets(
+    std::vector<scoped_refptr<TargetInfo>>* target_infos) {
+  for (const auto& host : DevToolsAgentHost::GetOrCreateAll())
+    target_infos->push_back(CreateInfo(host.get()));
+  return Response::OK();
+}
+
 // ---------------- DevToolsAgentHostClient ----------------
 
 void TargetHandler::DispatchProtocolMessage(
     DevToolsAgentHost* host,
     const std::string& message) {
   auto it = attached_hosts_.find(host->GetId());
   if (it == attached_hosts_.end())
     return;  // Already disconnected.
 
   client_->ReceivedMessageFromTarget(
@@ skipping 62 matching lines @@
 }
 
 void TargetHandler::WorkerDestroyed(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateServiceWorkers();
 }
 
 }  // namespace target
 }  // namespace devtools
 }  // namespace content