DevTools: Partially redesigned DevToolsAndroidBridge and AndroidDeviceManager

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 200 matching lines @@
 
 // static
 scoped_refptr<AndroidDeviceManager> AndroidDeviceManager::Create() {
   return new AndroidDeviceManager();
 }
 
 void AndroidDeviceManager::QueryDevices(
     const DeviceProviders& providers,
     const QueryDevicesCallback& callback) {
   DCHECK(CalledOnValidThread());
-  stopped_ = false;
   Devices empty;
   QueryNextProvider(callback, providers, empty, empty);
 }
 
-void AndroidDeviceManager::Stop() {
+void AndroidDeviceManager::ReleaseDevice(const std::string& serial) {

[pfeldman, 2014/05/21 11:33:41]

What if different clients query and release devices. How would that work?

   DCHECK(CalledOnValidThread());
-  stopped_ = true;
-  devices_.clear();
+  devices_.erase(serial);
 }
 
 bool AndroidDeviceManager::IsConnected(const std::string& serial) {
   DCHECK(CalledOnValidThread());
   Device* device = FindDevice(serial);
   return device && device->is_connected();
 }
 
 void AndroidDeviceManager::QueryDeviceInfo(const std::string& serial,
                                            const DeviceInfoCallback& callback) {
@@ skipping 41 matching lines @@
     device->OpenSocket(
         socket_name,
         base::Bind(&HttpRequest::SocketRequest,
                    base::StringPrintf(kWebSocketUpgradeRequest, url.c_str()),
                    callback));
   } else {
     callback.Run(net::ERR_CONNECTION_FAILED, NULL);
   }
 }
 
-AndroidDeviceManager::AndroidDeviceManager()
-    : stopped_(false) {
+AndroidDeviceManager::AndroidDeviceManager() {
 }
 
 AndroidDeviceManager::~AndroidDeviceManager() {
 }
 
 void AndroidDeviceManager::QueryNextProvider(
     const QueryDevicesCallback& callback,
     const DeviceProviders& providers,
     const Devices& total_devices,
     const Devices& new_devices) {
   DCHECK(CalledOnValidThread());
 
-  if (stopped_)
-    return;
-
   Devices more_devices(total_devices);
   more_devices.insert(
       more_devices.end(), new_devices.begin(), new_devices.end());
 
   if (providers.empty()) {
     std::vector<std::string> serials;
     devices_.clear();
     for (Devices::const_iterator it = more_devices.begin();
         it != more_devices.end(); ++it) {
       devices_[(*it)->serial()] = *it;
@@ skipping 12 matching lines @@
 }
 
 AndroidDeviceManager::Device*
 AndroidDeviceManager::FindDevice(const std::string& serial) {
   DCHECK(CalledOnValidThread());
   DeviceMap::const_iterator it = devices_.find(serial);
   if (it == devices_.end())
     return NULL;
   return (*it).second.get();
 }