DevTools: Partially redesigned DevToolsAndroidBridge and AndroidDeviceManager

chrome/browser/devtools/device/adb/adb_device_provider.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/adb/adb_device_provider.h"
 
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/devtools/device/adb/adb_client_socket.h"
 #include "chrome/browser/devtools/device/adb/adb_device_info_query.h"
 
 namespace {
 
 const char kHostDevicesCommand[] = "host:devices";
 const char kHostTransportCommand[] = "host:transport:%s|%s";
 const char kLocalAbstractCommand[] = "localabstract:%s";
 
 const int kAdbPort = 5037;
 
-class AdbDeviceImpl : public AndroidDeviceManager::Device {
- public:
-  AdbDeviceImpl(const std::string& serial, bool is_connected);
-  virtual void QueryDeviceInfo(const DeviceInfoCallback& callback) OVERRIDE;
-
-  virtual void OpenSocket(const std::string& name,
-                          const SocketCallback& callback) OVERRIDE;
- private:
-  virtual ~AdbDeviceImpl() {}
-
-  void RunCommand(const std::string& command,
-                  const CommandCallback& callback);
-};
-
-AdbDeviceImpl::AdbDeviceImpl(const std::string& serial, bool is_connected)
-    : Device(serial, is_connected) {
-}
-
-void AdbDeviceImpl::QueryDeviceInfo(const DeviceInfoCallback& callback) {
-  AdbDeviceInfoQuery::Start(
-      base::Bind(&AdbDeviceImpl::RunCommand, this), callback);
-}
-
-void AdbDeviceImpl::OpenSocket(const std::string& name,
-                               const SocketCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  std::string socket_name =
-      base::StringPrintf(kLocalAbstractCommand, name.c_str());
-  AdbClientSocket::TransportQuery(kAdbPort, serial(), socket_name, callback);
-}
-
-void AdbDeviceImpl::RunCommand(const std::string& command,
-                               const CommandCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  std::string query = base::StringPrintf(kHostTransportCommand,
-                                         serial().c_str(), command.c_str());
+static void RunCommand(const std::string& serial,
+                       const std::string& command,
+                       const AdbDeviceProvider::CommandCallback& callback) {
+  std::string query = base::StringPrintf(
+      kHostTransportCommand, serial.c_str(), command.c_str());
   AdbClientSocket::AdbQuery(kAdbPort, query, callback);
 }
 
-// static
-void ReceivedAdbDevices(
-    const AdbDeviceProvider::QueryDevicesCallback& callback,
+static void ReceivedAdbDevices(
+    const AdbDeviceProvider::SerialsCallback& callback,
     int result_code,
     const std::string& response) {
-  AndroidDeviceManager::Devices result;
+  std::vector<std::string> result;
   std::vector<std::string> serials;
   Tokenize(response, "\n", &serials);
   for (size_t i = 0; i < serials.size(); ++i) {
     std::vector<std::string> tokens;
     Tokenize(serials[i], "\t ", &tokens);
-    bool offline = tokens.size() > 1 && tokens[1] == "offline";
-    result.push_back(new AdbDeviceImpl(tokens[0], !offline));
+    // bool offline = tokens.size() > 1 && tokens[1] == "offline";

[pfeldman, 2014/05/26 09:57:14]

Remove these comments.

[vkuzkokov, 2014/05/26 10:54:03]

Done.

+    // result.push_back(new AdbDeviceImpl(tokens[0], !offline));
+    result.push_back(tokens[0]);

[pfeldman, 2014/05/26 09:57:14]

You would not need to do this if you were returning the DeviceInfo arrays from
the start.

   }
   callback.Run(result);
 }
 
 } // namespace
 
-AdbDeviceProvider::~AdbDeviceProvider() {
-}
-
-void AdbDeviceProvider::QueryDevices(const QueryDevicesCallback& callback) {
+void AdbDeviceProvider::QueryDevices(const SerialsCallback& callback) {
   AdbClientSocket::AdbQuery(
       kAdbPort, kHostDevicesCommand, base::Bind(&ReceivedAdbDevices, callback));
 }
+
+void AdbDeviceProvider::QueryDeviceInfo(const std::string& serial,
+                                        const DeviceInfoCallback& callback) {
+  AdbDeviceInfoQuery::Start(base::Bind(&RunCommand, serial), callback);
+}
+
+void AdbDeviceProvider::OpenSocket(const std::string& serial,
+                                   const std::string& socket_name,
+                                   const SocketCallback& callback) {
+  std::string request =
+      base::StringPrintf(kLocalAbstractCommand, socket_name.c_str());
+  AdbClientSocket::TransportQuery(kAdbPort, serial, request, callback);
+}
+
+AdbDeviceProvider::~AdbDeviceProvider() {
+}