src/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/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 BluetoothSocketListenUsingRfcommFunction : public AsyncExtensionFunction {
 123  public:
 124   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.listenUsingRfcomm",
 125                              BLUETOOTHSOCKET_LISTENUSINGRFCOMM);
 126
 127  protected:
 128   virtual ~BluetoothSocketListenUsingRfcommFunction() {}
 129
 130   // AsyncExtensionFunction override:
 131   virtual bool RunAsync() OVERRIDE;
 132 };
 133
 134 class BluetoothSocketListenUsingInsecureRfcommFunction
 135     : public AsyncExtensionFunction {
 136  public:
 137   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.listenUsingInsecureRfcomm",
 138                              BLUETOOTHSOCKET_LISTENUSINGINSECURERFCOMM);
 139
 140  protected:
 141   virtual ~BluetoothSocketListenUsingInsecureRfcommFunction() {}
 142
 143   // AsyncExtensionFunction override:
 144   virtual bool RunAsync() OVERRIDE;
 145 };
 146
 147 class BluetoothSocketListenUsingL2capFunction : public AsyncExtensionFunction {
 148  public:
 149   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.listenUsingL2cap",
 150                              BLUETOOTHSOCKET_LISTENUSINGL2CAP);
 151
 152  protected:
 153   virtual ~BluetoothSocketListenUsingL2capFunction() {}
 154
 155   // AsyncExtensionFunction override:
 156   virtual bool RunAsync() OVERRIDE;
 157 };
 158
 159 class BluetoothSocketConnectFunction : public BluetoothSocketAsyncApiFunction {
 160  public:
 161   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.connect",
 162                              BLUETOOTHSOCKET_CONNECT);
 163
 164   BluetoothSocketConnectFunction();
 165
 166  protected:
 167   virtual ~BluetoothSocketConnectFunction();
 168
 169   // BluetoothSocketAsyncApiFunction:
 170   virtual bool Prepare() OVERRIDE;
 171   virtual void AsyncWorkStart() OVERRIDE;
 172
 173  private:
 174   virtual void OnGetAdapter(scoped_refptr<device::BluetoothAdapter> adapter);
 175   virtual void OnConnect(scoped_refptr<device::BluetoothSocket> socket);
 176   virtual void OnConnectError(const std::string& message);
 177
 178   scoped_ptr<bluetooth_socket::Connect::Params> params_;
 179   BluetoothSocketEventDispatcher* socket_event_dispatcher_;
 180 };
 181
 182 class BluetoothSocketDisconnectFunction
 183     : public BluetoothSocketAsyncApiFunction {
 184  public:
 185   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.disconnect",
 186                              BLUETOOTHSOCKET_DISCONNECT);
 187
 188   BluetoothSocketDisconnectFunction();
 189
 190  protected:
 191   virtual ~BluetoothSocketDisconnectFunction();
 192
 193   // BluetoothSocketAsyncApiFunction:
 194   virtual bool Prepare() OVERRIDE;
 195   virtual void AsyncWorkStart() OVERRIDE;
 196
 197  private:
 198   virtual void OnSuccess();
 199
 200   scoped_ptr<bluetooth_socket::Disconnect::Params> params_;
 201 };
 202
 203 class BluetoothSocketCloseFunction : public BluetoothSocketAsyncApiFunction {
 204  public:
 205   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.close", BLUETOOTHSOCKET_CLOSE);
 206
 207   BluetoothSocketCloseFunction();
 208
 209  protected:
 210   virtual ~BluetoothSocketCloseFunction();
 211
 212   // BluetoothSocketAsyncApiFunction:
 213   virtual bool Prepare() OVERRIDE;
 214   virtual void Work() OVERRIDE;
 215
 216  private:
 217   scoped_ptr<bluetooth_socket::Close::Params> params_;
 218 };
 219
 220 class BluetoothSocketSendFunction : public BluetoothSocketAsyncApiFunction {
 221  public:
 222   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.send", BLUETOOTHSOCKET_SEND);
 223
 224   BluetoothSocketSendFunction();
 225
 226  protected:
 227   virtual ~BluetoothSocketSendFunction();
 228
 229   // BluetoothSocketAsyncApiFunction:
 230   virtual bool Prepare() OVERRIDE;
 231   virtual void AsyncWorkStart() OVERRIDE;
 232
 233  private:
 234   void OnSuccess(int bytes_sent);
 235   void OnError(BluetoothApiSocket::ErrorReason reason,
 236                const std::string& message);
 237
 238   scoped_ptr<bluetooth_socket::Send::Params> params_;
 239   scoped_refptr<net::IOBuffer> io_buffer_;
 240   size_t io_buffer_size_;
 241 };
 242
 243 class BluetoothSocketGetInfoFunction : public BluetoothSocketAsyncApiFunction {
 244  public:
 245   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.getInfo",
 246                              BLUETOOTHSOCKET_GETINFO);
 247
 248   BluetoothSocketGetInfoFunction();
 249
 250  protected:
 251   virtual ~BluetoothSocketGetInfoFunction();
 252
 253   // BluetoothSocketAsyncApiFunction:
 254   virtual bool Prepare() OVERRIDE;
 255   virtual void Work() OVERRIDE;
 256
 257  private:
 258   scoped_ptr<bluetooth_socket::GetInfo::Params> params_;
 259 };
 260
 261 class BluetoothSocketGetSocketsFunction
 262     : public BluetoothSocketAsyncApiFunction {
 263  public:
 264   DECLARE_EXTENSION_FUNCTION("bluetoothSocket.getSockets",
 265                              BLUETOOTHSOCKET_GETSOCKETS);
 266
 267   BluetoothSocketGetSocketsFunction();
 268
 269  protected:
 270   virtual ~BluetoothSocketGetSocketsFunction();
 271
 272   // BluetoothSocketAsyncApiFunction:
 273   virtual bool Prepare() OVERRIDE;
 274   virtual void Work() OVERRIDE;
 275 };
 276
 277 }  // namespace api
 278 }  // namespace extensions
 279
 280 #endif  // CHROME_BROWSER_EXTENSIONS_API_BLUETOOTH_SOCKET_BLUETOOTH_SOCKET_API_H_