[DevTools] Migrate target domain to new generator.

content/browser/devtools/render_frame_devtools_agent_host.cc

 // Copyright (c) 2012 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/render_frame_devtools_agent_host.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/guid.h"
@@ skipping 377 matching lines @@
   if (ShouldForceCreation()) {
     // Force agent host.
     DevToolsAgentHost::GetOrCreateFor(web_contents);
   }
 }
 
 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),
       current_frame_crashed_(false),
       pending_handle_(nullptr),
       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();
   WebContentsObserver::Observe(WebContents::FromRenderFrameHost(host));
 
   if (web_contents() && web_contents()->GetCrashedStatus() !=
       base::TERMINATION_STATUS_STILL_RUNNING) {
       current_frame_crashed_ = true;
   }
 
@@ skipping 89 matching lines @@
   }
 
   service_worker_handler_.reset(new protocol::ServiceWorkerHandler());
   service_worker_handler_->Wire(session()->dispatcher());
   service_worker_handler_->SetRenderFrameHost(handlers_frame_host_);
 
   storage_handler_.reset(new protocol::StorageHandler());
   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(),
       GetIOContext()));
   tracing_handler_->Wire(session()->dispatcher());
 
   if (current_)
     current_->Attach();
   if (pending_)
     pending_->Attach();
@@ skipping 20 matching lines @@
   schema_handler_->Disable();
   schema_handler_.reset();
   if (security_handler_) {
     security_handler_->Disable();
     security_handler_.reset();
   }
   service_worker_handler_->Disable();
   service_worker_handler_.reset();
   storage_handler_->Disable();
   storage_handler_.reset();
+  target_handler_->Disable();
+  target_handler_.reset();
   tracing_handler_->Disable();
   tracing_handler_.reset();
 
   if (current_)
     current_->Detach();
   if (pending_)
     pending_->Detach();
   OnClientDetached();
 }
 
@@ skipping 44 matching lines @@
     return;
 
   frame_trace_recorder_.reset(new DevToolsFrameTraceRecorder());
   CreatePowerSaveBlocker();
 }
 
 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();
 }
 
 RenderFrameDevToolsAgentHost::~RenderFrameDevToolsAgentHost() {
   Instances::iterator it = std::find(g_instances.Get().begin(),
                                      g_instances.Get().end(),
                                      this);
   if (it != g_instances.Get().end())
     g_instances.Get().erase(it);
@@ skipping 53 matching lines @@
       DCHECK(pending_->host() == navigation_handle->GetRenderFrameHost());
       CommitPending();
     } else {
       DiscardPending();
     }
     pending_handle_ = nullptr;
   }
   DispatchBufferedProtocolMessagesIfNecessary();
 
   DCHECK(CheckConsistency());
-  if (navigation_handle->HasCommitted())
+  if (target_handler_ && navigation_handle->HasCommitted())
     target_handler_->UpdateServiceWorkers();
 }
 
 void RenderFrameDevToolsAgentHost::AboutToNavigateRenderFrame(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
   if (IsBrowserSideNavigationEnabled())
@@ skipping 25 matching lines @@
   navigating_handles_.insert(navigation_handle);
   DCHECK(CheckConsistency());
 }
 
 void RenderFrameDevToolsAgentHost::RenderFrameHostChanged(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
-  target_handler_->UpdateFrames();
+  if (target_handler_)
+    target_handler_->UpdateFrames();
 
   if (IsBrowserSideNavigationEnabled())
     return;
 
   DCHECK(!pending_ || pending_->host() != old_host);
   if (!current_ || current_->host() != old_host) {
     DCHECK(CheckConsistency());
     return;
   }
 
@@ skipping 146 matching lines @@
     const GURL& url,
     ui::PageTransition transition_type) {
   // CommitPending may destruct |this|.
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
 
   if (IsBrowserSideNavigationEnabled())
     return;
   if (pending_ && pending_->host() == render_frame_host)
     CommitPending();
   DCHECK(CheckConsistency());
-  target_handler_->UpdateServiceWorkers();
+  if (target_handler_)
+    target_handler_->UpdateServiceWorkers();
 }
 
 void RenderFrameDevToolsAgentHost::DidFailProvisionalLoad(
     RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     int error_code,
     const base::string16& error_description,
     bool was_ignored_by_handler) {
   if (IsBrowserSideNavigationEnabled())
     return;
@@ skipping 46 matching lines @@
   if (network_handler_)
     network_handler_->SetRenderFrameHost(host);
   if (page_handler_)
     page_handler_->SetRenderFrameHost(host);
   if (service_worker_handler_)
     service_worker_handler_->SetRenderFrameHost(host);
   if (security_handler_)
     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() {
   if (pending_)
     DiscardPending();
   UpdateProtocolHandlers(nullptr);
   disconnected_ = std::move(current_);
   disconnected_->Detach();
   frame_tree_node_ = nullptr;
   in_navigation_protocol_message_buffer_.clear();
@@ skipping 200 matching lines @@
     RenderFrameHost* host) {
   return (current_ && current_->host() == host) ||
       (pending_ && pending_->host() == host);
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {
   return current_ && current_->host()->GetParent();
 }
 
 }  // namespace content