[DevTools] Port forwarding doesn't keep USB connection

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 236 matching lines @@
     }
   }
   return best_browser;
 }
 
 }  // namespace
 
 class PortForwardingController::Connection
     : public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
-  Connection(Registry* registry,
-             scoped_refptr<AndroidDeviceManager::Device> device,
+  Connection(PortForwardingController* controller,
              scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
              const ForwardingMap& forwarding_map);
   ~Connection() override;
 
   const PortStatusMap& GetPortStatusMap();
 
   void UpdateForwardingMap(const ForwardingMap& new_forwarding_map);
 
   scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser() {
     return browser_;
   }
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<Connection>;
 
-
   typedef std::map<int, std::string> ForwardingMap;
-
   typedef base::Callback<void(PortStatus)> CommandCallback;
   typedef std::map<int, CommandCallback> CommandCallbackMap;
 
   void SerializeChanges(const std::string& method,
                         const ForwardingMap& old_map,
                         const ForwardingMap& new_map);
 
   void SendCommand(const std::string& method, int port);
   bool ProcessResponse(const std::string& json);
 
   void ProcessBindResponse(int port, PortStatus status);
   void ProcessUnbindResponse(int port, PortStatus status);
 
   static void UpdateSocketCountOnHandlerThread(
       base::WeakPtr<Connection> weak_connection, int port, int increment);
   void UpdateSocketCount(int port, int increment);
 
   // DevToolsAndroidBridge::AndroidWebSocket::Delegate implementation:
   void OnSocketOpened() override;
   void OnFrameRead(const std::string& message) override;
   void OnSocketClosed() override;
 
-  PortForwardingController::Registry* registry_;
-  scoped_refptr<AndroidDeviceManager::Device> device_;
+  PortForwardingController* controller_;
   scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser_;
   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<AndroidDeviceManager::Device> device,
+    PortForwardingController* controller,
     scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
     const ForwardingMap& forwarding_map)
-    : registry_(registry),
-      device_(device),
+    : controller_(controller),
       browser_(browser),
       command_id_(0),
       connected_(false),
       forwarding_map_(forwarding_map),
       weak_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  (*registry_)[device_->serial()] = this;
+  controller_->registry_[browser->serial()] = this;
+  scoped_refptr<AndroidDeviceManager::Device> device(
+      controller_->bridge_->FindDevice(browser->serial()));
+  DCHECK(device.get());
   web_socket_.reset(
-      device_->CreateWebSocket(browser->socket(),
-                               kDevToolsRemoteBrowserTarget, this));
+      device->CreateWebSocket(browser->socket(),
+                              kDevToolsRemoteBrowserTarget, this));
 }
 
 PortForwardingController::Connection::~Connection() {
-
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(registry_->find(device_->serial()) != registry_->end());
-  registry_->erase(device_->serial());
+  DCHECK(controller_->registry_.find(browser_->serial()) !=
+         controller_->registry_.end());
+  controller_->registry_.erase(browser_->serial());
 }
 
 void PortForwardingController::Connection::UpdateForwardingMap(
     const ForwardingMap& new_forwarding_map) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (connected_) {
     SerializeChanges(tethering::unbind::kName,
         new_forwarding_map, forwarding_map_);
     SerializeChanges(tethering::bind::kName,
         forwarding_map_, new_forwarding_map);
@@ skipping 159 matching lines @@
   Tokenize(location, ":", &tokens);
   int destination_port = 0;
   if (tokens.size() != 2 || !base::StringToInt(tokens[1], &destination_port))
     return;
   std::string destination_host = tokens[0];
 
   SocketTunnel::CounterCallback callback =
       base::Bind(&Connection::UpdateSocketCountOnHandlerThread,
                  weak_factory_.GetWeakPtr(), port);
 
-  device_->OpenSocket(
+  scoped_refptr<AndroidDeviceManager::Device> device(
+      controller_->bridge_->FindDevice(browser_->serial()));
+  DCHECK(device.get());
+  device->OpenSocket(
       connection_id.c_str(),
       base::Bind(&SocketTunnel::StartTunnel,
                  destination_host,
                  destination_port,
                  callback));
 }
 
-PortForwardingController::PortForwardingController(Profile* profile)
+PortForwardingController::PortForwardingController(
+    Profile* profile,
+    DevToolsAndroidBridge* bridge)
     : profile_(profile),
+      bridge_(bridge),
       pref_service_(profile->GetPrefs()) {
   pref_change_registrar_.Init(pref_service_);
   base::Closure callback = base::Bind(
       &PortForwardingController::OnPrefsChange, base::Unretained(this));
   pref_change_registrar_.Add(prefs::kDevToolsPortForwardingEnabled, callback);
   pref_change_registrar_.Add(prefs::kDevToolsPortForwardingConfig, callback);
   OnPrefsChange();
 }
 
 PortForwardingController::~PortForwardingController() {}
 
 PortForwardingController::ForwardingStatus
 PortForwardingController::DeviceListChanged(
-    const DevToolsAndroidBridge::CompleteDevices& complete_devices) {
+    const DevToolsAndroidBridge::RemoteDevices& devices) {
   ForwardingStatus status;
   if (forwarding_map_.empty())
     return status;
 
-  for (const auto& pair : complete_devices) {
-    scoped_refptr<AndroidDeviceManager::Device> device(pair.first);
-    scoped_refptr<DevToolsAndroidBridge::RemoteDevice> remote_device(
-        pair.second);
-    if (!remote_device->is_connected())
+  for (const auto& device : devices) {
+    if (!device->is_connected())
       continue;
-    Registry::iterator rit = registry_.find(remote_device->serial());
+    Registry::iterator rit = registry_.find(device->serial());
     if (rit == registry_.end()) {
       scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser(
-          FindBestBrowserForTethering(remote_device->browsers()));
+          FindBestBrowserForTethering(device->browsers()));
       if (browser.get())
-        new Connection(&registry_, device, browser, forwarding_map_);
+        new Connection(this, browser, forwarding_map_);
     } else {
       status.push_back(std::make_pair(rit->second->browser(),
                                       rit->second->GetPortStatusMap()));
     }
   }
   return status;
 }
 
 void PortForwardingController::OnPrefsChange() {
   forwarding_map_.clear();
@@ skipping 20 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_);
 }