chrome/browser/extensions/api/serial/serial_api.h

   1 // Copyright 2012 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_SERIAL_SERIAL_API_H_
   6 #define CHROME_BROWSER_EXTENSIONS_API_SERIAL_SERIAL_API_H_
   7
   8 #include <string>
   9
  10 #include "base/memory/ref_counted.h"
  11 #include "chrome/common/extensions/api/serial.h"
  12 #include "extensions/browser/api/api_resource_manager.h"
  13 #include "extensions/browser/api/async_api_function.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   virtual ~SerialAsyncApiFunction();
  29
  30   // AsyncApiFunction:
  31   virtual bool PrePrepare() OVERRIDE;
  32   virtual 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   virtual ~SerialGetDevicesFunction() {}
  48
  49   // AsyncApiFunction:
  50   virtual bool Prepare() OVERRIDE;
  51   virtual 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   virtual ~SerialConnectFunction();
  62
  63   // AsyncApiFunction:
  64   virtual bool Prepare() OVERRIDE;
  65   virtual 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   virtual ~SerialUpdateFunction();
  95
  96   // AsyncApiFunction:
  97   virtual bool Prepare() OVERRIDE;
  98   virtual 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   virtual ~SerialDisconnectFunction();
 112
 113   // AsyncApiFunction:
 114   virtual bool Prepare() OVERRIDE;
 115   virtual 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   virtual ~SerialSetPausedFunction();
 129
 130   // AsyncApiFunction:
 131   virtual bool Prepare() OVERRIDE;
 132   virtual 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   virtual ~SerialGetInfoFunction();
 147
 148   // AsyncApiFunction:
 149   virtual bool Prepare() OVERRIDE;
 150   virtual 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   virtual ~SerialGetConnectionsFunction();
 164
 165   // AsyncApiFunction:
 166   virtual bool Prepare() OVERRIDE;
 167   virtual 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   virtual ~SerialSendFunction();
 178
 179   // AsyncApiFunction:
 180   virtual bool Prepare() OVERRIDE;
 181   virtual 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   virtual ~SerialFlushFunction();
 197
 198   // AsyncApiFunction:
 199   virtual bool Prepare() OVERRIDE;
 200   virtual 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   virtual ~SerialGetControlSignalsFunction();
 215
 216   // AsyncApiFunction:
 217   virtual bool Prepare() OVERRIDE;
 218   virtual 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   virtual ~SerialSetControlSignalsFunction();
 233
 234   // AsyncApiFunction:
 235   virtual bool Prepare() OVERRIDE;
 236   virtual void Work() OVERRIDE;
 237
 238  private:
 239   scoped_ptr<serial::SetControlSignals::Params> params_;
 240 };
 241
 242 }  // namespace api
 243
 244 }  // namespace extensions
 245
 246 #endif  // CHROME_BROWSER_EXTENSIONS_API_SERIAL_SERIAL_API_H_