[DevTools] Migrate target domain to new generator.

BUG=664683
TBR=pfeldman

Review-Url: https://codereview.chromium.org/2574843003
Cr-Commit-Position: refs/heads/master@{#438733}

content/browser/BUILD.gn

@@ -190,6 +190,8 @@ source_set("browser") {
     "$target_gen_dir/devtools/protocol/storage.h",
     "$target_gen_dir/devtools/protocol/system_info.cc",
     "$target_gen_dir/devtools/protocol/system_info.h",
+    "$target_gen_dir/devtools/protocol/target.cc",
+    "$target_gen_dir/devtools/protocol/target.h",
     "$target_gen_dir/devtools/protocol/tethering.cc",
     "$target_gen_dir/devtools/protocol/tethering.h",
     "$target_gen_dir/devtools/protocol/tracing.cc",

content/browser/devtools/BUILD.gn

@@ -82,6 +82,8 @@ inspector_protocol_generate("protocol_sources") {
     "protocol/storage.h",
     "protocol/system_info.cc",
     "protocol/system_info.h",
+    "protocol/target.cc",
+    "protocol/target.h",
     "protocol/tethering.cc",
     "protocol/tethering.h",
     "protocol/tracing.cc",

content/browser/devtools/protocol/devtools_protocol_handler_generator.py

@@ -643,7 +643,7 @@ fields = []
 includes = []
 fields_init = []
 
-browser_domains_list = ["Target", "Input"]
+browser_domains_list = ["Input"]
 browser_commands_list = []
 async_commands_list = [
     "Input.synthesizePinchGesture",

content/browser/devtools/protocol/target_handler.cc

@@ -11,10 +11,7 @@
 #include "content/browser/frame_host/render_frame_host_impl.h"
 
 namespace content {
-namespace devtools {
-namespace target {
-
-using Response = DevToolsProtocolClient::Response;
+namespace protocol {
 
 namespace {
 
@@ -84,12 +81,13 @@ ServiceWorkerDevToolsAgentHost::Map GetMatchingServiceWorkers(
   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
@@ -103,7 +101,11 @@ TargetHandler::TargetHandler()
 }
 
 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) {
@@ -111,16 +113,13 @@ void TargetHandler::SetRenderFrameHost(RenderFrameHostImpl* 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() {
@@ -198,8 +197,7 @@ void TargetHandler::ReattachTargetsOfType(
 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;
 }
 
@@ -208,8 +206,7 @@ void TargetHandler::TargetDestroyedInternal(
   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);
 }
 
@@ -218,9 +215,7 @@ bool TargetHandler::AttachToTargetInternal(
   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;
 }
 
@@ -229,8 +224,7 @@ void TargetHandler::DetachFromTargetInternal(DevToolsAgentHost* host) {
   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);
 }
 
@@ -284,8 +278,8 @@ Response TargetHandler::SetAttachToFrames(bool value) {
 }
 
 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,
@@ -294,7 +288,7 @@ Response TargetHandler::AttachToTarget(const std::string& target_id,
   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();
 }
@@ -302,7 +296,7 @@ Response TargetHandler::AttachToTarget(const std::string& target_id,
 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();
@@ -320,7 +314,7 @@ Response TargetHandler::SendMessageToTarget(
 
 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));
@@ -345,41 +339,42 @@ Response TargetHandler::CloseTarget(const std::string& target_id,
   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();
 }
 
@@ -392,17 +387,13 @@ void TargetHandler::DispatchProtocolMessage(
   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());
 }
 
@@ -462,6 +453,5 @@ void TargetHandler::WorkerDestroyed(
   UpdateServiceWorkers();
 }
 
-}  // namespace target
-}  // namespace devtools
+}  // namespace protocol
 }  // namespace content

content/browser/devtools/protocol/target_handler.h

@@ -8,7 +8,7 @@
 #include <map>
 #include <set>
 
-#include "content/browser/devtools/protocol/devtools_protocol_dispatcher.h"
+#include "content/browser/devtools/protocol/target.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/public/browser/devtools_agent_host_client.h"
 #include "content/public/browser/devtools_agent_host_observer.h"
@@ -17,48 +17,52 @@ namespace content {
 
 class RenderFrameHostImpl;
 
-namespace devtools {
-namespace target {
+namespace protocol {
 
-class TargetHandler : public DevToolsAgentHostClient,
+class TargetHandler : public Target::Backend,
+                      public DevToolsAgentHostClient,
                       public ServiceWorkerDevToolsManager::Observer,
                       public DevToolsAgentHostObserver {
  public:
-  using Response = DevToolsProtocolClient::Response;
-
   TargetHandler();
   ~TargetHandler() override;
 
+  void Wire(UberDispatcher*);
   void SetRenderFrameHost(RenderFrameHostImpl* render_frame_host);
-  void SetClient(std::unique_ptr<Client> client);
-  void Detached();
+  Response Disable() override;
 
   void UpdateServiceWorkers();
   void UpdateFrames();
 
   // Domain implementation.
-  Response SetDiscoverTargets(bool discover);
-  Response SetAutoAttach(bool auto_attach, bool wait_for_debugger_on_start);
-  Response SetAttachToFrames(bool value);
+  Response SetDiscoverTargets(bool discover) override;
+  Response SetAutoAttach(bool auto_attach,
+                         bool wait_for_debugger_on_start) override;
+  Response SetAttachToFrames(bool value) override;
   Response SetRemoteLocations(
-      const std::vector<std::unique_ptr<base::DictionaryValue>>&);
-  Response AttachToTarget(const std::string& target_id, bool* out_success);
-  Response DetachFromTarget(const std::string& target_id);
+      std::unique_ptr<protocol::Array<Target::RemoteLocation>>) override;
+  Response AttachToTarget(const std::string& target_id,
+                          bool* out_success) override;
+  Response DetachFromTarget(const std::string& target_id) override;
   Response SendMessageToTarget(const std::string& target_id,
-                               const std::string& message);
-  Response GetTargetInfo(const std::string& target_id,
-                         scoped_refptr<TargetInfo>* target_info);
-  Response ActivateTarget(const std::string& target_id);
-  Response CloseTarget(const std::string& target_id, bool* out_success);
-  Response CreateBrowserContext(std::string* out_context_id);
+                               const std::string& message) override;
+  Response GetTargetInfo(
+      const std::string& target_id,
+      std::unique_ptr<Target::TargetInfo>* target_info) override;
+  Response ActivateTarget(const std::string& target_id) override;
+  Response CloseTarget(const std::string& target_id,
+                       bool* out_success) override;
+  Response CreateBrowserContext(std::string* out_context_id) override;
   Response DisposeBrowserContext(const std::string& context_id,
-                                 bool* out_success);
+                                 bool* out_success) override;
   Response CreateTarget(const std::string& url,
-                        const int* width,
-                        const int* height,
-                        const std::string* context_id,
-                        std::string* out_target_id);
-  Response GetTargets(std::vector<scoped_refptr<TargetInfo>>* target_infos);
+                        Maybe<int> width,
+                        Maybe<int> height,
+                        Maybe<std::string> context_id,
+                        std::string* out_target_id) override;
+  Response GetTargets(
+      std::unique_ptr<protocol::Array<Target::TargetInfo>>* target_infos)
+      override;
 
  private:
   using HostsMap = std::map<std::string, scoped_refptr<DevToolsAgentHost>>;
@@ -92,7 +96,7 @@ class TargetHandler : public DevToolsAgentHostClient,
   void AgentHostClosed(DevToolsAgentHost* agent_host,
                        bool replaced_with_another_client) override;
 
-  std::unique_ptr<Client> client_;
+  std::unique_ptr<Target::Frontend> frontend_;
   bool discover_;
   bool auto_attach_;
   bool wait_for_debugger_on_start_;
@@ -105,8 +109,7 @@ class TargetHandler : public DevToolsAgentHostClient,
   DISALLOW_COPY_AND_ASSIGN(TargetHandler);
 };
 
-}  // namespace target
-}  // namespace devtools
+}  // namespace protocol
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_TARGET_HANDLER_H_

content/browser/devtools/protocol_config.json

@@ -61,6 +61,9 @@
                 "domain": "SystemInfo",
                 "async": ["getInfo"]
             },
