[DevTools] Port forwarding doesn't keep USB connection

chrome/browser/devtools/device/android_device_manager.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/android_device_manager.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
@@ skipping 308 matching lines @@
 }
 
 AndroidDeviceManager::DeviceProvider::DeviceProvider() {
 }
 
 AndroidDeviceManager::DeviceProvider::~DeviceProvider() {
 }
 
 void AndroidDeviceManager::Device::QueryDeviceInfo(
     const DeviceInfoCallback& callback) {
-  device_message_loop_->PostTask(
+  message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&DeviceProvider::QueryDeviceInfo,
                  provider_,
                  serial_,
                  base::Bind(&PostDeviceInfoCallback,
                             base::MessageLoopProxy::current(),
                             callback)));
 }
 
 void AndroidDeviceManager::Device::OpenSocket(const std::string& socket_name,
                                               const SocketCallback& callback) {
-  device_message_loop_->PostTask(
+  message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&DeviceProvider::OpenSocket,
                  provider_,
                  serial_,
                  socket_name,
                  callback));
 }
 
 void AndroidDeviceManager::Device::SendJsonRequest(
     const std::string& socket_name,
     const std::string& request,
     const CommandCallback& callback) {
-  device_message_loop_->PostTask(
+  message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&DeviceProvider::SendJsonRequest,
                  provider_,
                  serial_,
                  socket_name,
                  request,
                  base::Bind(&PostCommandCallback,
                             base::MessageLoopProxy::current(),
                             callback)));
 }
 
 void AndroidDeviceManager::Device::HttpUpgrade(const std::string& socket_name,
                                                const std::string& url,
                                                const SocketCallback& callback) {
-  device_message_loop_->PostTask(
+  message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&DeviceProvider::HttpUpgrade,
                  provider_,
                  serial_,
                  socket_name,
                  url,
                  base::Bind(&PostSocketCallback,
                             base::MessageLoopProxy::current(),
                             callback)));
 }
 
 AndroidDeviceManager::Device::Device(
     scoped_refptr<base::MessageLoopProxy> device_message_loop,
     scoped_refptr<DeviceProvider> provider,
     const std::string& serial)
-    : device_message_loop_(device_message_loop),
+    : message_loop_proxy_(device_message_loop),
       provider_(provider),
       serial_(serial),
       weak_factory_(this) {
 }
 
 AndroidDeviceManager::Device::~Device() {
+  std::set<AndroidWebSocket*> sockets_copy(sockets_);
+  for (AndroidWebSocket* socket : sockets_copy)
+    socket->OnSocketClosed();
+
   provider_->AddRef();
   DeviceProvider* raw_ptr = provider_.get();
   provider_ = NULL;
-  device_message_loop_->PostTask(
+  message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&ReleaseDeviceAndProvider,
                  base::Unretained(raw_ptr),
                  serial_));
 }
 
 AndroidDeviceManager::HandlerThread*
 AndroidDeviceManager::HandlerThread::instance_ = NULL;
 
 // static
@@ skipping 89 matching lines @@
           it->provider, it->serial);
     } else {
       device = found->second.get();
     }
     response.push_back(device);
     new_devices[it->serial] = device->weak_factory_.GetWeakPtr();
   }
   devices_.swap(new_devices);
   callback.Run(response);
 }