DevTools: RemoteDevice and RemoteBrowser are now value types

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 "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 274 matching lines @@
                     const DevToolsTargetsUIHandler::TargetCallback&) OVERRIDE;
 
   virtual scoped_refptr<content::DevToolsAgentHost> GetBrowserAgentHost(
       const std::string& browser_id) OVERRIDE;
 
  private:
   // DevToolsAndroidBridge::Listener overrides.
   virtual void DeviceListChanged(
       const DevToolsAndroidBridge::RemoteDevices& devices) OVERRIDE;
 
+  DevToolsAndroidBridge* GetAndroidBridge();
+
   Profile* profile_;
 
   typedef std::map<std::string,
       scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> > RemoteBrowsers;
   RemoteBrowsers remote_browsers_;
 };
 
 AdbTargetsUIHandler::AdbTargetsUIHandler(const Callback& callback,
                                          Profile* profile)
     : DevToolsTargetsUIHandler(kTargetSourceRemote, callback),
       profile_(profile) {
-  DevToolsAndroidBridge* android_bridge =
-      DevToolsAndroidBridge::Factory::GetForProfile(profile_);
+  DevToolsAndroidBridge* android_bridge = GetAndroidBridge();
   if (android_bridge)
     android_bridge->AddDeviceListListener(this);
 }
 
 AdbTargetsUIHandler::~AdbTargetsUIHandler() {
-  DevToolsAndroidBridge* android_bridge =
-      DevToolsAndroidBridge::Factory::GetForProfile(profile_);
+  DevToolsAndroidBridge* android_bridge = GetAndroidBridge();
   if (android_bridge)
     android_bridge->RemoveDeviceListListener(this);
 }
 
 static void CallOnTarget(
     const DevToolsTargetsUIHandler::TargetCallback& callback,
     DevToolsAndroidBridge::RemotePage* page) {
   scoped_ptr<DevToolsAndroidBridge::RemotePage> my_page(page);
   callback.Run(my_page ? my_page->GetTarget() : NULL);
 }
 
 void AdbTargetsUIHandler::Open(
     const std::string& browser_id,
     const std::string& url,
     const DevToolsTargetsUIHandler::TargetCallback& callback) {
   RemoteBrowsers::iterator it = remote_browsers_.find(browser_id);
-  if (it !=  remote_browsers_.end())
-    it->second->Open(url, base::Bind(&CallOnTarget, callback));
+  if (it == remote_browsers_.end())
+    return;
+
+  DevToolsAndroidBridge* android_bridge = GetAndroidBridge();
+  if (android_bridge)
+    android_bridge->Open(it->second, url, base::Bind(&CallOnTarget, callback));
 }
 
 scoped_refptr<content::DevToolsAgentHost>
 AdbTargetsUIHandler::GetBrowserAgentHost(
     const std::string& browser_id) {
   RemoteBrowsers::iterator it = remote_browsers_.find(browser_id);
-  return it != remote_browsers_.end() ? it->second->GetAgentHost() : NULL;
+  if (it == remote_browsers_.end())
+    return NULL;
+
+  DevToolsAndroidBridge* android_bridge = GetAndroidBridge();
+  return android_bridge ? android_bridge->GetBrowserAgentHost(it->second)
+                        : NULL;
 }
 
 void AdbTargetsUIHandler::DeviceListChanged(
     const DevToolsAndroidBridge::RemoteDevices& devices) {
   remote_browsers_.clear();
   STLDeleteValues(&targets_);
 
+  DevToolsAndroidBridge* android_bridge = GetAndroidBridge();
   base::ListValue device_list;
   for (DevToolsAndroidBridge::RemoteDevices::const_iterator dit =
       devices.begin(); dit != devices.end(); ++dit) {
     DevToolsAndroidBridge::RemoteDevice* device = dit->get();
     base::DictionaryValue* device_data = new base::DictionaryValue();
     device_data->SetString(kAdbModelField, device->model());
     device_data->SetString(kAdbSerialField, device->serial());
     device_data->SetBoolean(kAdbConnectedField, device->is_connected());
     std::string device_id = base::StringPrintf(
         kAdbDeviceIdFormat,
@@ skipping 25 matching lines @@
       base::Version local_version(version_info.Version());
 
       browser_data->SetBoolean(kCompatibleVersion,
           (!remote_version.IsValid()) || (!local_version.IsValid()) ||
           remote_version.components()[0] <= local_version.components()[0]);
 
       base::ListValue* page_list = new base::ListValue();
       remote_browsers_[browser_id] = browser;
             browser_data->Set(kAdbPagesList, page_list);
       std::vector<DevToolsAndroidBridge::RemotePage*> pages =
-          browser->CreatePages();
+          android_bridge->CreatePages(browser);
       for (std::vector<DevToolsAndroidBridge::RemotePage*>::iterator it =
           pages.begin(); it != pages.end(); ++it) {
         DevToolsAndroidBridge::RemotePage* page =  *it;
         DevToolsTargetImpl* target = page->GetTarget();
         base::DictionaryValue* target_data = Serialize(*target);
         target_data->SetBoolean(
             kAdbAttachedForeignField,
             target->IsAttached() &&
-                !DevToolsAndroidBridge::HasDevToolsWindow(target->GetId()));
+                !android_bridge->HasDevToolsWindow(target->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_[target->GetId()] = target;
         page_list->Append(target_data);
       }
       browser_list->Append(browser_data);
     }
 
     device_list.Append(device_data);
   }
   SendSerializedTargets(device_list);
 }
 
+DevToolsAndroidBridge* AdbTargetsUIHandler::GetAndroidBridge() {
+  return DevToolsAndroidBridge::Factory::GetForProfile(profile_);

[dgozman, 2014/10/02 12:19:34]

Why don't you just get it once and save to |android_bridge_|?

[vkuzkokov, 2014/10/02 13:07:46]

Done.

+}
+
 } // namespace
 
 // DevToolsTargetsUIHandler ---------------------------------------------------
 
 DevToolsTargetsUIHandler::DevToolsTargetsUIHandler(
     const std::string& source_id,
     const Callback& callback)
     : source_id_(source_id),
       callback_(callback) {
 }
@@ skipping 96 matching lines @@
     device_status_dict->SetString(kPortForwardingBrowserId,
                                   SerializeBrowserId(sit->first));
 
     std::string device_id = base::StringPrintf(
         kAdbDeviceIdFormat,
         sit->first->serial().c_str());
     result.Set(device_id, device_status_dict);
   }
   callback_.Run(result);
 }