extensions/browser/api/serial/serial_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 EXTENSIONS_BROWSER_API_SERIAL_SERIAL_API_H_
   6 #define EXTENSIONS_BROWSER_API_SERIAL_SERIAL_API_H_
   7
   8 #include <string>
   9
  10 #include "device/serial/serial.mojom.h"
  11 #include "extensions/browser/api/api_resource_manager.h"
  12 #include "extensions/browser/api/async_api_function.h"
  13 #include "extensions/common/api/serial.h"
  14
  15 namespace extensions {
  16
  17 class SerialConnection;
  18
  19 namespace api {
  20
  21 class SerialEventDispatcher;
  22
  23 class SerialAsyncApiFunction : public AsyncApiFunction {
  24  public:
  25   SerialAsyncApiFunction();
  26
  27  protected:
  28   ~SerialAsyncApiFunction() override;
  29
  30   // AsyncApiFunction:
  31   bool PrePrepare() override;
  32   bool Respond() override;
  33
  34   SerialConnection* GetSerialConnection(int api_resource_id);
  35   void RemoveSerialConnection(int api_resource_id);
  36
  37   ApiResourceManager<SerialConnection>* manager_;
  38 };
  39
  40 class SerialGetDevicesFunction : public SerialAsyncApiFunction {
  41  public:
  42   DECLARE_EXTENSION_FUNCTION("serial.getDevices", SERIAL_GETDEVICES)
  43
  44   SerialGetDevicesFunction();
  45
  46  protected:
  47   ~SerialGetDevicesFunction() override {}
  48
  49   // AsyncApiFunction:
  50   bool Prepare() override;
  51   void Work() override;
  52 };
  53
  54 class SerialConnectFunction : public SerialAsyncApiFunction {
  55  public:
  56   DECLARE_EXTENSION_FUNCTION("serial.connect", SERIAL_CONNECT)
  57
  58   SerialConnectFunction();
  59
  60  protected:
  61   ~SerialConnectFunction() override;
  62
  63   // AsyncApiFunction:
  64   bool Prepare() override;
  65   void AsyncWorkStart() override;
  66
  67   virtual SerialConnection* CreateSerialConnection(
  68       const std::string& port,
  69       const std::string& extension_id) const;
  70
  71  private:
  72   void OnConnected(bool success);
  73   void FinishConnect();
  74
  75   scoped_ptr<serial::Connect::Params> params_;
  76
  77   // SerialEventDispatcher is owned by a BrowserContext.
  78   SerialEventDispatcher* serial_event_dispatcher_;
  79
  80   // This connection is created within SerialConnectFunction.
  81   // From there it is either destroyed in OnConnected (upon failure)
  82   // or its ownership is transferred to the
  83   // ApiResourceManager<SerialConnection>.
  84   SerialConnection* connection_;
  85 };
  86
  87 class SerialUpdateFunction : public SerialAsyncApiFunction {
  88  public:
  89   DECLARE_EXTENSION_FUNCTION("serial.update", SERIAL_UPDATE);
  90
  91   SerialUpdateFunction();
  92
  93  protected:
  94   ~SerialUpdateFunction() override;
  95
  96   // AsyncApiFunction:
  97   bool Prepare() override;
  98   void Work() override;
  99
 100  private:
 101   scoped_ptr<serial::Update::Params> params_;
 102 };
 103
 104 class SerialDisconnectFunction : public SerialAsyncApiFunction {
 105  public:
 106   DECLARE_EXTENSION_FUNCTION("serial.disconnect", SERIAL_DISCONNECT)
 107
 108   SerialDisconnectFunction();
 109
 110  protected:
 111   ~SerialDisconnectFunction() override;
 112
 113   // AsyncApiFunction:
 114   bool Prepare() override;
 115   void Work() override;
 116
 117  private:
 118   scoped_ptr<serial::Disconnect::Params> params_;
 119 };
 120
 121 class SerialSetPausedFunction : public SerialAsyncApiFunction {
 122  public:
 123   DECLARE_EXTENSION_FUNCTION("serial.setPaused", SERIAL_SETPAUSED)
 124
 125   SerialSetPausedFunction();
 126
 127  protected:
 128   ~SerialSetPausedFunction() override;
 129
 130   // AsyncApiFunction:
 131   bool Prepare() override;
 132   void Work() override;
 133
 134  private:
 135   scoped_ptr<serial::SetPaused::Params> params_;
 136   SerialEventDispatcher* serial_event_dispatcher_;
 137 };
 138
 139 class SerialGetInfoFunction : public SerialAsyncApiFunction {
 140  public:
 141   DECLARE_EXTENSION_FUNCTION("serial.getInfo", SERIAL_GETINFO)
 142
 143   SerialGetInfoFunction();
 144
 145  protected:
 146   ~SerialGetInfoFunction() override;
 147
 148   // AsyncApiFunction:
 149   bool Prepare() override;
 150   void Work() override;
 151
 152  private:
 153   scoped_ptr<serial::GetInfo::Params> params_;
 154 };
 155
 156 class SerialGetConnectionsFunction : public SerialAsyncApiFunction {
 157  public:
 158   DECLARE_EXTENSION_FUNCTION("serial.getConnections", SERIAL_GETCONNECTIONS);
 159
 160   SerialGetConnectionsFunction();
 161
 162  protected:
 163   ~SerialGetConnectionsFunction() override;
 164
 165   // AsyncApiFunction:
 166   bool Prepare() override;
 167   void Work() override;
 168 };
 169
 170 class SerialSendFunction : public SerialAsyncApiFunction {
 171  public:
 172   DECLARE_EXTENSION_FUNCTION("serial.send", SERIAL_SEND)
 173
 174   SerialSendFunction();
 175
 176  protected:
 177   ~SerialSendFunction() override;
 178
 179   // AsyncApiFunction:
 180   bool Prepare() override;
 181   void AsyncWorkStart() override;
 182
 183  private:
 184   void OnSendComplete(int bytes_sent, serial::SendError error);
 185
 186   scoped_ptr<serial::Send::Params> params_;
 187 };
 188
 189 class SerialFlushFunction : public SerialAsyncApiFunction {
 190  public:
 191   DECLARE_EXTENSION_FUNCTION("serial.flush", SERIAL_FLUSH)
 192
 193   SerialFlushFunction();
 194
 195  protected:
 196   ~SerialFlushFunction() override;
 197
 198   // AsyncApiFunction:
 199   bool Prepare() override;
 200   void Work() override;
 201
 202  private:
 203   scoped_ptr<serial::Flush::Params> params_;
 204 };
 205
 206 class SerialGetControlSignalsFunction : public SerialAsyncApiFunction {
 207  public:
 208   DECLARE_EXTENSION_FUNCTION("serial.getControlSignals",
 209                              SERIAL_GETCONTROLSIGNALS)
 210
 211   SerialGetControlSignalsFunction();
 212
 213  protected:
 214   ~SerialGetControlSignalsFunction() override;
 215
 216   // AsyncApiFunction:
 217   bool Prepare() override;
 218   void Work() override;
 219
 220  private:
 221   scoped_ptr<serial::GetControlSignals::Params> params_;
 222 };
 223
 224 class SerialSetControlSignalsFunction : public SerialAsyncApiFunction {
 225  public:
 226   DECLARE_EXTENSION_FUNCTION("serial.setControlSignals",
 227                              SERIAL_SETCONTROLSIGNALS)
 228
 229   SerialSetControlSignalsFunction();
 230
 231  protected:
 232   ~SerialSetControlSignalsFunction() override;
 233
 234   // AsyncApiFunction:
 235   bool Prepare() override;
 236   void Work() override;
 237
 238  private:
 239   scoped_ptr<serial::SetControlSignals::Params> params_;
 240 };
 241
 242 class SerialSetBreakFunction : public SerialAsyncApiFunction {
 243  public:
 244   DECLARE_EXTENSION_FUNCTION("serial.setBreak", SERIAL_SETBREAK)
 245   SerialSetBreakFunction();
 246
 247  protected:
 248   ~SerialSetBreakFunction() override;
 249
 250   // AsyncApiFunction:
 251   bool Prepare() override;
 252   void Work() override;
 253
 254  private:
 255   scoped_ptr<serial::SetBreak::Params> params_;
 256 };
 257
 258 class SerialClearBreakFunction : public SerialAsyncApiFunction {
 259  public:
 260   DECLARE_EXTENSION_FUNCTION("serial.clearBreak", SERIAL_CLEARBREAK)
 261   SerialClearBreakFunction();
 262
 263  protected:
 264   ~SerialClearBreakFunction() override;
 265
 266   // AsyncApiFunction:
 267   bool Prepare() override;
 268   void Work() override;
 269
 270  private:
 271   scoped_ptr<serial::ClearBreak::Params> params_;
 272 };
 273
 274 }  // namespace api
 275
 276 }  // namespace extensions
 277
 278 namespace mojo {
 279
 280 template <>
 281 struct TypeConverter<linked_ptr<extensions::api::serial::DeviceInfo>,
 282                      device::serial::DeviceInfoPtr> {
 283   static linked_ptr<extensions::api::serial::DeviceInfo> Convert(
 284       const device::serial::DeviceInfoPtr& input);
 285 };
 286
 287 }  // namespace mojo
 288
 289 #endif  // EXTENSIONS_BROWSER_API_SERIAL_SERIAL_API_H_