[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 281 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<AndroidDeviceManager::Device> device_;
+  AndroidDeviceManager::Device* device_;
   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,
     scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
     const ForwardingMap& forwarding_map)
     : registry_(registry),
-      device_(device),
+      device_(device.get()),

[dgozman, 2014/10/21 11:54:02]

I think you either need |device_| or |browser_|, but not both.

[vkuzkokov, 2014/10/21 13:00:54]

We store browser_ so that we could display on chrome://inspect which one is
used. device_ is needed to open forwarding sockets.

       browser_(browser),
       command_id_(0),
       connected_(false),
       forwarding_map_(forwarding_map),
       weak_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  (*registry_)[device_->serial()] = this;
+  (*registry_)[browser->serial()] = this;
   web_socket_.reset(
       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(registry_->find(browser_->serial()) != registry_->end());
+  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 239 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_);
 }