DevTools: Partially redesigned DevToolsAndroidBridge and AndroidDeviceManager

chrome/browser/devtools/device/android_device_manager.h

Index: chrome/browser/devtools/device/android_device_manager.h
diff --git a/chrome/browser/devtools/device/android_device_manager.h b/chrome/browser/devtools/device/android_device_manager.h
index 27d1be809fa069e1330fe6e33d15bb07e2ef3fd4..9e2ea2723f9f150f69c5298ac35be26b099afffc 100644
--- a/chrome/browser/devtools/device/android_device_manager.h
+++ b/chrome/browser/devtools/device/android_device_manager.h
@@ -23,6 +23,7 @@ class AndroidDeviceManager
  public:
   typedef base::Callback<void(int, const std::string&)> CommandCallback;
   typedef base::Callback<void(int result, net::StreamSocket*)> SocketCallback;
+  typedef base::Callback<void(const std::vector<std::string>&)> SerialsCallback;
 
   struct BrowserInfo {
     BrowserInfo();
@@ -43,117 +44,167 @@ class AndroidDeviceManager
     ~DeviceInfo();
 
     std::string model;
+    bool connected;
     gfx::Size screen_size;
     std::vector<BrowserInfo> browser_info;
   };
 
   typedef base::Callback<void(const DeviceInfo&)> DeviceInfoCallback;
 
