[DevTools] Migrate target domain to new generator.

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;
+namespace protocol {
 
 namespace {
 
 using ScopeAgentsMap =
     std::map<GURL, std::unique_ptr<ServiceWorkerDevToolsAgentHost::List>>;
 
 void GetMatchingHostsByScopeMap(
     const ServiceWorkerDevToolsAgentHost::List& agent_hosts,
     const std::set<GURL>& urls,
     ScopeAgentsMap* scope_agents_map) {
@@ skipping 49 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());
+std::unique_ptr<Target::TargetInfo> CreateInfo(DevToolsAgentHost* host) {
+  return Target::TargetInfo::Create()
+      .SetTargetId(host->GetId())
+      .SetTitle(host->GetTitle())
+      .SetUrl(host->GetURL().spec())
+      .SetType(host->GetType())
+      .Build();
 }
 
 }  // namespace
 
 TargetHandler::TargetHandler()
     : discover_(false),
       auto_attach_(false),
       wait_for_debugger_on_start_(false),
       attach_to_frames_(false),
       render_frame_host_(nullptr) {
 }
 
 TargetHandler::~TargetHandler() {
-  Detached();
+}
+
+void TargetHandler::Wire(UberDispatcher* dispatcher) {
+  frontend_.reset(new Target::Frontend(dispatcher->channel()));
+  Target::Dispatcher::wire(dispatcher, this);
 }
 
 void TargetHandler::SetRenderFrameHost(RenderFrameHostImpl* render_frame_host) {
   render_frame_host_ = render_frame_host;
   UpdateFrames();
 }
 
-void TargetHandler::SetClient(std::unique_ptr<Client> client) {
-  client_.swap(client);
-}
-
-void TargetHandler::Detached() {
+Response TargetHandler::Disable() {
   SetAutoAttach(false, false);
   SetDiscoverTargets(false);
   for (const auto& id_host : attached_hosts_)
     id_host.second->DetachClient(this);
   attached_hosts_.clear();
+  return Response::OK();
 }
 
 void TargetHandler::UpdateServiceWorkers() {
   UpdateServiceWorkers(false);
 }
 
 void TargetHandler::UpdateFrames() {
   if (!auto_attach_ || !attach_to_frames_)
     return;
 
@@ skipping 57 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(CreateInfo(host)));
+  frontend_->TargetCreated(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()));
+  frontend_->TargetDestroyed(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(CreateInfo(host))
-      ->set_waiting_for_debugger(waiting_for_debugger));
+  frontend_->AttachedToTarget(CreateInfo(host), 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()->
-      set_target_id(host->GetId()));
+  frontend_->DetachedFromTarget(host->GetId());
   attached_hosts_.erase(it);
 }
 
 // ----------------- Protocol ----------------------
 
 Response TargetHandler::SetDiscoverTargets(bool discover) {
   if (discover_ == discover)
     return Response::OK();
   discover_ = discover;
   if (discover_) {
@@ skipping 33 matching lines @@
   if (attach_to_frames_) {
     UpdateFrames();
   } else {
     HostsMap empty;
     ReattachTargetsOfType(empty, DevToolsAgentHost::kTypeFrame, false);
   }
   return Response::OK();
 }
 
 Response TargetHandler::SetRemoteLocations(
-    const std::vector<std::unique_ptr<base::DictionaryValue>>& locations) {
-  return Response::ServerError("Not supported");
+    std::unique_ptr<protocol::Array<Target::RemoteLocation>>) {
+  return Response::Error("Not supported");
 }
 
 Response TargetHandler::AttachToTarget(const std::string& target_id,
                                        bool* out_success) {
   // 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");
+    return Response::InvalidParams("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");
+    return Response::Error("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::FallThrough();
   it->second->DispatchProtocolMessage(this, message);
   return Response::OK();
 }
 
 Response TargetHandler::GetTargetInfo(
     const std::string& target_id,
-    scoped_refptr<TargetInfo>* target_info) {
+    std::unique_ptr<Target::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 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 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");
+    return Response::InvalidParams("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");
+  return Response::Error("Not supported");
 }
 
 Response TargetHandler::DisposeBrowserContext(const std::string& context_id,
                                               bool* out_success) {
-  return Response::ServerError("Not supported");
+  return Response::Error("Not supported");
 }
 
 Response TargetHandler::CreateTarget(const std::string& url,
-                                     const int* width,
-                                     const int* height,
-                                     const std::string* context_id,
+                                     Maybe<int> width,
+                                     Maybe<int> height,
+                                     Maybe<std::string> context_id,
                                      std::string* out_target_id) {
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (!delegate)
-    return Response::ServerError("Not supported");
+    return Response::Error("Not supported");
   scoped_refptr<content::DevToolsAgentHost> agent_host =
       delegate->CreateNewTarget(GURL(url));
   if (!agent_host)
-    return Response::ServerError("Not supported");
+    return Response::Error("Not supported");
   *out_target_id = agent_host->GetId();
   return Response::OK();
 }
 
 Response TargetHandler::GetTargets(
-    std::vector<scoped_refptr<TargetInfo>>* target_infos) {
+    std::unique_ptr<protocol::Array<Target::TargetInfo>>* target_infos) {
+  *target_infos = protocol::Array<Target::TargetInfo>::create();
   for (const auto& host : DevToolsAgentHost::GetOrCreateAll())
-    target_infos->push_back(CreateInfo(host.get()));
+    (*target_infos)->addItem(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(
-      ReceivedMessageFromTargetParams::Create()->
-          set_target_id(host->GetId())->
-          set_message(message));
+  frontend_->ReceivedMessageFromTarget(host->GetId(), message);
 }
 
 void TargetHandler::AgentHostClosed(
     DevToolsAgentHost* host,
     bool replaced_with_another_client) {
-  client_->DetachedFromTarget(DetachedFromTargetParams::Create()->
-      set_target_id(host->GetId()));
+  frontend_->DetachedFromTarget(host->GetId());
   attached_hosts_.erase(host->GetId());
 }
 
 // -------------- DevToolsAgentHostObserver -----------------
 
 bool TargetHandler::ShouldForceDevToolsAgentHostCreation() {
   return true;
 }
 
 void TargetHandler::DevToolsAgentHostCreated(DevToolsAgentHost* agent_host) {
@@ skipping 39 matching lines @@
 void TargetHandler::WorkerVersionDoomed(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateServiceWorkers();
 }
 
 void TargetHandler::WorkerDestroyed(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateServiceWorkers();
 }
 
-}  // namespace target
-}  // namespace devtools
+}  // namespace protocol
 }  // namespace content