chrome/browser/extensions/api/bluetooth_socket/bluetooth_socket_api.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_EXTENSIONS_API_BLUETOOTH_SOCKET_BLUETOOTH_SOCKET_API_H_
   6 #define CHROME_BROWSER_EXTENSIONS_API_BLUETOOTH_SOCKET_BLUETOOTH_SOCKET_API_H_
   7
   8 #include <string>
   9
  10 #include "base/containers/hash_tables.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "chrome/browser/extensions/api/bluetooth_socket/bluetooth_api_socket.h"
  14 #include "chrome/common/extensions/api/bluetooth_socket.h"
  15 #include "device/bluetooth/bluetooth_adapter.h"
  16 #include "extensions/browser/api/api_resource_manager.h"
  17 #include "extensions/browser/api/async_api_function.h"
  18 #include "extensions/browser/extension_function.h"
  19 #include "extensions/browser/extension_function_histogram_value.h"
  20
  21 namespace device {
  22 class BluetoothSocket;
  23 }
  24
  25 namespace net {
  26 class IOBuffer;
  27 }
  28
  29 namespace extensions {
  30
  31 namespace api {
  32
  33 class BluetoothSocketEventDispatcher;
  34
  35 // Asynchronous API function that performs its work on the BluetoothApiSocket
  36 // thread while providing methods to manage resources of that class. This
  37 // follows the pattern of AsyncApiFunction, but does not derive from it,
  38 // because BluetoothApiSocket methods must be called on the UI Thread.
  39 class BluetoothSocketAsyncApiFunction : public AsyncExtensionFunction {
  40  public:
  41   BluetoothSocketAsyncApiFunction();
  42
  43  protected:
  44   virtual ~BluetoothSocketAsyncApiFunction();
  45
  46   // AsyncExtensionFunction:
  47   virtual bool RunAsync() OVERRIDE;
  48
  49   bool PrePrepare();
  50   bool Respond();
  51   void AsyncWorkCompleted();
  52
  53   virtual bool Prepare() = 0;
  54   virtual void Work();
  55   virtual void AsyncWorkStart();
  56
  57   content::BrowserThread::ID work_thread_id() const;
  58
  59   int AddSocket(BluetoothApiSocket* socket);
  60   BluetoothApiSocket* GetSocket(int api_resource_id);
  61   void RemoveSocket(int api_resource_id);
  62   base::hash_set<int>* GetSocketIds();
  63
  64  private:
  65   ApiResourceManager<BluetoothApiSocket>* manager_;
  66 };
  67
  68 class BluetoothSocketCreateFunction : public BluetoothSocketAsyncApiFunction {
  69  public:
  70   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.create", BLUETOOTHSOCKET_CREATE);
  71
  72   BluetoothSocketCreateFunction();
  73
  74  protected:
  75   virtual ~BluetoothSocketCreateFunction();
  76
  77   // BluetoothSocketAsyncApiFunction:
  78   virtual bool Prepare() OVERRIDE;
  79   virtual void Work() OVERRIDE;
  80
  81  private:
  82   scoped_ptr<bluetooth_socket::Create::Params> params_;
  83 };
  84
  85 class BluetoothSocketUpdateFunction : public BluetoothSocketAsyncApiFunction {
  86  public:
  87   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.update", BLUETOOTHSOCKET_UPDATE);
  88
  89   BluetoothSocketUpdateFunction();
  90
  91  protected:
  92   virtual ~BluetoothSocketUpdateFunction();
  93
  94   // BluetoothSocketAsyncApiFunction:
  95   virtual bool Prepare() OVERRIDE;
  96   virtual void Work() OVERRIDE;
  97
  98  private:
  99   scoped_ptr<bluetooth_socket::Update::Params> params_;
 100 };
 101
 102 class BluetoothSocketSetPausedFunction
 103     : public BluetoothSocketAsyncApiFunction {
 104  public:
 105   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.setPaused",
 106                              BLUETOOTHSOCKET_SETPAUSED);
 107
 108   BluetoothSocketSetPausedFunction();
 109
 110  protected:
 111   virtual ~BluetoothSocketSetPausedFunction();
 112
 113   // BluetoothSocketAsyncApiFunction:
 114   virtual bool Prepare() OVERRIDE;
 115   virtual void Work() OVERRIDE;
 116
 117  private:
 118   scoped_ptr<bluetooth_socket::SetPaused::Params> params_;
 119   BluetoothSocketEventDispatcher* socket_event_dispatcher_;
 120 };
 121
 122 class BluetoothSocketListenFunction : public BluetoothSocketAsyncApiFunction {
 123  public:
 124   BluetoothSocketListenFunction();
 125
 126   virtual bool CreateParams() = 0;
 127   virtual void CreateService(
 128       scoped_refptr<device::BluetoothAdapter> adapter,
 129       const device::BluetoothUUID& uuid,
 130       scoped_ptr<std::string> name,
 131       const device::BluetoothAdapter::CreateServiceCallback& callback,
 132       const device::BluetoothAdapter::CreateServiceErrorCallback&
 133           error_callback) = 0;
 134   virtual void CreateResults() = 0;
 135
 136   virtual int socket_id() const = 0;
 137   virtual const std::string& uuid() const = 0;
 138
 139   // BluetoothSocketAsyncApiFunction:
 140   virtual bool Prepare() OVERRIDE;
 141   virtual void AsyncWorkStart() OVERRIDE;
 142
 143  protected:
 144   virtual ~BluetoothSocketListenFunction();
 145
 146   virtual void OnGetAdapter(scoped_refptr<device::BluetoothAdapter> adapter);
 147   virtual void OnCreateService(scoped_refptr<device::BluetoothSocket> socket);
 148   virtual void OnCreateServiceError(const std::string& message);
 149
 150   BluetoothSocketEventDispatcher* socket_event_dispatcher_;
 151 };
 152
 153 class BluetoothSocketListenUsingRfcommFunction
 154     : public BluetoothSocketListenFunction {
 155  public:
 156   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.listenUsingRfcomm",
 157                              BLUETOOTHSOCKET_LISTENUSINGRFCOMM);
 158
 159   BluetoothSocketListenUsingRfcommFunction();
 160
 161   // BluetoothSocketListenFunction:
 162   virtual int socket_id() const OVERRIDE;
 163   virtual const std::string& uuid() const OVERRIDE;
 164
 165   virtual bool CreateParams() OVERRIDE;
 166   virtual void CreateService(
 167       scoped_refptr<device::BluetoothAdapter> adapter,
 168       const device::BluetoothUUID& uuid,
 169       scoped_ptr<std::string> name,
 170       const device::BluetoothAdapter::CreateServiceCallback& callback,
 171       const device::BluetoothAdapter::CreateServiceErrorCallback&
 172           error_callback) OVERRIDE;
 173   virtual void CreateResults() OVERRIDE;
 174
 175  protected:
 176   virtual ~BluetoothSocketListenUsingRfcommFunction();
 177
 178  private:
 179   scoped_ptr<bluetooth_socket::ListenUsingRfcomm::Params> params_;
 180 };
 181
 182 class BluetoothSocketListenUsingL2capFunction
 183     : public BluetoothSocketListenFunction {
 184  public:
 185   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.listenUsingL2cap",
 186                              BLUETOOTHSOCKET_LISTENUSINGL2CAP);
 187
 188   BluetoothSocketListenUsingL2capFunction();
 189
 190   // BluetoothSocketListenFunction:
 191   virtual int socket_id() const OVERRIDE;
 192   virtual const std::string& uuid() const OVERRIDE;
 193
 194   virtual bool CreateParams() OVERRIDE;
 195   virtual void CreateService(
 196       scoped_refptr<device::BluetoothAdapter> adapter,
 197       const device::BluetoothUUID& uuid,
 198       scoped_ptr<std::string> name,
 199       const device::BluetoothAdapter::CreateServiceCallback& callback,
 200       const device::BluetoothAdapter::CreateServiceErrorCallback&
 201           error_callback) OVERRIDE;
 202   virtual void CreateResults() OVERRIDE;
 203
 204  protected:
 205   virtual ~BluetoothSocketListenUsingL2capFunction();
 206
 207  private:
 208   scoped_ptr<bluetooth_socket::ListenUsingL2cap::Params> params_;
 209 };
 210
 211 class BluetoothSocketConnectFunction : public BluetoothSocketAsyncApiFunction {
 212  public:
 213   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.connect",
 214                              BLUETOOTHSOCKET_CONNECT);
 215
 216   BluetoothSocketConnectFunction();
 217
 218  protected:
 219   virtual ~BluetoothSocketConnectFunction();
 220
 221   // BluetoothSocketAsyncApiFunction:
 222   virtual bool Prepare() OVERRIDE;
 223   virtual void AsyncWorkStart() OVERRIDE;
 224
 225  private:
 226   virtual void OnGetAdapter(scoped_refptr<device::BluetoothAdapter> adapter);
 227   virtual void OnConnect(scoped_refptr<device::BluetoothSocket> socket);
 228   virtual void OnConnectError(const std::string& message);
 229
 230   scoped_ptr<bluetooth_socket::Connect::Params> params_;
 231   BluetoothSocketEventDispatcher* socket_event_dispatcher_;
 232 };
 233
 234 class BluetoothSocketDisconnectFunction
 235     : public BluetoothSocketAsyncApiFunction {
 236  public:
 237   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.disconnect",
 238                              BLUETOOTHSOCKET_DISCONNECT);
 239
 240   BluetoothSocketDisconnectFunction();
 241
 242  protected:
 243   virtual ~BluetoothSocketDisconnectFunction();
 244
 245   // BluetoothSocketAsyncApiFunction:
 246   virtual bool Prepare() OVERRIDE;
 247   virtual void AsyncWorkStart() OVERRIDE;
 248
 249  private:
 250   virtual void OnSuccess();
 251
 252   scoped_ptr<bluetooth_socket::Disconnect::Params> params_;
 253 };
 254
 255 class BluetoothSocketCloseFunction : public BluetoothSocketAsyncApiFunction {
 256  public:
 257   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.close", BLUETOOTHSOCKET_CLOSE);
 258
 259   BluetoothSocketCloseFunction();
 260
 261  protected:
 262   virtual ~BluetoothSocketCloseFunction();
 263
 264   // BluetoothSocketAsyncApiFunction:
 265   virtual bool Prepare() OVERRIDE;
 266   virtual void Work() OVERRIDE;
 267
 268  private:
 269   scoped_ptr<bluetooth_socket::Close::Params> params_;
 270 };
 271
 272 class BluetoothSocketSendFunction : public BluetoothSocketAsyncApiFunction {
 273  public:
 274   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.send", BLUETOOTHSOCKET_SEND);
 275
 276   BluetoothSocketSendFunction();
 277
 278  protected:
 279   virtual ~BluetoothSocketSendFunction();
 280
 281   // BluetoothSocketAsyncApiFunction:
 282   virtual bool Prepare() OVERRIDE;
 283   virtual void AsyncWorkStart() OVERRIDE;
 284
 285  private:
 286   void OnSuccess(int bytes_sent);
 287   void OnError(BluetoothApiSocket::ErrorReason reason,
 288                const std::string& message);
 289
 290   scoped_ptr<bluetooth_socket::Send::Params> params_;
 291   scoped_refptr<net::IOBuffer> io_buffer_;
 292   size_t io_buffer_size_;
 293 };
 294
 295 class BluetoothSocketGetInfoFunction : public BluetoothSocketAsyncApiFunction {
 296  public:
 297   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.getInfo",
 298                              BLUETOOTHSOCKET_GETINFO);
 299
 300   BluetoothSocketGetInfoFunction();
 301
 302  protected:
 303   virtual ~BluetoothSocketGetInfoFunction();
 304
 305   // BluetoothSocketAsyncApiFunction:
 306   virtual bool Prepare() OVERRIDE;
 307   virtual void Work() OVERRIDE;
 308
 309  private:
 310   scoped_ptr<bluetooth_socket::GetInfo::Params> params_;
 311 };
 312
 313 class BluetoothSocketGetSocketsFunction
 314     : public BluetoothSocketAsyncApiFunction {
 315  public:
 316   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.getSockets",
 317                              BLUETOOTHSOCKET_GETSOCKETS);
 318
 319   BluetoothSocketGetSocketsFunction();
 320
 321  protected:
 322   virtual ~BluetoothSocketGetSocketsFunction();
 323
 324   // BluetoothSocketAsyncApiFunction:
 325   virtual bool Prepare() OVERRIDE;
 326   virtual void Work() OVERRIDE;
 327 };
 328
 329 }  // namespace api
 330 }  // namespace extensions
 331
 332 #endif  // CHROME_BROWSER_EXTENSIONS_API_BLUETOOTH_SOCKET_BLUETOOTH_SOCKET_API_H_