-  class Device : public base::RefCounted<Device>,
-                 public base::NonThreadSafe {
+  class AndroidWebSocket : public base::RefCountedThreadSafe<AndroidWebSocket> {
+   public:
+    class Delegate {
+     public:
+      virtual void OnSocketOpened() = 0;
+      virtual void OnFrameRead(const std::string& message) = 0;
+      virtual void OnSocketClosed(bool closed_by_device) = 0;
+
+     protected:
+      virtual ~Delegate() {}
+    };
+
+    AndroidWebSocket() {}
+
+    virtual void Connect() = 0;
+    virtual void Disconnect() = 0;
+    virtual void SendFrame(const std::string& message) = 0;
+    virtual void ClearDelegate() = 0;
+
    protected:
-    friend class AndroidDeviceManager;
+    virtual ~AndroidWebSocket() {}
+
+   private:
+    friend class base::RefCountedThreadSafe<AndroidWebSocket>;
+
+    DISALLOW_COPY_AND_ASSIGN(AndroidWebSocket);
+  };
+
+  class DeviceProvider;
 
+  class Device : public base::RefCountedThreadSafe<Device>,
+                 public base::NonThreadSafe {
+   public:
+    typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
     typedef AndroidDeviceManager::CommandCallback CommandCallback;
     typedef AndroidDeviceManager::SocketCallback SocketCallback;
-    typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
 
-    Device(const std::string& serial, bool is_connected);
+    void QueryDeviceInfo(const DeviceInfoCallback& callback);
 
-    virtual void QueryDeviceInfo(const DeviceInfoCallback& callback) = 0;
+    void OpenSocket(const std::string& socket_name,
+                    const SocketCallback& callback);
 
-    virtual void OpenSocket(const std::string& socket_name,
-                            const SocketCallback& callback) = 0;
+    void SendJsonRequest(const std::string& socket_name,
+                         const std::string& request,
+                         const CommandCallback& callback);
+
+    void HttpUpgrade(const std::string& socket_name,
+                     const std::string& url,
+                     const SocketCallback& callback);
 
-    virtual void HttpQuery(const std::string& socket_name,
-                           const std::string& request,
-                           const CommandCallback& callback);
+    scoped_refptr<AndroidWebSocket> CreateWebSocket(
+        const std::string& socket_name,
+        const std::string& url,
+        AndroidWebSocket::Delegate* delegate);
 
     std::string serial() { return serial_; }
-    bool is_connected() { return is_connected_; }
 
-    friend class base::RefCounted<Device>;
+   private:
+    friend class AndroidDeviceManager;
+    Device(scoped_refptr<base::MessageLoopProxy> device_message_loop,
+           const scoped_refptr<DeviceProvider>& provider,

[Vladislav Kaznacheev, 2014/05/30 11:44:40]

This is not a typical usage, why not just pass scoped_refptr<>?

[vkuzkokov, 2014/05/30 11:46:10]

Done.

+           const std::string& serial);
+
+    friend class base::RefCountedThreadSafe<Device>;
     virtual ~Device();
 
-   private:
-    const std::string serial_;
-    const bool is_connected_;
+    scoped_refptr<base::MessageLoopProxy> device_message_loop_;
+    scoped_refptr<DeviceProvider> provider_;
+    std::string serial_;
+    base::WeakPtrFactory<Device> weak_factory_;
 
     DISALLOW_COPY_AND_ASSIGN(Device);
   };
 
   typedef std::vector<scoped_refptr<Device> > Devices;
+  typedef base::Callback<void(const Devices&)> DevicesCallback;
 
-  class DeviceProvider
-      : public base::RefCountedThreadSafe<
-            DeviceProvider,
-            content::BrowserThread::DeleteOnUIThread> {
-   protected:
-    friend class AndroidDeviceManager;
+  class DeviceProvider : public base::RefCountedThreadSafe<DeviceProvider> {
+   public:
+    typedef AndroidDeviceManager::SerialsCallback SerialsCallback;
+    typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
+    typedef AndroidDeviceManager::SocketCallback SocketCallback;
+    typedef AndroidDeviceManager::CommandCallback CommandCallback;
 
-    typedef base::Callback<void(const Devices&)> QueryDevicesCallback;
+    virtual void QueryDevices(const SerialsCallback& callback) = 0;
 
-    virtual void QueryDevices(const QueryDevicesCallback& callback) = 0;
+    virtual void QueryDeviceInfo(const std::string& serial,
+                                 const DeviceInfoCallback& callback) = 0;
 
-   protected:
-    friend struct
-        content::BrowserThread::DeleteOnThread<content::BrowserThread::UI>;
-    friend class base::DeleteHelper<DeviceProvider>;
+    virtual void OpenSocket(const std::string& serial,
+                            const std::string& socket_name,
+                            const SocketCallback& callback) = 0;
+
+    virtual void SendJsonRequest(const std::string& serial,
+                                 const std::string& socket_name,
+                                 const std::string& request,
+                                 const CommandCallback& callback);
 
+    virtual void HttpUpgrade(const std::string& serial,
+                             const std::string& socket_name,
+                             const std::string& url,
+                             const SocketCallback& callback);
+
+    virtual void ReleaseDevice(const std::string& serial);
+
+   protected:
+    friend class base::RefCountedThreadSafe<DeviceProvider>;
     DeviceProvider();
     virtual ~DeviceProvider();
   };
 
- public:
-  static scoped_refptr<AndroidDeviceManager> Create();
-
   typedef std::vector<scoped_refptr<DeviceProvider> > DeviceProviders;
-  typedef base::Callback<void (const std::vector<std::string>&)>
-      QueryDevicesCallback;
 
-  void QueryDevices(const DeviceProviders& providers,
-                    const QueryDevicesCallback& callback);
+  static scoped_refptr<AndroidDeviceManager> Create();
 
-  void Stop();
+  void SetDeviceProviders(const DeviceProviders& providers);
 
-  bool IsConnected(const std::string& serial);
+  void QueryDevices(const DevicesCallback& callback);
 
-  void QueryDeviceInfo(const std::string& serial,
-                       const DeviceInfoCallback& callback);
+  struct DeviceDescriptor {
+    scoped_refptr<DeviceProvider> provider;
+    std::string serial;
+  };
 
-  void OpenSocket(const std::string& serial,
-                  const std::string& socket_name,
-                  const SocketCallback& callback);
+  typedef std::vector<DeviceDescriptor> DeviceDescriptors;
 
-  void HttpQuery(const std::string& serial,
-                 const std::string& socket_name,
-                 const std::string& request,
-                 const CommandCallback& callback);
+ private:
+  class HandlerThread : public base::RefCountedThreadSafe<HandlerThread> {
+   public:
+    static scoped_refptr<HandlerThread> GetInstance();
+    scoped_refptr<base::MessageLoopProxy> message_loop();
 
-  void HttpUpgrade(const std::string& serial,
-                   const std::string& socket_name,
-                   const std::string& url,
-                   const SocketCallback& callback);
+   private:
+    friend class base::RefCountedThreadSafe<HandlerThread>;
+    static HandlerThread* instance_;
+    static void StopThread(base::Thread* thread);
 
- private:
-  AndroidDeviceManager();
+    HandlerThread();
+    virtual ~HandlerThread();
+    base::Thread* thread_;
+  };
 
   friend class base::RefCountedThreadSafe<AndroidDeviceManager>;
-
+  AndroidDeviceManager();
   virtual ~AndroidDeviceManager();
 
-  void QueryNextProvider(
-      const QueryDevicesCallback& callback,
-      const DeviceProviders& providers,
-      const Devices& total_devices,
-      const Devices& new_devices);
-
-  Device* FindDevice(const std::string& serial);
+  void UpdateDevices(const DevicesCallback& callback,
+                     DeviceDescriptors* descriptors);
 
-  typedef std::map<std::string, scoped_refptr<Device> > DeviceMap;
-  DeviceMap devices_;
+  typedef std::map<std::string, base::WeakPtr<Device> > DeviceWeakMap;
 
-  bool stopped_;
+  scoped_refptr<HandlerThread> handler_thread_;
+  DeviceProviders providers_;
+  DeviceWeakMap devices_;
 };
 
 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_ANDROID_DEVICE_MANAGER_H_