DevTools: remove DevToolsTargetDescriptor and its implementations, we are now...

DevTools: remove DevToolsTargetDescriptor and its implementations, we are now based on devtools agent hosts.

BUG=627517
TBR=this is a mechanical change

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

android_webview/browser/aw_dev_tools_discovery_provider.cc

@@ -10,7 +10,6 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "components/devtools_discovery/basic_target_descriptor.h"
 #include "components/devtools_discovery/devtools_discovery_manager.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/web_contents.h"
@@ -58,17 +57,14 @@ AwDevToolsDiscoveryProvider::AwDevToolsDiscoveryProvider() {
 AwDevToolsDiscoveryProvider::~AwDevToolsDiscoveryProvider() {
 }
 
-devtools_discovery::DevToolsTargetDescriptor::List
+content::DevToolsAgentHost::List
 AwDevToolsDiscoveryProvider::GetDescriptors() {
   DevToolsAgentHost::List agent_hosts = DevToolsAgentHost::GetOrCreateAll();
-  devtools_discovery::DevToolsTargetDescriptor::List result;
-  result.reserve(agent_hosts.size());
   for (auto& agent_host : agent_hosts) {
     agent_host->SetDescriptionOverride(
         GetViewDescription(agent_host->GetWebContents()));
-    result.push_back(new devtools_discovery::BasicTargetDescriptor(agent_host));
   }
-  return result;
+  return agent_hosts;
 }
 
 }  // namespace android_webview

android_webview/browser/aw_dev_tools_discovery_provider.h

@@ -19,7 +19,7 @@ class AwDevToolsDiscoveryProvider :
   ~AwDevToolsDiscoveryProvider() override;
 
   // devtools_discovery::DevToolsDiscoveryManager::Provider implementation.
-  devtools_discovery::DevToolsTargetDescriptor::List GetDescriptors() override;
+  content::DevToolsAgentHost::List GetDescriptors() override;
 
  private:
   AwDevToolsDiscoveryProvider();

chrome/browser/android/dev_tools_discovery_provider_android.cc

@@ -14,7 +14,6 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/ui/android/tab_model/tab_model.h"
 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
-#include "components/devtools_discovery/basic_target_descriptor.h"
 #include "components/devtools_discovery/devtools_discovery_manager.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_agent_host_client.h"
@@ -26,7 +25,6 @@
 
 using content::DevToolsAgentHost;
 using content::WebContents;
-using devtools_discovery::DevToolsTargetDescriptor;
 
 namespace {
 
@@ -164,26 +162,23 @@ class TabProxyDelegate : public content::DevToolsExternalAgentProxyDelegate,
   DISALLOW_COPY_AND_ASSIGN(TabProxyDelegate);
 };
 
-std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor>
-CreateNewAndroidTab(const GURL& url) {
+scoped_refptr<content::DevToolsAgentHost> CreateNewAndroidTab(const GURL& url) {
   if (TabModelList::empty())
-    return std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+    return nullptr;
 
   TabModel* tab_model = TabModelList::get(0);
   if (!tab_model)
-    return std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+    return nullptr;
 
   WebContents* web_contents = tab_model->CreateNewTabForDevTools(url);
   if (!web_contents)
-    return std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+    return nullptr;
 
   TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
   if (!tab)
-    return std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+    return nullptr;
 
-  scoped_refptr<content::DevToolsAgentHost> host =
-      DevToolsAgentHost::Create(new TabProxyDelegate(tab));
-  return base::WrapUnique(new devtools_discovery::BasicTargetDescriptor(host));
+  return content::DevToolsAgentHost::Create(new TabProxyDelegate(tab));
 }
 
 }  // namespace
