DevTools: RemoteDevice and RemoteBrowser are now value types

chrome/browser/devtools/device/port_forwarding_controller.cc

 // Copyright 2014 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/device/port_forwarding_controller.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 234 matching lines @@
       best_browser = browser;
       newest_version = current_version;
     }
   }
   return best_browser;
 }
 
 }  // namespace
 
 class PortForwardingController::Connection
-    : public DevToolsAndroidBridge::AndroidWebSocket::Delegate {
+    : public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
   Connection(Registry* registry,
-             scoped_refptr<DevToolsAndroidBridge::RemoteDevice> device,
-             scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+             scoped_refptr<AndroidDeviceManager::Device> device,
+             const std::string& socket,
              const ForwardingMap& forwarding_map);
   virtual ~Connection();
 
   const PortStatusMap& GetPortStatusMap();
 
   void UpdateForwardingMap(const ForwardingMap& new_forwarding_map);
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
@@ skipping 18 matching lines @@
   static void UpdateSocketCountOnHandlerThread(
       base::WeakPtr<Connection> weak_connection, int port, int increment);
   void UpdateSocketCount(int port, int increment);
 
   // DevToolsAndroidBridge::AndroidWebSocket::Delegate implementation:
   virtual void OnSocketOpened() OVERRIDE;
   virtual void OnFrameRead(const std::string& message) OVERRIDE;
   virtual void OnSocketClosed() OVERRIDE;
 
   PortForwardingController::Registry* registry_;
-  scoped_refptr<DevToolsAndroidBridge::RemoteDevice> device_;
-  scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser_;
-  scoped_ptr<DevToolsAndroidBridge::AndroidWebSocket> web_socket_;
+  scoped_refptr<AndroidDeviceManager::Device> device_;
+  scoped_ptr<AndroidDeviceManager::AndroidWebSocket> web_socket_;
   int command_id_;
   bool connected_;
   ForwardingMap forwarding_map_;
   CommandCallbackMap pending_responses_;
   PortStatusMap port_status_;
   base::WeakPtrFactory<Connection> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
 PortForwardingController::Connection::Connection(
     Registry* registry,
-    scoped_refptr<DevToolsAndroidBridge::RemoteDevice> device,
-    scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
+    scoped_refptr<AndroidDeviceManager::Device> device,
+    const std::string& socket,
     const ForwardingMap& forwarding_map)
     : registry_(registry),
       device_(device),
-      browser_(browser),
       command_id_(0),
       connected_(false),
       forwarding_map_(forwarding_map),
       weak_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   (*registry_)[device_->serial()] = this;
   web_socket_.reset(
-      browser->CreateWebSocket(kDevToolsRemoteBrowserTarget, this));
+      device_->CreateWebSocket(socket, kDevToolsRemoteBrowserTarget, this));
 }
 
 PortForwardingController::Connection::~Connection() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(registry_->find(device_->serial()) != registry_->end());
   registry_->erase(device_->serial());
 }
 
 void PortForwardingController::Connection::UpdateForwardingMap(
     const ForwardingMap& new_forwarding_map) {
@@ skipping 188 matching lines @@
       &PortForwardingController::OnPrefsChange, base::Unretained(this));
   pref_change_registrar_.Add(prefs::kDevToolsPortForwardingEnabled, callback);
   pref_change_registrar_.Add(prefs::kDevToolsPortForwardingConfig, callback);
   OnPrefsChange();
 }
 
 PortForwardingController::~PortForwardingController() {}
 
 PortForwardingController::DevicesStatus
 PortForwardingController::DeviceListChanged(
-    const DevToolsAndroidBridge::RemoteDevices& devices) {
+    const DevToolsAndroidBridge::DeviceMap& device_map,
+    const DevToolsAndroidBridge::RemoteDevices& remote_devices) {
   DevicesStatus status;
   if (forwarding_map_.empty())
     return status;
 
   for (DevToolsAndroidBridge::RemoteDevices::const_iterator it =
-      devices.begin(); it != devices.end(); ++it) {
-    scoped_refptr<DevToolsAndroidBridge::RemoteDevice> device = *it;
-    if (!device->is_connected())
+      remote_devices.begin(); it != remote_devices.end(); ++it) {
+    scoped_refptr<DevToolsAndroidBridge::RemoteDevice> remote_device = *it;
+    if (!remote_device->is_connected())
       continue;
-    Registry::iterator rit = registry_.find(device->serial());
+    Registry::iterator rit = registry_.find(remote_device->serial());
     if (rit == registry_.end()) {
       scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser =
-          FindBestBrowserForTethering(device->browsers());
+          FindBestBrowserForTethering(remote_device->browsers());
       if (browser.get()) {
-        new Connection(&registry_, device, browser, forwarding_map_);
+        DevToolsAndroidBridge::DeviceMap::const_iterator it =
+            device_map.find(remote_device->serial());
+        DCHECK(it != device_map.end());
+        new Connection(&registry_, it->second, browser->socket(),
+                       forwarding_map_);
       }
     } else {
-      status[device->serial()] = (*rit).second->GetPortStatusMap();
+      status[remote_device->serial()] = (*rit).second->GetPortStatusMap();
     }
   }
 
   return status;
 }
 
 void PortForwardingController::OnPrefsChange() {
   forwarding_map_.clear();
 
   if (pref_service_->GetBoolean(prefs::kDevToolsPortForwardingEnabled)) {
@@ skipping 18 matching lines @@
       registry_copy.push_back(it->second);
     }
     STLDeleteElements(&registry_copy);
   }
 }
 
 void PortForwardingController::UpdateConnections() {
   for (Registry::iterator it = registry_.begin(); it != registry_.end(); ++it)
     it->second->UpdateForwardingMap(forwarding_map_);
 }