+            {
+                "domain": "Target"
+            },
             {
                 "domain": "Tethering",
                 "async": ["bind", "unbind"]

content/browser/devtools/render_frame_devtools_agent_host.cc

@@ -395,7 +395,6 @@ RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost(
     RenderFrameHostImpl* host)
     : DevToolsAgentHostImpl(base::GenerateGUID()),
       input_handler_(new devtools::input::InputHandler()),
-      target_handler_(new devtools::target::TargetHandler()),
       frame_trace_recorder_(nullptr),
       protocol_handler_(new DevToolsProtocolHandler(this)),
       handlers_frame_host_(nullptr),
@@ -404,7 +403,6 @@ RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost(
       frame_tree_node_(host->frame_tree_node()) {
   DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
   dispatcher->SetInputHandler(input_handler_.get());
-  dispatcher->SetTargetHandler(target_handler_.get());
 
   SetPending(host);
   CommitPending();
@@ -514,6 +512,10 @@ void RenderFrameDevToolsAgentHost::Attach() {
   storage_handler_->Wire(session()->dispatcher());
   storage_handler_->SetRenderFrameHost(handlers_frame_host_);
 
+  target_handler_.reset(new protocol::TargetHandler());
+  target_handler_->Wire(session()->dispatcher());
+  target_handler_->SetRenderFrameHost(handlers_frame_host_);
+
   tracing_handler_.reset(new protocol::TracingHandler(
       protocol::TracingHandler::Renderer,
       frame_tree_node_->frame_tree_node_id(),
@@ -554,6 +556,8 @@ void RenderFrameDevToolsAgentHost::Detach() {
   service_worker_handler_.reset();
   storage_handler_->Disable();
   storage_handler_.reset();
+  target_handler_->Disable();
+  target_handler_.reset();
   tracing_handler_->Disable();
   tracing_handler_.reset();
 
@@ -618,7 +622,6 @@ void RenderFrameDevToolsAgentHost::OnClientDetached() {
 #if defined(OS_ANDROID)
   power_save_blocker_.reset();
 #endif
-  target_handler_->Detached();
   frame_trace_recorder_.reset();
   in_navigation_protocol_message_buffer_.clear();
 }
@@ -692,7 +695,7 @@ void RenderFrameDevToolsAgentHost::DidFinishNavigation(
   DispatchBufferedProtocolMessagesIfNecessary();
 
   DCHECK(CheckConsistency());
-  if (navigation_handle->HasCommitted())
+  if (target_handler_ && navigation_handle->HasCommitted())
     target_handler_->UpdateServiceWorkers();
 }
 
@@ -738,7 +741,8 @@ void RenderFrameDevToolsAgentHost::RenderFrameHostChanged(
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
-  target_handler_->UpdateFrames();
+  if (target_handler_)
+    target_handler_->UpdateFrames();
 
   if (IsBrowserSideNavigationEnabled())
     return;
@@ -905,7 +909,8 @@ void RenderFrameDevToolsAgentHost::DidCommitProvisionalLoadForFrame(
   if (pending_ && pending_->host() == render_frame_host)
     CommitPending();
   DCHECK(CheckConsistency());
-  target_handler_->UpdateServiceWorkers();
+  if (target_handler_)
+    target_handler_->UpdateServiceWorkers();
 }
 
 void RenderFrameDevToolsAgentHost::DidFailProvisionalLoad(
@@ -972,7 +977,8 @@ void RenderFrameDevToolsAgentHost::UpdateProtocolHandlers(
     security_handler_->SetRenderFrameHost(host);
   if (storage_handler_)
     storage_handler_->SetRenderFrameHost(host);
-  target_handler_->SetRenderFrameHost(host);
+  if (target_handler_)
+    target_handler_->SetRenderFrameHost(host);
 }
 
 void RenderFrameDevToolsAgentHost::DisconnectWebContents() {

content/browser/devtools/render_frame_devtools_agent_host.h

@@ -41,7 +41,6 @@ class RenderFrameHostImpl;
 
 namespace devtools {
 namespace input { class InputHandler; }
-namespace target { class TargetHandler; }
 }
 
 namespace protocol {
@@ -55,6 +54,7 @@ class SchemaHandler;
 class SecurityHandler;
 class ServiceWorkerHandler;
 class StorageHandler;
+class TargetHandler;
 class TracingHandler;
 }  // namespace protocol
 
@@ -193,7 +193,7 @@ class CONTENT_EXPORT RenderFrameDevToolsAgentHost
   std::unique_ptr<protocol::SecurityHandler> security_handler_;
   std::unique_ptr<protocol::ServiceWorkerHandler> service_worker_handler_;
   std::unique_ptr<protocol::StorageHandler> storage_handler_;
-  std::unique_ptr<devtools::target::TargetHandler> target_handler_;
+  std::unique_ptr<protocol::TargetHandler> target_handler_;
   std::unique_ptr<protocol::TracingHandler> tracing_handler_;
   std::unique_ptr<protocol::EmulationHandler> emulation_handler_;
   std::unique_ptr<DevToolsFrameTraceRecorder> frame_trace_recorder_;