extensions/browser/api/sockets_udp/sockets_udp_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_UDP_SOCKETS_UDP_API_H_
   6 #define EXTENSIONS_BROWSER_API_SOCKETS_UDP_SOCKETS_UDP_API_H_
   7
   8 #include "extensions/browser/api/socket/socket_api.h"
   9 #include "extensions/common/api/sockets_udp.h"
  10
  11 namespace extensions {
  12 class ResumableUDPSocket;
  13 }
  14
  15 namespace extensions {
  16 namespace core_api {
  17
  18 class UDPSocketEventDispatcher;
  19
  20 class UDPSocketAsyncApiFunction : public SocketAsyncApiFunction {
  21  protected:
  22   ~UDPSocketAsyncApiFunction() override;
  23
  24   scoped_ptr<SocketResourceManagerInterface> CreateSocketResourceManager()
  25       override;
  26
  27   ResumableUDPSocket* GetUdpSocket(int socket_id);
  28 };
  29
  30 class UDPSocketExtensionWithDnsLookupFunction
  31     : public SocketExtensionWithDnsLookupFunction {
  32  protected:
  33   ~UDPSocketExtensionWithDnsLookupFunction() override;
  34
  35   scoped_ptr<SocketResourceManagerInterface> CreateSocketResourceManager()
  36       override;
  37
  38   ResumableUDPSocket* GetUdpSocket(int socket_id);
  39 };
  40
  41 class SocketsUdpCreateFunction : public UDPSocketAsyncApiFunction {
  42  public:
  43   DECLARE_EXTENSION_FUNCTION("sockets.udp.create", SOCKETS_UDP_CREATE)
  44
  45   SocketsUdpCreateFunction();
  46
  47  protected:
  48   ~SocketsUdpCreateFunction() override;
  49
  50   // AsyncApiFunction:
  51   bool Prepare() override;
  52   void Work() override;
  53
  54  private:
  55   FRIEND_TEST_ALL_PREFIXES(SocketsUdpUnitTest, Create);
  56   scoped_ptr<sockets_udp::Create::Params> params_;
  57 };
  58
  59 class SocketsUdpUpdateFunction : public UDPSocketAsyncApiFunction {
  60  public:
  61   DECLARE_EXTENSION_FUNCTION("sockets.udp.update", SOCKETS_UDP_UPDATE)
  62
  63   SocketsUdpUpdateFunction();
  64
  65  protected:
  66   ~SocketsUdpUpdateFunction() override;
  67
  68   // AsyncApiFunction:
  69   bool Prepare() override;
  70   void Work() override;
  71
  72  private:
  73   scoped_ptr<sockets_udp::Update::Params> params_;
  74 };
  75
  76 class SocketsUdpSetPausedFunction : public UDPSocketAsyncApiFunction {
  77  public:
  78   DECLARE_EXTENSION_FUNCTION("sockets.udp.setPaused", SOCKETS_UDP_SETPAUSED)
  79
  80   SocketsUdpSetPausedFunction();
  81
  82  protected:
  83   ~SocketsUdpSetPausedFunction() override;
  84
  85   // AsyncApiFunction
  86   bool Prepare() override;
  87   void Work() override;
  88
  89  private:
  90   scoped_ptr<sockets_udp::SetPaused::Params> params_;
  91   UDPSocketEventDispatcher* socket_event_dispatcher_;
  92 };
  93
  94 class SocketsUdpBindFunction : public UDPSocketAsyncApiFunction {
  95  public:
  96   DECLARE_EXTENSION_FUNCTION("sockets.udp.bind", SOCKETS_UDP_BIND)
  97
  98   SocketsUdpBindFunction();
  99
 100  protected:
 101   ~SocketsUdpBindFunction() override;
 102
 103   // AsyncApiFunction:
 104   bool Prepare() override;
 105   void AsyncWorkStart() override;
 106
 107  private:
 108   scoped_ptr<sockets_udp::Bind::Params> params_;
 109   UDPSocketEventDispatcher* socket_event_dispatcher_;
 110 };
 111
 112 class SocketsUdpSendFunction : public UDPSocketExtensionWithDnsLookupFunction {
 113  public:
 114   DECLARE_EXTENSION_FUNCTION("sockets.udp.send", SOCKETS_UDP_SEND)
 115
 116   SocketsUdpSendFunction();
 117
 118  protected:
 119   ~SocketsUdpSendFunction() override;
 120
 121   // AsyncApiFunction:
 122   bool Prepare() override;
 123   void AsyncWorkStart() override;
 124   void OnCompleted(int net_result);
 125   void SetSendResult(int net_result, int bytes_sent);
 126
 127   // SocketExtensionWithDnsLookupFunction:
 128   void AfterDnsLookup(int lookup_result) override;
 129
 130  private:
 131   void StartSendTo();
 132
 133   scoped_ptr<sockets_udp::Send::Params> params_;
 134   scoped_refptr<net::IOBuffer> io_buffer_;
 135   size_t io_buffer_size_;
 136 };
 137
 138 class SocketsUdpCloseFunction : public UDPSocketAsyncApiFunction {
 139  public:
 140   DECLARE_EXTENSION_FUNCTION("sockets.udp.close", SOCKETS_UDP_CLOSE)
 141
 142   SocketsUdpCloseFunction();
 143
 144  protected:
 145   ~SocketsUdpCloseFunction() override;
 146
 147   // AsyncApiFunction:
 148   bool Prepare() override;
 149   void Work() override;
 150
 151  private:
 152   scoped_ptr<sockets_udp::Close::Params> params_;
 153 };
 154
 155 class SocketsUdpGetInfoFunction : public UDPSocketAsyncApiFunction {
 156  public:
 157   DECLARE_EXTENSION_FUNCTION("sockets.udp.getInfo", SOCKETS_UDP_GETINFO)
 158
 159   SocketsUdpGetInfoFunction();
 160
 161  protected:
 162   ~SocketsUdpGetInfoFunction() override;
 163
 164   // AsyncApiFunction:
 165   bool Prepare() override;
 166   void Work() override;
 167
 168  private:
 169   scoped_ptr<sockets_udp::GetInfo::Params> params_;
 170 };
 171
 172 class SocketsUdpGetSocketsFunction : public UDPSocketAsyncApiFunction {
 173  public:
 174   DECLARE_EXTENSION_FUNCTION("sockets.udp.getSockets", SOCKETS_UDP_GETSOCKETS)
 175
 176   SocketsUdpGetSocketsFunction();
 177
 178  protected:
 179   ~SocketsUdpGetSocketsFunction() override;
 180
 181   // AsyncApiFunction:
 182   bool Prepare() override;
 183   void Work() override;
 184 };
 185
 186 class SocketsUdpJoinGroupFunction : public UDPSocketAsyncApiFunction {
 187  public:
 188   DECLARE_EXTENSION_FUNCTION("sockets.udp.joinGroup", SOCKETS_UDP_JOINGROUP)
 189
 190   SocketsUdpJoinGroupFunction();
 191
 192  protected:
 193   ~SocketsUdpJoinGroupFunction() override;
 194
 195   // AsyncApiFunction
 196   bool Prepare() override;
 197   void Work() override;
 198
 199  private:
 200   scoped_ptr<sockets_udp::JoinGroup::Params> params_;
 201 };
 202
 203 class SocketsUdpLeaveGroupFunction : public UDPSocketAsyncApiFunction {
 204  public:
 205   DECLARE_EXTENSION_FUNCTION("sockets.udp.leaveGroup", SOCKETS_UDP_LEAVEGROUP)
 206
 207   SocketsUdpLeaveGroupFunction();
 208
 209  protected:
 210   ~SocketsUdpLeaveGroupFunction() override;
 211
 212   // AsyncApiFunction
 213   bool Prepare() override;
 214   void Work() override;
 215
 216  private:
 217   scoped_ptr<sockets_udp::LeaveGroup::Params> params_;
 218 };
 219
 220 class SocketsUdpSetMulticastTimeToLiveFunction
 221     : public UDPSocketAsyncApiFunction {
 222  public:
 223   DECLARE_EXTENSION_FUNCTION("sockets.udp.setMulticastTimeToLive",
 224                              SOCKETS_UDP_SETMULTICASTTIMETOLIVE)
 225
 226   SocketsUdpSetMulticastTimeToLiveFunction();
 227
 228  protected:
 229   ~SocketsUdpSetMulticastTimeToLiveFunction() override;
 230
 231   // AsyncApiFunction
 232   bool Prepare() override;
 233   void Work() override;
 234
 235  private:
 236   scoped_ptr<sockets_udp::SetMulticastTimeToLive::Params> params_;
 237 };
 238
 239 class SocketsUdpSetMulticastLoopbackModeFunction
 240     : public UDPSocketAsyncApiFunction {
 241  public:
 242   DECLARE_EXTENSION_FUNCTION("sockets.udp.setMulticastLoopbackMode",
 243                              SOCKETS_UDP_SETMULTICASTLOOPBACKMODE)
 244
 245   SocketsUdpSetMulticastLoopbackModeFunction();
 246
 247  protected:
 248   ~SocketsUdpSetMulticastLoopbackModeFunction() override;
 249
 250   // AsyncApiFunction
 251   bool Prepare() override;
 252   void Work() override;
 253
 254  private:
 255   scoped_ptr<sockets_udp::SetMulticastLoopbackMode::Params> params_;
 256 };
 257
 258 class SocketsUdpGetJoinedGroupsFunction : public UDPSocketAsyncApiFunction {
 259  public:
 260   DECLARE_EXTENSION_FUNCTION("sockets.udp.getJoinedGroups",
 261                              SOCKETS_UDP_GETJOINEDGROUPS)
 262
 263   SocketsUdpGetJoinedGroupsFunction();
 264
 265  protected:
 266   ~SocketsUdpGetJoinedGroupsFunction() override;
 267
 268   // AsyncApiFunction
 269   bool Prepare() override;
 270   void Work() override;
 271
 272  private:
 273   scoped_ptr<sockets_udp::GetJoinedGroups::Params> params_;
 274 };
 275
 276 class SocketsUdpSetBroadcastFunction : public UDPSocketAsyncApiFunction {
 277  public:
 278   DECLARE_EXTENSION_FUNCTION("sockets.udp.setBroadcast",
 279                              SOCKETS_UDP_SETBROADCAST)
 280
 281   SocketsUdpSetBroadcastFunction();
 282
 283  protected:
 284   ~SocketsUdpSetBroadcastFunction() override;
 285
 286   // AsyncApiFunction
 287   bool Prepare() override;
 288   void Work() override;
 289
 290  private:
 291   scoped_ptr<sockets_udp::SetBroadcast::Params> params_;
 292 };
 293
 294 }  // namespace core_api
 295 }  // namespace extensions
 296
 297 #endif  // EXTENSIONS_BROWSER_API_SOCKETS_UDP_SOCKETS_UDP_API_H_