DevTools: remove DevToolsTargetDescriptor and its implementations, we are now based on devtools age…

chrome/browser/devtools/devtools_targets_ui.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_targets_ui.h"
 
 #include <utility>
 
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #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"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/worker_service.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/process_type.h"
 #include "net/base/escape.h"
 
 using content::BrowserThread;
+using content::DevToolsAgentHost;
 
 namespace {
 
 const char kTargetSourceField[]  = "source";
 const char kTargetSourceLocal[]  = "local";
 const char kTargetSourceRemote[]  = "remote";
 
 const char kTargetIdField[]  = "id";
 const char kTargetTypeField[]  = "type";
 const char kAttachedField[]  = "attached";
@@ skipping 122 matching lines @@
   void ForceUpdate() override;
 
 private:
   // content::NotificationObserver overrides.
  void Observe(int type,
               const content::NotificationSource& source,
               const content::NotificationDetails& details) override;
 
   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_;
   scoped_refptr<WorkerObserver> observer_;
   base::WeakPtrFactory<LocalTargetsUIHandler> weak_factory_;
 };
 
 LocalTargetsUIHandler::LocalTargetsUIHandler(
     const Callback& callback)
     : DevToolsTargetsUIHandler(kTargetSourceLocal, callback),
@@ skipping 32 matching lines @@
 void LocalTargetsUIHandler::ScheduleUpdate() {
   const int kUpdateDelay = 100;
   timer_.reset(
       new CancelableTimer(
           base::Bind(&LocalTargetsUIHandler::UpdateTargets,
                      base::Unretained(this)),
           base::TimeDelta::FromMilliseconds(kUpdateDelay)));
 }
 
 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) {
       list_value.Append(descriptor);
     } else {
       base::DictionaryValue* parent = id_to_descriptor[parent_id];
       base::ListValue* guests = NULL;
       if (!parent->GetList(kGuestList, &guests)) {
         guests = new base::ListValue();
         parent->Set(kGuestList, guests);
       }
       guests->Append(descriptor);
     }
   }
 
   SendSerializedTargets(list_value);
 }
 
 // AdbTargetsUIHandler --------------------------------------------------------
 
 class AdbTargetsUIHandler
     : public DevToolsTargetsUIHandler,
       public DevToolsAndroidBridge::DeviceListListener {
  public:
   AdbTargetsUIHandler(const Callback& callback, Profile* profile);
   ~AdbTargetsUIHandler() override;
 
   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:
   // DevToolsAndroidBridge::Listener overrides.
   void DeviceListChanged(
       const DevToolsAndroidBridge::RemoteDevices& devices) override;
 
   DevToolsAndroidBridge* GetAndroidBridge();
 
   Profile* const profile_;
@@ skipping 19 matching lines @@
     android_bridge_->RemoveDeviceListListener(this);
 }
 
 void AdbTargetsUIHandler::Open(const std::string& browser_id,
                                const std::string& url) {
   RemoteBrowsers::iterator it = remote_browsers_.find(browser_id);
   if (it != remote_browsers_.end() && android_bridge_)
     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);
   if (it == remote_browsers_.end() || !android_bridge_)
     return nullptr;
 
   return android_bridge_->GetBrowserAgentHost(it->second);
 }
 
 void AdbTargetsUIHandler::DeviceListChanged(
     const DevToolsAndroidBridge::RemoteDevices& devices) {
   remote_browsers_.clear();
-  base::STLDeleteValues(&targets_);
+  targets_.clear();
   if (!android_bridge_)
     return;
 
   base::ListValue device_list;
   for (DevToolsAndroidBridge::RemoteDevices::const_iterator dit =
       devices.begin(); dit != devices.end(); ++dit) {
     DevToolsAndroidBridge::RemoteDevice* device = dit->get();
     std::unique_ptr<base::DictionaryValue> device_data(
         new base::DictionaryValue());
     device_data->SetString(kAdbModelField, device->model());
@@ skipping 21 matching lines @@
           kAdbBrowserChromeVersionField,
           browser->IsChrome() && !parsed.empty() ? parsed[0] : 0);
       std::string browser_id = browser->GetId();
       browser_data->SetString(kTargetIdField, browser_id);
       browser_data->SetString(kTargetSourceField, source_id());
 
       base::ListValue* page_list = new base::ListValue();
       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() &&
                 !android_bridge_->HasDevToolsWindow(host->GetId()));
         // Pass the screen size in the target object to make sure that
         // the caching logic does not prevent the target item from updating
         // when the screen size changes.
         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));
     }
 
     device_list.Append(std::move(device_data));
   }
   SendSerializedTargets(device_list);
 }
 
 } // namespace
 
 // DevToolsTargetsUIHandler ---------------------------------------------------
 
 DevToolsTargetsUIHandler::DevToolsTargetsUIHandler(
     const std::string& source_id,
     const Callback& callback)
     : source_id_(source_id),
       callback_(callback) {
 }
 
 DevToolsTargetsUIHandler::~DevToolsTargetsUIHandler() {
-  base::STLDeleteValues(&targets_);
 }
 
 // static
 std::unique_ptr<DevToolsTargetsUIHandler>
 DevToolsTargetsUIHandler::CreateForLocal(
     const DevToolsTargetsUIHandler::Callback& callback) {
   return std::unique_ptr<DevToolsTargetsUIHandler>(
       new LocalTargetsUIHandler(callback));
 }
 
 // static
 std::unique_ptr<DevToolsTargetsUIHandler>
 DevToolsTargetsUIHandler::CreateForAdb(
     const DevToolsTargetsUIHandler::Callback& callback,
     Profile* profile) {
   return std::unique_ptr<DevToolsTargetsUIHandler>(
       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())
     return it->second;
   return NULL;
 }
 
 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());
   target_data->SetBoolean(kAttachedField, host->IsAttached());
   target_data->SetString(kUrlField, host->GetURL().spec());
   target_data->SetString(kNameField, host->GetTitle());
   target_data->SetString(kFaviconUrlField, host->GetFaviconURL().spec());
   target_data->SetString(kDescriptionField, host->GetDescription());
   return target_data;
 }
@@ skipping 42 matching lines @@
     device_status_dict->SetString(kPortForwardingBrowserId,
                                   sit->first->GetId());
 
     std::string device_id = base::StringPrintf(
         kAdbDeviceIdFormat,
         sit->first->serial().c_str());
     result.Set(device_id, device_status_dict);
   }
   callback_.Run(result);
 }