@@ -194,9 +189,9 @@ DevToolsDiscoveryProviderAndroid::DevToolsDiscoveryProviderAndroid() {
 DevToolsDiscoveryProviderAndroid::~DevToolsDiscoveryProviderAndroid() {
 }
 
-devtools_discovery::DevToolsTargetDescriptor::List
+content::DevToolsAgentHost::List
 DevToolsDiscoveryProviderAndroid::GetDescriptors() {
-  devtools_discovery::DevToolsTargetDescriptor::List result;
+  content::DevToolsAgentHost::List result;
 
   // Enumerate existing tabs, including the ones with no WebContents.
   std::set<WebContents*> tab_web_contents;
@@ -221,7 +216,7 @@ DevToolsDiscoveryProviderAndroid::GetDescriptors() {
       if (tab_web_contents.find(web_contents) != tab_web_contents.end())
         continue;
     }
-    result.push_back(new devtools_discovery::BasicTargetDescriptor(*it));
+    result.push_back(*it);
   }
 
   return result;

chrome/browser/android/dev_tools_discovery_provider_android.h

@@ -17,7 +17,7 @@ class DevToolsDiscoveryProviderAndroid :
   ~DevToolsDiscoveryProviderAndroid() override;
 
   // devtools_discovery::DevToolsDiscoveryManager::Provider implementation.
-  devtools_discovery::DevToolsTargetDescriptor::List GetDescriptors() override;
+  content::DevToolsAgentHost::List GetDescriptors() override;
 
  private:
   DevToolsDiscoveryProviderAndroid();

chrome/browser/devtools/BUILD.gn

@@ -118,8 +118,6 @@ static_library("devtools") {
       "devtools_file_system_indexer.h",
       "devtools_file_watcher.cc",
       "devtools_file_watcher.h",
-      "devtools_target_impl.cc",
-      "devtools_target_impl.h",
       "devtools_targets_ui.cc",
       "devtools_targets_ui.h",
       "devtools_toggle_action.cc",

chrome/browser/devtools/chrome_devtools_discovery_provider.cc

@@ -5,7 +5,6 @@
 #include "chrome/browser/devtools/chrome_devtools_discovery_provider.h"
 
 #include "base/memory/ptr_util.h"
-#include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
@@ -13,20 +12,18 @@
 
 namespace {
 
-std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor>
+scoped_refptr<content::DevToolsAgentHost>
 CreateNewChromeTab(const GURL& url) {
   chrome::NavigateParams params(ProfileManager::GetLastUsedProfile(),
       url, ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
   if (!params.target_contents)
-    return std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor>();
+    return nullptr;
 
   if (!params.target_contents)
     return nullptr;
-  scoped_refptr<content::DevToolsAgentHost> host =
-      content::DevToolsAgentHost::GetOrCreateFor(params.target_contents);
-  return std::unique_ptr<DevToolsTargetImpl>(new DevToolsTargetImpl(host));
+  return content::DevToolsAgentHost::GetOrCreateFor(params.target_contents);
 }
 
 }  // namespace
@@ -37,14 +34,9 @@ ChromeDevToolsDiscoveryProvider::ChromeDevToolsDiscoveryProvider() {
 ChromeDevToolsDiscoveryProvider::~ChromeDevToolsDiscoveryProvider() {
 }
 
-devtools_discovery::DevToolsTargetDescriptor::List
+content::DevToolsAgentHost::List
 ChromeDevToolsDiscoveryProvider::GetDescriptors() {
-  std::vector<DevToolsTargetImpl*> list = DevToolsTargetImpl::EnumerateAll();
-  devtools_discovery::DevToolsTargetDescriptor::List result;
-  result.reserve(list.size());
-  for (auto* descriptor : list)
-    result.push_back(descriptor);
-  return result;
+  return content::DevToolsAgentHost::GetOrCreateAll();
 }
 
 // static

chrome/browser/devtools/chrome_devtools_discovery_provider.h

@@ -17,7 +17,7 @@ class ChromeDevToolsDiscoveryProvider :
   ~ChromeDevToolsDiscoveryProvider() override;
 
   // devtools_discovery::DevToolsDiscoveryManager::Provider implementation.
-  devtools_discovery::DevToolsTargetDescriptor::List GetDescriptors() override;
+  content::DevToolsAgentHost::List GetDescriptors() override;
 
  private:
   ChromeDevToolsDiscoveryProvider();

chrome/browser/devtools/device/adb/adb_client_socket_browsertest.cc

@@ -5,7 +5,6 @@
 #include "chrome/browser/devtools/device/adb/adb_device_provider.h"
 #include "chrome/browser/devtools/device/adb/mock_adb_server.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
-#include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_thread.h"
@@ -108,25 +107,25 @@ class AdbClientSocketTest : public InProcessBrowserTest,
     ASSERT_EQ(1U, chrome_beta_pages.size());
     ASSERT_EQ(2U, webview_pages.size());
 
-    std::unique_ptr<DevToolsTargetImpl> chrome_target(
+    scoped_refptr<content::DevToolsAgentHost> chrome_target(
         android_bridge_->CreatePageTarget(chrome_pages[0]));
-    std::unique_ptr<DevToolsTargetImpl> chrome_beta_target(
+    scoped_refptr<content::DevToolsAgentHost> chrome_beta_target(
         android_bridge_->CreatePageTarget(chrome_beta_pages[0]));
-    std::unique_ptr<DevToolsTargetImpl> webview_target_0(
+    scoped_refptr<content::DevToolsAgentHost> webview_target_0(
         android_bridge_->CreatePageTarget(webview_pages[0]));
-    std::unique_ptr<DevToolsTargetImpl> webview_target_1(
+    scoped_refptr<content::DevToolsAgentHost> webview_target_1(
         android_bridge_->CreatePageTarget(webview_pages[1]));
 
     // Check that we have non-empty description for webview pages.
-    ASSERT_EQ(0U, chrome_target->GetAgentHost()->GetDescription().size());
-    ASSERT_EQ(0U, chrome_beta_target->GetAgentHost()->GetDescription().size());
-    ASSERT_NE(0U, webview_target_0->GetAgentHost()->GetDescription().size());
-    ASSERT_NE(0U, webview_target_1->GetAgentHost()->GetDescription().size());
+    ASSERT_EQ(0U, chrome_target->GetDescription().size());
+    ASSERT_EQ(0U, chrome_beta_target->GetDescription().size());
+    ASSERT_NE(0U, webview_target_0->GetDescription().size());
+    ASSERT_NE(0U, webview_target_1->GetDescription().size());
 
     ASSERT_EQ(GURL("http://www.chromium.org/"),
-                   chrome_target->GetAgentHost()->GetURL());
+                   chrome_target->GetURL());
     ASSERT_EQ("The Chromium Projects",
-              chrome_target->GetAgentHost()->GetTitle());
+              chrome_target->GetTitle());
   }
 
  private:

chrome/browser/devtools/device/devtools_android_bridge.cc

@@ -32,7 +32,6 @@
 #include "chrome/browser/devtools/device/tcp_device_provider.h"
 #include "chrome/browser/devtools/device/usb/usb_device_provider.h"
 #include "chrome/browser/devtools/devtools_protocol.h"
-#include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/devtools/remote_debugging_server.h"
 #include "chrome/browser/profiles/profile.h"
@@ -602,17 +601,14 @@ DevToolsAndroidBridge::RemoteBrowser::GetParsedVersion() {
   return result;
 }
 
-DevToolsTargetImpl*
+scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::CreatePageTarget(scoped_refptr<RemotePage> page) {
   std::string local_id = BuildUniqueTargetId(page->browser_id_,
                                              page->dict_.get());
   std::string target_path = GetTargetPath(page->dict_.get());
   std::string type = GetStringProperty(page->dict_.get(), "type");
-  scoped_refptr<DevToolsAgentHost> host =
-      AgentHostDelegate::GetOrCreateAgentHost(this, page->browser_id_, local_id,
-                                              target_path, type,
-                                              page->dict_.get());
-  return new DevToolsTargetImpl(host);
+  return AgentHostDelegate::GetOrCreateAgentHost(
+      this, page->browser_id_, local_id, target_path, type, page->dict_.get());
 }
 
 void DevToolsAndroidBridge::SendJsonRequest(

chrome/browser/devtools/device/devtools_android_bridge.h

@@ -34,7 +34,6 @@ namespace content {
 class BrowserContext;
 }
 
-class DevToolsTargetImpl;
 class PortForwardingController;
 class Profile;
 class TCPDeviceProvider;
@@ -204,7 +203,8 @@ class DevToolsAndroidBridge : public KeyedService {
   bool HasDevToolsWindow(const std::string& agent_id);
 
   // Creates new target instance owned by caller.
-  DevToolsTargetImpl* CreatePageTarget(scoped_refptr<RemotePage> browser);
+  scoped_refptr<content::DevToolsAgentHost>
+  CreatePageTarget(scoped_refptr<RemotePage> browser);
 
   using RemotePageCallback = base::Callback<void(scoped_refptr<RemotePage>)>;
   void OpenRemotePage(scoped_refptr<RemoteBrowser> browser,

chrome/browser/devtools/devtools_target_impl.cc

-// Copyright 2013 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 "chrome/browser/devtools/devtools_target_impl.h"
-
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/devtools/devtools_window.h"
-#include "chrome/browser/extensions/extension_tab_util.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
-#include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
-#include "chrome/common/extensions/extension_constants.h"
-#include "components/guest_view/browser/guest_view_base.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/devtools_agent_host.h"
-#include "content/public/browser/favicon_status.h"
-#include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/web_contents.h"
-#include "extensions/browser/extension_host.h"
-#include "extensions/browser/extension_registry.h"
-#include "extensions/browser/process_manager.h"
-#include "extensions/common/constants.h"
-
-using content::BrowserThread;
-using content::DevToolsAgentHost;
-using content::WebContents;
-
-DevToolsTargetImpl::~DevToolsTargetImpl() {
-}
-
-DevToolsTargetImpl::DevToolsTargetImpl(
-    scoped_refptr<DevToolsAgentHost> agent_host)
-    : devtools_discovery::BasicTargetDescriptor(agent_host) {
-}
-
-// static
-std::vector<DevToolsTargetImpl*> DevToolsTargetImpl::EnumerateAll() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  std::vector<DevToolsTargetImpl*> result;
-  DevToolsAgentHost::List agents = DevToolsAgentHost::GetOrCreateAll();
-  for (DevToolsAgentHost::List::iterator it = agents.begin();
-       it != agents.end(); ++it) {
-    result.push_back(new DevToolsTargetImpl(*it));
-  }
-  return result;
-}

chrome/browser/devtools/devtools_target_impl.h

-// Copyright 2013 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.
-
-#ifndef CHROME_BROWSER_DEVTOOLS_DEVTOOLS_TARGET_IMPL_H_
-#define CHROME_BROWSER_DEVTOOLS_DEVTOOLS_TARGET_IMPL_H_
-
-#include <memory>
-#include <vector>
-
-#include "base/callback.h"
-#include "components/devtools_discovery/basic_target_descriptor.h"
-
-class Profile;
-
-namespace content {
-class DevToolsAgentHost;
-class WebContents;
-}
-
-class DevToolsTargetImpl : public devtools_discovery::BasicTargetDescriptor {
- public:
-  explicit DevToolsTargetImpl(
-      scoped_refptr<content::DevToolsAgentHost> agent_host);
-  ~DevToolsTargetImpl() override;
-
-  // Caller takes ownership of returned objects.
-  static std::vector<DevToolsTargetImpl*> EnumerateAll();
-};
-
-#endif  // CHROME_BROWSER_DEVTOOLS_DEVTOOLS_TARGET_IMPL_H_

chrome/browser/devtools/devtools_targets_ui.cc

@@ -16,10 +16,10 @@
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
-#include "chrome/browser/devtools/devtools_target_impl.h"
 #include "content/public/browser/browser_child_process_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
+#include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
@@ -31,6 +31,7 @@
 #include "net/base/escape.h"
 
 using content::BrowserThread;
+using content::DevToolsAgentHost;
 
 namespace {
 
@@ -173,7 +174,7 @@ private:
 
   void ScheduleUpdate();
   void UpdateTargets();
-  void SendTargets(const std::vector<DevToolsTargetImpl*>& targets);
+  void SendTargets(const DevToolsAgentHost::List& targets);
 
   content::NotificationRegistrar notification_registrar_;
   std::unique_ptr<CancelableTimer> timer_;
@@ -226,24 +227,22 @@ void LocalTargetsUIHandler::ScheduleUpdate() {
 }
 
 void LocalTargetsUIHandler::UpdateTargets() {
-  SendTargets(DevToolsTargetImpl::EnumerateAll());
+  SendTargets(DevToolsAgentHost::GetOrCreateAll());
 }
 
 void LocalTargetsUIHandler::SendTargets(
-    const std::vector<DevToolsTargetImpl*>& targets) {
+    const content::DevToolsAgentHost::List& targets) {
   base::ListValue list_value;
   std::map<std::string, base::DictionaryValue*> id_to_descriptor;
 
-  base::STLDeleteValues(&targets_);
-  for (DevToolsTargetImpl* target : targets) {
-    scoped_refptr<content::DevToolsAgentHost> host = target->GetAgentHost();
-    targets_[host->GetId()] = target;
-    id_to_descriptor[host->GetId()] = Serialize(*target);
+  targets_.clear();
+  for (scoped_refptr<DevToolsAgentHost> host : targets) {
+    targets_[host->GetId()] = host;
+    id_to_descriptor[host->GetId()] = Serialize(host);
   }
 
-  for (TargetMap::iterator it(targets_.begin()); it != targets_.end(); ++it) {
-    DevToolsTargetImpl* target = it->second;
-    scoped_refptr<content::DevToolsAgentHost> host = target->GetAgentHost();
+  for (auto& it : targets_) {
+    scoped_refptr<DevToolsAgentHost> host = it.second;
     base::DictionaryValue* descriptor = id_to_descriptor[host->GetId()];
     std::string parent_id = host->GetParentId();
     if (parent_id.empty() || id_to_descriptor.count(parent_id) == 0) {
@@ -273,7 +272,7 @@ class AdbTargetsUIHandler
 
   void Open(const std::string& browser_id, const std::string& url) override;
 
-  scoped_refptr<content::DevToolsAgentHost> GetBrowserAgentHost(
+  scoped_refptr<DevToolsAgentHost> GetBrowserAgentHost(
       const std::string& browser_id) override;
 
  private:
@@ -313,7 +312,7 @@ void AdbTargetsUIHandler::Open(const std::string& browser_id,
     android_bridge_->OpenRemotePage(it->second, url);
 }
 
-scoped_refptr<content::DevToolsAgentHost>
+scoped_refptr<DevToolsAgentHost>
 AdbTargetsUIHandler::GetBrowserAgentHost(
     const std::string& browser_id) {
   RemoteBrowsers::iterator it = remote_browsers_.find(browser_id);
@@ -326,7 +325,7 @@ AdbTargetsUIHandler::GetBrowserAgentHost(
 void AdbTargetsUIHandler::DeviceListChanged(
     const DevToolsAndroidBridge::RemoteDevices& devices) {
   remote_browsers_.clear();
-  base::STLDeleteValues(&targets_);
+  targets_.clear();
   if (!android_bridge_)
     return;
 
@@ -368,9 +367,9 @@ void AdbTargetsUIHandler::DeviceListChanged(
       remote_browsers_[browser_id] = browser;
             browser_data->Set(kAdbPagesList, page_list);
       for (const auto& page : browser->pages()) {
-        DevToolsTargetImpl* target = android_bridge_->CreatePageTarget(page);
-        scoped_refptr<content::DevToolsAgentHost> host = target->GetAgentHost();
-        base::DictionaryValue* target_data = Serialize(*target);
+        scoped_refptr<DevToolsAgentHost> host =
+            android_bridge_->CreatePageTarget(page);
+        base::DictionaryValue* target_data = Serialize(host);
         target_data->SetBoolean(
             kAdbAttachedForeignField,
             host->IsAttached() &&
@@ -381,7 +380,7 @@ void AdbTargetsUIHandler::DeviceListChanged(
         gfx::Size screen_size = device->screen_size();
         target_data->SetInteger(kAdbScreenWidthField, screen_size.width());
         target_data->SetInteger(kAdbScreenHeightField, screen_size.height());
-        targets_[host->GetId()] = target;
+        targets_[host->GetId()] = host;
         page_list->Append(target_data);
       }
       browser_list->Append(std::move(browser_data));
@@ -404,7 +403,6 @@ DevToolsTargetsUIHandler::DevToolsTargetsUIHandler(
 }
 
 DevToolsTargetsUIHandler::~DevToolsTargetsUIHandler() {
-  base::STLDeleteValues(&targets_);
 }
 
 // static
@@ -424,7 +422,7 @@ DevToolsTargetsUIHandler::CreateForAdb(
       new AdbTargetsUIHandler(callback, profile));
 }
 
-DevToolsTargetImpl* DevToolsTargetsUIHandler::GetTarget(
+scoped_refptr<DevToolsAgentHost> DevToolsTargetsUIHandler::GetTarget(
     const std::string& target_id) {
   TargetMap::iterator it = targets_.find(target_id);
   if (it != targets_.end())
@@ -436,15 +434,14 @@ void DevToolsTargetsUIHandler::Open(const std::string& browser_id,
                                     const std::string& url) {
 }
 
-scoped_refptr<content::DevToolsAgentHost>
+scoped_refptr<DevToolsAgentHost>
 DevToolsTargetsUIHandler::GetBrowserAgentHost(const std::string& browser_id) {
   return NULL;
 }
 
 base::DictionaryValue* DevToolsTargetsUIHandler::Serialize(
-    const DevToolsTargetImpl& target) {
+    scoped_refptr<DevToolsAgentHost> host) {
   base::DictionaryValue* target_data = new base::DictionaryValue();
-  scoped_refptr<content::DevToolsAgentHost> host = target.GetAgentHost();
   target_data->SetString(kTargetSourceField, source_id_);
   target_data->SetString(kTargetIdField, host->GetId());
   target_data->SetString(kTargetTypeField, host->GetType());

chrome/browser/devtools/devtools_targets_ui.h

@@ -18,7 +18,6 @@ class ListValue;
 class DictionaryValue;
 }
 
-class DevToolsTargetImpl;
 class Profile;
 
 class DevToolsTargetsUIHandler {
@@ -39,7 +38,8 @@ class DevToolsTargetsUIHandler {
       const Callback& callback,
       Profile* profile);
 
-  DevToolsTargetImpl* GetTarget(const std::string& target_id);
+  scoped_refptr<content::DevToolsAgentHost> GetTarget(
+      const std::string& target_id);
 
   virtual void Open(const std::string& browser_id, const std::string& url);
 
@@ -49,10 +49,12 @@ class DevToolsTargetsUIHandler {
   virtual void ForceUpdate();
 
  protected:
-  base::DictionaryValue* Serialize(const DevToolsTargetImpl& target);
+  base::DictionaryValue* Serialize(
+      scoped_refptr<content::DevToolsAgentHost> host);
   void SendSerializedTargets(const base::ListValue& list);
 
-  typedef std::map<std::string, DevToolsTargetImpl*> TargetMap;
+  using TargetMap =
+      std::map<std::string, scoped_refptr<content::DevToolsAgentHost>>;
   TargetMap targets_;
 
  private:

chrome/browser/devtools/devtools_ui_bindings.cc

@@ -23,7 +23,6 @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/devtools/devtools_file_watcher.h"
 #include "chrome/browser/devtools/devtools_protocol.h"
-#include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/devtools/global_confirm_info_bar.h"
 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
 #include "chrome/browser/infobars/infobar_service.h"
@@ -758,17 +757,18 @@ void DevToolsUIBindings::PerformActionOnRemotePage(const std::string& page_id,
                                                    const std::string& action) {
   if (!remote_targets_handler_)
     return;
-  DevToolsTargetImpl* target = remote_targets_handler_->GetTarget(page_id);
-  if (!target)
+  scoped_refptr<content::DevToolsAgentHost> host =
+      remote_targets_handler_->GetTarget(page_id);
+  if (!host)
     return;
   if (action == kRemotePageActionInspect)
-    target->GetAgentHost()->Inspect();
+    host->Inspect();
   if (action == kRemotePageActionReload)
-    target->GetAgentHost()->Reload();
+    host->Reload();
   if (action == kRemotePageActionActivate)
-    target->GetAgentHost()->Activate();
+    host->Activate();
   if (action == kRemotePageActionClose)
-    target->GetAgentHost()->Close();
+    host->Close();
 }
 
 void DevToolsUIBindings::OpenRemotePage(const std::string& browser_id,

chrome/browser/extensions/api/debugger/debugger_api.cc

@@ -27,7 +27,6 @@
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/devtools/chrome_devtools_manager_delegate.h"
-#include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/devtools/global_confirm_info_bar.h"
 #include "chrome/browser/extensions/api/debugger/debugger_api_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ -678,9 +677,8 @@ const char kTargetTabIdField[] = "tabId";
 const char kTargetExtensionIdField[] = "extensionId";
 const char kTargetTypeWorker[] = "worker";
 
-base::Value* SerializeTarget(const DevToolsTargetImpl& target) {
+base::Value* SerializeTarget(scoped_refptr<DevToolsAgentHost> host) {
   base::DictionaryValue* dictionary = new base::DictionaryValue();
-  scoped_refptr<DevToolsAgentHost> host = target.GetAgentHost();
   dictionary->SetString(kTargetIdField, host->GetId());
   dictionary->SetString(kTargetTitleField, host->GetTitle());
   dictionary->SetBoolean(kTargetAttachedField, host->IsAttached());
@@ -718,7 +716,7 @@ DebuggerGetTargetsFunction::~DebuggerGetTargetsFunction() {
 }
 
 bool DebuggerGetTargetsFunction::RunAsync() {
-  std::vector<DevToolsTargetImpl*> list = DevToolsTargetImpl::EnumerateAll();
+  content::DevToolsAgentHost::List list = DevToolsAgentHost::GetOrCreateAll();
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
@@ -727,11 +725,10 @@ bool DebuggerGetTargetsFunction::RunAsync() {
 }
 
 void DebuggerGetTargetsFunction::SendTargetList(
-    const std::vector<DevToolsTargetImpl*>& target_list) {
+    const content::DevToolsAgentHost::List& target_list) {
   std::unique_ptr<base::ListValue> result(new base::ListValue());
   for (size_t i = 0; i < target_list.size(); ++i)
-    result->Append(SerializeTarget(*target_list[i]));
-  base::STLDeleteContainerPointers(target_list.begin(), target_list.end());
+    result->Append(SerializeTarget(target_list[i]));
   SetResult(std::move(result));
   SendResponse(true);
 }

chrome/browser/extensions/api/debugger/debugger_api.h

@@ -13,19 +13,17 @@
 
 #include "chrome/browser/extensions/chrome_extension_function.h"
 #include "chrome/common/extensions/api/debugger.h"
+#include "content/public/browser/devtools_agent_host.h"
 
 using extensions::api::debugger::Debuggee;
 
 // Base debugger function.
 
-class DevToolsTargetImpl;
-
 namespace base {
 class DictionaryValue;
 }
 
 namespace content {
-class DevToolsAgentHost;
 class WebContents;
 }
 
@@ -104,7 +102,7 @@ class DebuggerGetTargetsFunction : public DebuggerFunction {
   bool RunAsync() override;
 
  private:
-  void SendTargetList(const std::vector<DevToolsTargetImpl*>& target_list);
+  void SendTargetList(const content::DevToolsAgentHost::List& target_list);
 };
 
 }  // namespace extensions

chrome/browser/ui/webui/inspect_ui.cc

@@ -6,7 +6,6 @@
 
 #include "base/macros.h"
 #include "base/stl_util.h"
-#include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/devtools/devtools_targets_ui.h"
 #include "chrome/browser/devtools/devtools_ui_bindings.h"
 #include "chrome/browser/profiles/profile.h"
@@ -505,9 +504,8 @@ DevToolsTargetsUIHandler* InspectUI::FindTargetHandler(
 scoped_refptr<content::DevToolsAgentHost> InspectUI::FindTarget(
     const std::string& source_id, const std::string& target_id) {
   TargetHandlerMap::iterator it = target_handlers_.find(source_id);
-  DevToolsTargetImpl* target = it != target_handlers_.end() ?
+  return it != target_handlers_.end() ?
       it->second->GetTarget(target_id) : nullptr;
-  return target ? target->GetAgentHost() : nullptr;
 }
 
 void InspectUI::PopulateTargets(const std::string& source,

chrome/browser/ui/webui/inspect_ui.h

@@ -28,7 +28,6 @@ class DevToolsAgentHost;
 
 class Browser;
 class DevToolsTargetsUIHandler;
-class DevToolsTargetImpl;
 class PortForwardingStatusSerializer;
 
 class InspectUI : public content::WebUIController,

chrome/chrome_debugger.gypi

@@ -97,8 +97,6 @@
             'browser/devtools/devtools_file_system_indexer.h',
             'browser/devtools/devtools_file_watcher.cc',
             'browser/devtools/devtools_file_watcher.h',
-            'browser/devtools/devtools_target_impl.cc',
-            'browser/devtools/devtools_target_impl.h',
             'browser/devtools/devtools_targets_ui.cc',
             'browser/devtools/devtools_targets_ui.h',
             'browser/devtools/devtools_toggle_action.cc',

components/devtools_discovery/BUILD.gn

@@ -4,11 +4,8 @@
 
 static_library("devtools_discovery") {
   sources = [
-    "basic_target_descriptor.cc",
-    "basic_target_descriptor.h",
     "devtools_discovery_manager.cc",
     "devtools_discovery_manager.h",
-    "devtools_target_descriptor.h",
   ]
 
   deps = [

components/devtools_discovery/basic_target_descriptor.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 "components/devtools_discovery/basic_target_descriptor.h"
-
-#include "content/public/browser/devtools_agent_host.h"
-#include "content/public/browser/favicon_status.h"
-#include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/web_contents.h"
-
-using content::DevToolsAgentHost;
-
-namespace devtools_discovery {
-
-BasicTargetDescriptor::BasicTargetDescriptor(
-    scoped_refptr<DevToolsAgentHost> agent_host)
-    : agent_host_(agent_host) {
-}
-
-BasicTargetDescriptor::~BasicTargetDescriptor() {
-}
-
-scoped_refptr<DevToolsAgentHost> BasicTargetDescriptor::GetAgentHost() const {
-  return agent_host_;
-}
-
-}  // namespace devtools_discovery

components/devtools_discovery/basic_target_descriptor.h

-// 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.
-
-#ifndef COMPONENTS_DEVTOOLS_DISCOVERY_BASIC_TARGET_DESCRIPTOR_H_
-#define COMPONENTS_DEVTOOLS_DISCOVERY_BASIC_TARGET_DESCRIPTOR_H_
-
-#include "components/devtools_discovery/devtools_target_descriptor.h"
-
-namespace devtools_discovery {
-
-class BasicTargetDescriptor : public DevToolsTargetDescriptor {
- public:
-  explicit BasicTargetDescriptor(
-      scoped_refptr<content::DevToolsAgentHost> agent_host);
-  ~BasicTargetDescriptor() override;
-
-  scoped_refptr<content::DevToolsAgentHost> GetAgentHost() const override;
-
- private:
-  scoped_refptr<content::DevToolsAgentHost> agent_host_;
-};
-
-}  // namespace devtools_discovery
-
-#endif  // COMPONENTS_DEVTOOLS_DISCOVERY_BASIC_TARGET_DESCRIPTOR_H_

components/devtools_discovery/devtools_discovery_manager.cc

@@ -5,8 +5,6 @@
 #include "components/devtools_discovery/devtools_discovery_manager.h"
 
 #include "base/stl_util.h"
-#include "components/devtools_discovery/basic_target_descriptor.h"
-#include "content/public/browser/devtools_agent_host.h"
 
 using content::DevToolsAgentHost;
 
@@ -28,16 +26,11 @@ void DevToolsDiscoveryManager::AddProvider(std::unique_ptr<Provider> provider) {
   providers_.push_back(provider.release());
 }
 
-DevToolsTargetDescriptor::List DevToolsDiscoveryManager::GetDescriptors() {
+content::DevToolsAgentHost::List DevToolsDiscoveryManager::GetDescriptors() {
   if (providers_.size())
     return GetDescriptorsFromProviders();
 
-  DevToolsAgentHost::List agent_hosts = DevToolsAgentHost::GetOrCreateAll();
-  DevToolsTargetDescriptor::List result;
-  result.reserve(agent_hosts.size());
-  for (const auto& agent_host : agent_hosts)
-    result.push_back(new BasicTargetDescriptor(agent_host));
-  return result;
+  return DevToolsAgentHost::GetOrCreateAll();
 }
 
 void DevToolsDiscoveryManager::SetCreateCallback(
@@ -45,18 +38,18 @@ void DevToolsDiscoveryManager::SetCreateCallback(
   create_callback_ = callback;
 }
 
-std::unique_ptr<DevToolsTargetDescriptor> DevToolsDiscoveryManager::CreateNew(
+scoped_refptr<content::DevToolsAgentHost> DevToolsDiscoveryManager::CreateNew(
     const GURL& url) {
   if (create_callback_.is_null())
     return nullptr;
   return create_callback_.Run(url);
 }
 
-DevToolsTargetDescriptor::List
+content::DevToolsAgentHost::List
 DevToolsDiscoveryManager::GetDescriptorsFromProviders() {
-  DevToolsTargetDescriptor::List result;
+  content::DevToolsAgentHost::List result;
   for (auto* provider : providers_) {
-    DevToolsTargetDescriptor::List partial = provider->GetDescriptors();
+    content::DevToolsAgentHost::List partial = provider->GetDescriptors();
     result.insert(result.begin(), partial.begin(), partial.end());
   }
   return result;
@@ -74,15 +67,14 @@ DevToolsDiscoveryManager::HandleCreateTargetCommand(
       method == "Browser.createTarget" &&
       command_dict->GetDictionary("params", &params_dict) &&
       params_dict->GetString("url", &url)) {
-    std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor> descriptor =
-        CreateNew(GURL(url));
-    if (!descriptor)
+    scoped_refptr<content::DevToolsAgentHost> host = CreateNew(GURL(url));
+    if (!host)
       return nullptr;
     std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
     result->SetInteger("id", id);
     std::unique_ptr<base::DictionaryValue> cmd_result(
         new base::DictionaryValue());
-    cmd_result->SetString("targetId", descriptor->GetAgentHost()->GetId());
+    cmd_result->SetString("targetId", host->GetId());
     result->Set("result", std::move(cmd_result));
     return result;
   }

components/devtools_discovery/devtools_discovery_manager.h

@@ -11,7 +11,7 @@
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/values.h"
-#include "components/devtools_discovery/devtools_target_descriptor.h"
+#include "content/public/browser/devtools_agent_host.h"
 
 namespace devtools_discovery {
 
@@ -21,13 +21,11 @@ class DevToolsDiscoveryManager {
    public:
     virtual ~Provider() {}
 
-    // Caller takes ownership of created descriptors.
-    virtual DevToolsTargetDescriptor::List GetDescriptors() = 0;
+    virtual content::DevToolsAgentHost::List GetDescriptors() = 0;
   };
 
-  using CreateCallback =
-      base::Callback<std::unique_ptr<DevToolsTargetDescriptor>(
-          const GURL& url)>;
+  using CreateCallback = base::Callback<
+      scoped_refptr<content::DevToolsAgentHost>(const GURL& url)>;
 
   // Returns single instance of this class. The instance is destroyed on the
   // browser main loop exit so this method MUST NOT be called after that point.
@@ -35,10 +33,9 @@ class DevToolsDiscoveryManager {
 
   void AddProvider(std::unique_ptr<Provider> provider);
   void SetCreateCallback(const CreateCallback& callback);
-
   // Caller takes ownership of created descriptors.
-  DevToolsTargetDescriptor::List GetDescriptors();
-  std::unique_ptr<DevToolsTargetDescriptor> CreateNew(const GURL& url);
+  content::DevToolsAgentHost::List GetDescriptors();
+  scoped_refptr<content::DevToolsAgentHost> CreateNew(const GURL& url);
 
   // Handles Browser.createTarget only.
   std::unique_ptr<base::DictionaryValue> HandleCreateTargetCommand(
@@ -49,7 +46,7 @@ class DevToolsDiscoveryManager {
 
   DevToolsDiscoveryManager();
   ~DevToolsDiscoveryManager();
-  DevToolsTargetDescriptor::List GetDescriptorsFromProviders();
+  content::DevToolsAgentHost::List GetDescriptorsFromProviders();
 
   std::vector<Provider*> providers_;
   CreateCallback create_callback_;

components/devtools_discovery/devtools_target_descriptor.h

-// 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.
-
-#ifndef COMPONENTS_DEVTOOLS_DISCOVERY_DEVTOOLS_TARGET_DESCRIPTOR_H_
-#define COMPONENTS_DEVTOOLS_DISCOVERY_DEVTOOLS_TARGET_DESCRIPTOR_H_
-
-#include <string>
-#include <vector>
-
-#include "base/memory/ref_counted.h"
-#include "base/time/time.h"
-#include "url/gurl.h"
-
-namespace content {
-class DevToolsAgentHost;
-}
-
-namespace devtools_discovery {
-
-// DevToolsTargetDescriptor provides information about devtools target
-// and can be used to manipulate the target and query its details.
-// Instantiation and discovery of DevToolsTargetDescriptor instances
-// is the responsibility of DevToolsDiscoveryManager.
-class DevToolsTargetDescriptor {
- public:
-  using List = std::vector<DevToolsTargetDescriptor*>;
-  virtual ~DevToolsTargetDescriptor() {}
-
-  // Returns the agent host for this target.
-  virtual scoped_refptr<content::DevToolsAgentHost> GetAgentHost() const = 0;
-};
-
-}  // namespace devtools_discovery
-
-#endif  // COMPONENTS_DEVTOOLS_DISCOVERY_DEVTOOLS_TARGET_DESCRIPTOR_H_

components/devtools_http_handler/devtools_http_handler.cc

@@ -26,7 +26,6 @@
 #include "components/devtools_http_handler/devtools_http_handler.h"
 #include "components/devtools_http_handler/devtools_http_handler_delegate.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/user_agent.h"
@@ -46,7 +45,6 @@
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostClient;
-using devtools_discovery::DevToolsTargetDescriptor;
 
 namespace devtools_http_handler {
 
@@ -322,10 +320,9 @@ class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
   scoped_refptr<DevToolsAgentHost> agent_host_;
 };
 
-static bool TimeComparator(const DevToolsTargetDescriptor* desc1,
-                           const DevToolsTargetDescriptor* desc2) {
-  return desc1->GetAgentHost()->GetLastActivityTime() >
-         desc2->GetAgentHost()->GetLastActivityTime();
+static bool TimeComparator(scoped_refptr<DevToolsAgentHost> host1,
+                           scoped_refptr<DevToolsAgentHost> host2) {
+  return host1->GetLastActivityTime() > host2->GetLastActivityTime();
 }
 
 // DevToolsHttpHandler::ServerSocketFactory ----------------------------------
@@ -345,8 +342,6 @@ DevToolsHttpHandler::ServerSocketFactory::CreateForTethering(
 
 DevToolsHttpHandler::~DevToolsHttpHandler() {
   TerminateOnUI(thread_, server_wrapper_, socket_factory_);
-  base::STLDeleteValues(&descriptor_map_);
-  base::STLDeleteValues(&connection_to_client_);
 }
 
 GURL DevToolsHttpHandler::GetFrontendURL(const std::string& path) {
@@ -579,15 +574,15 @@ void DevToolsHttpHandler::OnJsonRequest(
 
   if (command == "list") {
     std::string host = info.headers["host"];
-    DevToolsTargetDescriptor::List descriptors =
+    DevToolsAgentHost::List agent_hosts =
         devtools_discovery::DevToolsDiscoveryManager::GetInstance()->
             GetDescriptors();
-    std::sort(descriptors.begin(), descriptors.end(), TimeComparator);
-    base::STLDeleteValues(&descriptor_map_);
+    std::sort(agent_hosts.begin(), agent_hosts.end(), TimeComparator);
+    agent_host_map_.clear();
     base::ListValue list_value;
-    for (DevToolsTargetDescriptor* descriptor : descriptors) {
-      descriptor_map_[descriptor->GetAgentHost()->GetId()] = descriptor;
-      list_value.Append(SerializeDescriptor(*descriptor, host));
+    for (auto& agent_host : agent_hosts) {
+      agent_host_map_[agent_host->GetId()] = agent_host;
+      list_value.Append(SerializeDescriptor(agent_host, host));
     }
     SendJson(connection_id, net::HTTP_OK, &list_value, std::string());
     return;
@@ -599,10 +594,10 @@ void DevToolsHttpHandler::OnJsonRequest(
                    net::UnescapeRule::PATH_SEPARATORS));
     if (!url.is_valid())
       url = GURL(url::kAboutBlankURL);
-    std::unique_ptr<DevToolsTargetDescriptor> descriptor =
+    scoped_refptr<DevToolsAgentHost> agent_host =
         devtools_discovery::DevToolsDiscoveryManager::GetInstance()->CreateNew(
             url);
-    if (!descriptor) {
+    if (!agent_host) {
       SendJson(connection_id,
                net::HTTP_INTERNAL_SERVER_ERROR,
                NULL,
@@ -611,16 +606,16 @@ void DevToolsHttpHandler::OnJsonRequest(
     }
     std::string host = info.headers["host"];
     std::unique_ptr<base::DictionaryValue> dictionary(
-        SerializeDescriptor(*descriptor.get(), host));
+        SerializeDescriptor(agent_host, host));
     SendJson(connection_id, net::HTTP_OK, dictionary.get(), std::string());
-    const std::string target_id = descriptor->GetAgentHost()->GetId();
-    descriptor_map_[target_id] = descriptor.release();
+    const std::string target_id = agent_host->GetId();
+    agent_host_map_[target_id] = agent_host;
     return;
   }
 
   if (command == "activate" || command == "close") {
-    DevToolsTargetDescriptor* descriptor = GetDescriptor(target_id);
-    if (!descriptor) {
+    scoped_refptr<DevToolsAgentHost> agent_host = GetAgentHost(target_id);
+    if (!agent_host) {
       SendJson(connection_id,
                net::HTTP_NOT_FOUND,
                NULL,
@@ -629,7 +624,7 @@ void DevToolsHttpHandler::OnJsonRequest(
     }
 
     if (command == "activate") {
-      if (descriptor->GetAgentHost()->Activate()) {
+      if (agent_host->Activate()) {
         SendJson(connection_id, net::HTTP_OK, NULL, "Target activated");
       } else {
         SendJson(connection_id,
@@ -641,7 +636,7 @@ void DevToolsHttpHandler::OnJsonRequest(
     }
 
     if (command == "close") {
-      if (descriptor->GetAgentHost()->Close()) {
+      if (agent_host->Close()) {
         SendJson(connection_id, net::HTTP_OK, NULL, "Target is closing");
       } else {
         SendJson(connection_id,
@@ -659,20 +654,18 @@ void DevToolsHttpHandler::OnJsonRequest(
   return;
 }
 
-DevToolsTargetDescriptor* DevToolsHttpHandler::GetDescriptor(
+scoped_refptr<DevToolsAgentHost> DevToolsHttpHandler::GetAgentHost(
     const std::string& target_id) {
-  DescriptorMap::const_iterator it = descriptor_map_.find(target_id);
-  if (it == descriptor_map_.end())
-    return nullptr;
-  return it->second;
+  DescriptorMap::const_iterator it = agent_host_map_.find(target_id);
+  return it != agent_host_map_.end() ? it->second : nullptr;
 }
 
 void DevToolsHttpHandler::OnThumbnailRequest(
     int connection_id, const std::string& target_id) {
-  DevToolsTargetDescriptor* descriptor = GetDescriptor(target_id);
+  scoped_refptr<DevToolsAgentHost> agent_host = GetAgentHost(target_id);
   GURL page_url;
-  if (descriptor)
-    page_url = descriptor->GetAgentHost()->GetURL();
+  if (agent_host)
+    page_url = agent_host->GetURL();
   std::string data = delegate_->GetPageThumbnailData(page_url);
   if (!data.empty())
     Send200(connection_id, data, "image/png");
@@ -731,10 +724,8 @@ void DevToolsHttpHandler::OnWebSocketRequest(
   }
 
   std::string target_id = request.path.substr(strlen(kPageUrlPrefix));
-  DevToolsTargetDescriptor* descriptor = GetDescriptor(target_id);
-  scoped_refptr<DevToolsAgentHost> agent =
-      descriptor ? descriptor->GetAgentHost() : nullptr;
-  if (!agent.get()) {
+  scoped_refptr<DevToolsAgentHost> agent = GetAgentHost(target_id);
+  if (!agent) {
     Send500(connection_id, "No such target id: " + target_id);
     return;
   }
@@ -897,11 +888,9 @@ void DevToolsHttpHandler::AcceptWebSocket(
 }
 
 base::DictionaryValue* DevToolsHttpHandler::SerializeDescriptor(
-    const DevToolsTargetDescriptor& descriptor,
+    scoped_refptr<DevToolsAgentHost> agent_host,
     const std::string& host) {
   base::DictionaryValue* dictionary = new base::DictionaryValue;
-  scoped_refptr<content::DevToolsAgentHost> agent_host =
-      descriptor.GetAgentHost();
   std::string id = agent_host->GetId();
   dictionary->SetString(kTargetIdField, id);
   std::string parent_id = agent_host->GetParentId();

components/devtools_http_handler/devtools_http_handler.h

@@ -12,7 +12,7 @@
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "components/devtools_discovery/devtools_target_descriptor.h"
+#include "content/public/browser/devtools_agent_host.h"
 #include "net/http/http_status_code.h"
 
 class GURL;
@@ -103,7 +103,7 @@ class DevToolsHttpHandler {
                      ServerSocketFactory* socket_factory,
                      std::unique_ptr<net::IPEndPoint> ip_address);
 
-  devtools_discovery::DevToolsTargetDescriptor* GetDescriptor(
+  scoped_refptr<content::DevToolsAgentHost> GetAgentHost(
       const std::string& target_id);
 
   void SendJson(int connection_id,
@@ -124,7 +124,7 @@ class DevToolsHttpHandler {
                                      const std::string& host);
 
   base::DictionaryValue* SerializeDescriptor(
-      const devtools_discovery::DevToolsTargetDescriptor& descriptor,
+      scoped_refptr<content::DevToolsAgentHost> agent_host,
       const std::string& host);
 
   // The thread used by the devtools handler to run server socket.
@@ -139,8 +139,8 @@ class DevToolsHttpHandler {
   const std::unique_ptr<DevToolsHttpHandlerDelegate> delegate_;
   ServerSocketFactory* socket_factory_;
   using DescriptorMap =
-      std::map<std::string, devtools_discovery::DevToolsTargetDescriptor*>;
-  DescriptorMap descriptor_map_;
+      std::map<std::string, scoped_refptr<content::DevToolsAgentHost>>;
+  DescriptorMap agent_host_map_;
   base::WeakPtrFactory<DevToolsHttpHandler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsHttpHandler);

content/shell/browser/shell_devtools_manager_delegate.cc

@@ -17,7 +17,6 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
-#include "components/devtools_discovery/basic_target_descriptor.h"
 #include "components/devtools_discovery/devtools_discovery_manager.h"
 #include "components/devtools_http_handler/devtools_http_handler.h"
 #include "content/public/browser/browser_context.h"
@@ -135,14 +134,13 @@ CreateSocketFactory() {
 #endif
 }
 
-std::unique_ptr<devtools_discovery::DevToolsTargetDescriptor>
+scoped_refptr<content::DevToolsAgentHost>
 CreateNewShellTarget(BrowserContext* browser_context, const GURL& url) {
   Shell* shell = Shell::CreateNewWindow(browser_context,
                                         url,
                                         nullptr,
                                         gfx::Size());
-  return base::WrapUnique(new devtools_discovery::BasicTargetDescriptor(
-      DevToolsAgentHost::GetOrCreateFor(shell->web_contents())));
+  return DevToolsAgentHost::GetOrCreateFor(shell->web_contents());
 }
 
 // ShellDevToolsDelegate ----------------------------------------------------