chrome/browser/devtools/device/android_device_manager.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_DEVTOOLS_DEVICE_ANDROID_DEVICE_MANAGER_H_
   6 #define CHROME_BROWSER_DEVTOOLS_DEVICE_ANDROID_DEVICE_MANAGER_H_
   7
   8 #include <vector>
   9
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "base/single_thread_task_runner.h"
  13 #include "base/threading/non_thread_safe.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "content/public/browser/browser_thread.h"
  16 #include "ui/gfx/geometry/size.h"
  17
  18 namespace net {
  19 class StreamSocket;
  20 }
  21
  22 class AndroidDeviceManager : public base::NonThreadSafe {
  23  public:
  24   using CommandCallback =
  25       base::Callback<void(int, const std::string&)>;
  26   using SocketCallback =
  27       base::Callback<void(int result, scoped_ptr<net::StreamSocket>)>;
  28   // |body_head| should contain the body (WebSocket frame data) part that has
  29   // been read during processing the header (WebSocket handshake).
  30   using HttpUpgradeCallback = base::Callback<void(
  31       int result,
  32       const std::string& extensions,
  33       const std::string& body_head,
  34       scoped_ptr<net::StreamSocket>)>;
  35   using SerialsCallback =
  36       base::Callback<void(const std::vector<std::string>&)>;
  37
  38   struct BrowserInfo {
  39     BrowserInfo();
  40
  41     enum Type {
  42       kTypeChrome,
  43       kTypeWebView,
  44       kTypeOther
  45     };
  46
  47     std::string socket_name;
  48     std::string display_name;
  49     std::string user;
  50     Type type;
  51   };
  52
  53   struct DeviceInfo {
  54     DeviceInfo();
  55     ~DeviceInfo();
  56
  57     std::string model;
  58     bool connected;
  59     gfx::Size screen_size;
  60     std::vector<BrowserInfo> browser_info;
  61   };
  62
  63   typedef base::Callback<void(const DeviceInfo&)> DeviceInfoCallback;
  64   class Device;
  65
  66   class AndroidWebSocket {
  67    public:
  68     class Delegate {
  69      public:
  70       virtual void OnSocketOpened() = 0;
  71       virtual void OnFrameRead(const std::string& message) = 0;
  72       virtual void OnSocketClosed() = 0;
  73
  74      protected:
  75       virtual ~Delegate() {}
  76     };
  77
  78     ~AndroidWebSocket();
  79
  80     void SendFrame(const std::string& message);
  81
  82    private:
  83     friend class Device;
  84     class WebSocketImpl;
  85
  86     AndroidWebSocket(
  87         scoped_refptr<Device> device,
  88         const std::string& socket_name,
  89         const std::string& path,
  90         AndroidWebSocket::Delegate* delegate);
  91     void Connected(int result,
  92                    const std::string& extensions,
  93                    const std::string& body_head,
  94                    scoped_ptr<net::StreamSocket> socket);
  95     void OnFrameRead(const std::string& message);
  96     void OnSocketClosed();
  97     void Terminate();
  98
  99     Device* device_;
 100     WebSocketImpl* socket_impl_;
 101     Delegate* delegate_;
 102     base::WeakPtrFactory<AndroidWebSocket> weak_factory_;
 103     DISALLOW_COPY_AND_ASSIGN(AndroidWebSocket);
 104   };
 105
 106   class DeviceProvider;
 107
 108   class Device : public base::RefCountedThreadSafe<Device>,
 109                  public base::NonThreadSafe {
 110    public:
 111     void QueryDeviceInfo(const DeviceInfoCallback& callback);
 112
 113     void OpenSocket(const std::string& socket_name,
 114                     const SocketCallback& callback);
 115
 116     void SendJsonRequest(const std::string& socket_name,
 117                          const std::string& request,
 118                          const CommandCallback& callback);
 119
 120     void HttpUpgrade(const std::string& socket_name,
 121                      const std::string& path,
 122                      const std::string& extensions,
 123                      const HttpUpgradeCallback& callback);
 124     AndroidWebSocket* CreateWebSocket(
 125         const std::string& socket_name,
 126         const std::string& path,
 127         AndroidWebSocket::Delegate* delegate);
 128
 129     std::string serial() { return serial_; }
 130
 131    private:
 132     friend class base::RefCountedThreadSafe<Device>;
 133     friend class AndroidDeviceManager;
 134     friend class AndroidWebSocket;
 135
 136     Device(scoped_refptr<base::SingleThreadTaskRunner> device_task_runner,
 137            scoped_refptr<DeviceProvider> provider,
 138            const std::string& serial);
 139
 140     virtual ~Device();
 141
 142     scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 143     scoped_refptr<DeviceProvider> provider_;
 144     std::string serial_;
 145     std::set<AndroidWebSocket*> sockets_;
 146     base::WeakPtrFactory<Device> weak_factory_;
 147
 148     DISALLOW_COPY_AND_ASSIGN(Device);
 149   };
 150
 151   typedef std::vector<scoped_refptr<Device> > Devices;
 152   typedef base::Callback<void(const Devices&)> DevicesCallback;
 153
 154   class DeviceProvider : public base::RefCountedThreadSafe<DeviceProvider> {
 155    public:
 156     typedef AndroidDeviceManager::SerialsCallback SerialsCallback;
 157     typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
 158     typedef AndroidDeviceManager::SocketCallback SocketCallback;
 159     typedef AndroidDeviceManager::CommandCallback CommandCallback;
 160
 161     virtual void QueryDevices(const SerialsCallback& callback) = 0;
 162
 163     virtual void QueryDeviceInfo(const std::string& serial,
 164                                  const DeviceInfoCallback& callback) = 0;
 165
 166     virtual void OpenSocket(const std::string& serial,
 167                             const std::string& socket_name,
 168                             const SocketCallback& callback) = 0;
 169
 170     virtual void SendJsonRequest(const std::string& serial,
 171                                  const std::string& socket_name,
 172                                  const std::string& request,
 173                                  const CommandCallback& callback);
 174
 175     virtual void HttpUpgrade(const std::string& serial,
 176                              const std::string& socket_name,
 177                              const std::string& path,
 178                              const std::string& extensions,
 179                              const HttpUpgradeCallback& callback);
 180
 181     virtual void ReleaseDevice(const std::string& serial);
 182
 183    protected:
 184     friend class base::RefCountedThreadSafe<DeviceProvider>;
 185     DeviceProvider();
 186     virtual ~DeviceProvider();
 187   };
 188
 189   typedef std::vector<scoped_refptr<DeviceProvider> > DeviceProviders;
 190
 191   virtual ~AndroidDeviceManager();
 192
 193   static scoped_ptr<AndroidDeviceManager> Create();
 194
 195   void SetDeviceProviders(const DeviceProviders& providers);
 196
 197   void QueryDevices(const DevicesCallback& callback);
 198
 199   static std::string GetBrowserName(const std::string& socket,
 200                                     const std::string& package);
 201   using RunCommandCallback =
 202       base::Callback<void(const std::string&, const CommandCallback&)>;
 203
 204   static void QueryDeviceInfo(const RunCommandCallback& command_callback,
 205                               const DeviceInfoCallback& callback);
 206
 207   struct DeviceDescriptor {
 208     DeviceDescriptor();
 209     ~DeviceDescriptor();
 210
 211     scoped_refptr<DeviceProvider> provider;
 212     std::string serial;
 213   };
 214
 215   typedef std::vector<DeviceDescriptor> DeviceDescriptors;
 216
 217  private:
 218   class HandlerThread : public base::RefCountedThreadSafe<HandlerThread> {
 219    public:
 220     static scoped_refptr<HandlerThread> GetInstance();
 221     scoped_refptr<base::SingleThreadTaskRunner> message_loop();
 222
 223    private:
 224     friend class base::RefCountedThreadSafe<HandlerThread>;
 225     static HandlerThread* instance_;
 226     static void StopThread(base::Thread* thread);
 227
 228     HandlerThread();
 229     virtual ~HandlerThread();
 230     base::Thread* thread_;
 231   };
 232
 233   AndroidDeviceManager();
 234
 235   void UpdateDevices(const DevicesCallback& callback,
 236                      scoped_ptr<DeviceDescriptors> descriptors);
 237
 238   typedef std::map<std::string, base::WeakPtr<Device> > DeviceWeakMap;
 239
 240   scoped_refptr<HandlerThread> handler_thread_;
 241   DeviceProviders providers_;
 242   DeviceWeakMap devices_;
 243
 244   base::WeakPtrFactory<AndroidDeviceManager> weak_factory_;
 245 };
 246
 247 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_ANDROID_DEVICE_MANAGER_H_