extensions/browser/api/sockets_tcp/sockets_tcp_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_SOCKETS_TCP_SOCKETS_TCP_API_H_
   6 #define EXTENSIONS_BROWSER_API_SOCKETS_TCP_SOCKETS_TCP_API_H_
   7
   8 #include "extensions/browser/api/socket/socket_api.h"
   9 #include "extensions/common/api/sockets_tcp.h"
  10
  11 namespace extensions {
  12 class ResumableTCPSocket;
  13 class TLSSocket;
  14 }
  15
  16 namespace extensions {
  17 namespace api {
  18
  19 class TCPSocketEventDispatcher;
  20
  21 class TCPSocketAsyncApiFunction : public SocketAsyncApiFunction {
  22  protected:
  23   ~TCPSocketAsyncApiFunction() override;
  24
  25   scoped_ptr<SocketResourceManagerInterface> CreateSocketResourceManager()
  26       override;
  27
  28   ResumableTCPSocket* GetTcpSocket(int socket_id);
  29 };
  30
  31 class TCPSocketExtensionWithDnsLookupFunction
  32     : public SocketExtensionWithDnsLookupFunction {
  33  protected:
  34   ~TCPSocketExtensionWithDnsLookupFunction() override;
  35
  36   scoped_ptr<SocketResourceManagerInterface> CreateSocketResourceManager()
  37       override;
  38
  39   ResumableTCPSocket* GetTcpSocket(int socket_id);
  40 };
  41
  42 class SocketsTcpCreateFunction : public TCPSocketAsyncApiFunction {
  43  public:
  44   DECLARE_EXTENSION_FUNCTION("sockets.tcp.create", SOCKETS_TCP_CREATE)
  45
  46   SocketsTcpCreateFunction();
  47
  48  protected:
  49   ~SocketsTcpCreateFunction() override;
  50
  51   // AsyncApiFunction:
  52   bool Prepare() override;
  53   void Work() override;
  54
  55  private:
  56   FRIEND_TEST_ALL_PREFIXES(SocketsTcpUnitTest, Create);
  57   scoped_ptr<sockets_tcp::Create::Params> params_;
  58 };
  59
  60 class SocketsTcpUpdateFunction : public TCPSocketAsyncApiFunction {
  61  public:
  62   DECLARE_EXTENSION_FUNCTION("sockets.tcp.update", SOCKETS_TCP_UPDATE)
  63
  64   SocketsTcpUpdateFunction();
  65
  66  protected:
  67   ~SocketsTcpUpdateFunction() override;
  68
  69   // AsyncApiFunction:
  70   bool Prepare() override;
  71   void Work() override;
  72
  73  private:
  74   scoped_ptr<sockets_tcp::Update::Params> params_;
  75 };
  76
  77 class SocketsTcpSetPausedFunction : public TCPSocketAsyncApiFunction {
  78  public:
  79   DECLARE_EXTENSION_FUNCTION("sockets.tcp.setPaused", SOCKETS_TCP_SETPAUSED)
  80
  81   SocketsTcpSetPausedFunction();
  82
  83  protected:
  84   ~SocketsTcpSetPausedFunction() override;
  85
  86   // AsyncApiFunction
  87   bool Prepare() override;
  88   void Work() override;
  89
  90  private:
  91   scoped_ptr<sockets_tcp::SetPaused::Params> params_;
  92   TCPSocketEventDispatcher* socket_event_dispatcher_;
  93 };
  94
  95 class SocketsTcpSetKeepAliveFunction : public TCPSocketAsyncApiFunction {
  96  public:
  97   DECLARE_EXTENSION_FUNCTION("sockets.tcp.setKeepAlive",
  98                              SOCKETS_TCP_SETKEEPALIVE)
  99
 100   SocketsTcpSetKeepAliveFunction();
 101
 102  protected:
 103   ~SocketsTcpSetKeepAliveFunction() override;
 104
 105   // AsyncApiFunction
 106   bool Prepare() override;
 107   void Work() override;
 108
 109  private:
 110   scoped_ptr<sockets_tcp::SetKeepAlive::Params> params_;
 111 };
 112
 113 class SocketsTcpSetNoDelayFunction : public TCPSocketAsyncApiFunction {
 114  public:
 115   DECLARE_EXTENSION_FUNCTION("sockets.tcp.setNoDelay", SOCKETS_TCP_SETNODELAY)
 116
 117   SocketsTcpSetNoDelayFunction();
 118
 119  protected:
 120   ~SocketsTcpSetNoDelayFunction() override;
 121
 122   // AsyncApiFunction
 123   bool Prepare() override;
 124   void Work() override;
 125
 126  private:
 127   scoped_ptr<sockets_tcp::SetNoDelay::Params> params_;
 128 };
 129
 130 class SocketsTcpConnectFunction
 131     : public TCPSocketExtensionWithDnsLookupFunction {
 132  public:
 133   DECLARE_EXTENSION_FUNCTION("sockets.tcp.connect", SOCKETS_TCP_CONNECT)
 134
 135   SocketsTcpConnectFunction();
 136
 137  protected:
 138   ~SocketsTcpConnectFunction() override;
 139
 140   // AsyncApiFunction:
 141   bool Prepare() override;
 142   void AsyncWorkStart() override;
 143
 144   // SocketExtensionWithDnsLookupFunction:
 145   void AfterDnsLookup(int lookup_result) override;
 146
 147  private:
 148   void StartConnect();
 149   void OnCompleted(int net_result);
 150
 151   scoped_ptr<sockets_tcp::Connect::Params> params_;
 152   TCPSocketEventDispatcher* socket_event_dispatcher_;
 153 };
 154
 155 class SocketsTcpDisconnectFunction : public TCPSocketAsyncApiFunction {
 156  public:
 157   DECLARE_EXTENSION_FUNCTION("sockets.tcp.disconnect", SOCKETS_TCP_DISCONNECT)
 158
 159   SocketsTcpDisconnectFunction();
 160
 161  protected:
 162   ~SocketsTcpDisconnectFunction() override;
 163
 164   // AsyncApiFunction:
 165   bool Prepare() override;
 166   void Work() override;
 167
 168  private:
 169   scoped_ptr<sockets_tcp::Disconnect::Params> params_;
 170 };
 171
 172 class SocketsTcpSendFunction : public TCPSocketAsyncApiFunction {
 173  public:
 174   DECLARE_EXTENSION_FUNCTION("sockets.tcp.send", SOCKETS_TCP_SEND)
 175
 176   SocketsTcpSendFunction();
 177
 178  protected:
 179   ~SocketsTcpSendFunction() override;
 180
 181   // AsyncApiFunction:
 182   bool Prepare() override;
 183   void AsyncWorkStart() override;
 184
 185  private:
 186   void OnCompleted(int net_result);
 187   void SetSendResult(int net_result, int bytes_sent);
 188
 189   scoped_ptr<sockets_tcp::Send::Params> params_;
 190   scoped_refptr<net::IOBuffer> io_buffer_;
 191   size_t io_buffer_size_;
 192 };
 193
 194 class SocketsTcpCloseFunction : public TCPSocketAsyncApiFunction {
 195  public:
 196   DECLARE_EXTENSION_FUNCTION("sockets.tcp.close", SOCKETS_TCP_CLOSE)
 197
 198   SocketsTcpCloseFunction();
 199
 200  protected:
 201   ~SocketsTcpCloseFunction() override;
 202
 203   // AsyncApiFunction:
 204   bool Prepare() override;
 205   void Work() override;
 206
 207  private:
 208   scoped_ptr<sockets_tcp::Close::Params> params_;
 209 };
 210
 211 class SocketsTcpGetInfoFunction : public TCPSocketAsyncApiFunction {
 212  public:
 213   DECLARE_EXTENSION_FUNCTION("sockets.tcp.getInfo", SOCKETS_TCP_GETINFO)
 214
 215   SocketsTcpGetInfoFunction();
 216
 217  protected:
 218   ~SocketsTcpGetInfoFunction() override;
 219
 220   // AsyncApiFunction:
 221   bool Prepare() override;
 222   void Work() override;
 223
 224  private:
 225   scoped_ptr<sockets_tcp::GetInfo::Params> params_;
 226 };
 227
 228 class SocketsTcpGetSocketsFunction : public TCPSocketAsyncApiFunction {
 229  public:
 230   DECLARE_EXTENSION_FUNCTION("sockets.tcp.getSockets", SOCKETS_TCP_GETSOCKETS)
 231
 232   SocketsTcpGetSocketsFunction();
 233
 234  protected:
 235   ~SocketsTcpGetSocketsFunction() override;
 236
 237   // AsyncApiFunction:
 238   bool Prepare() override;
 239   void Work() override;
 240 };
 241
 242 class SocketsTcpSecureFunction : public TCPSocketAsyncApiFunction {
 243  public:
 244   DECLARE_EXTENSION_FUNCTION("sockets.tcp.secure", SOCKETS_TCP_SECURE);
 245
 246   SocketsTcpSecureFunction();
 247
 248  protected:
 249   ~SocketsTcpSecureFunction() override;
 250   bool Prepare() override;
 251   void AsyncWorkStart() override;
 252
 253  private:
 254   virtual void TlsConnectDone(scoped_ptr<extensions::TLSSocket> sock,
 255                               int result);
 256
 257   bool paused_;
 258   bool persistent_;
 259   scoped_ptr<sockets_tcp::Secure::Params> params_;
 260   scoped_refptr<net::URLRequestContextGetter> url_request_getter_;
 261
 262   DISALLOW_COPY_AND_ASSIGN(SocketsTcpSecureFunction);
 263 };
 264
 265 }  // namespace api
 266 }  // namespace extensions
 267
 268 #endif  // EXTENSIONS_BROWSER_API_SOCKETS_TCP_SOCKETS_TCP_API_H_