src/chrome/browser/extensions/api/sockets_udp/sockets_udp_api.h

   1 // Copyright 2013 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_SOCKETS_UDP_SOCKETS_UDP_API_H_
   6 #define CHROME_BROWSER_EXTENSIONS_API_SOCKETS_UDP_SOCKETS_UDP_API_H_
   7
   8 #include "chrome/browser/extensions/api/socket/socket_api.h"
   9 #include "chrome/common/extensions/api/sockets_udp.h"
  10
  11 namespace extensions {
  12 class ResumableUDPSocket;
  13 }
  14
  15 namespace extensions {
  16 namespace api {
  17
  18 class UDPSocketEventDispatcher;
  19
  20 class UDPSocketAsyncApiFunction : public SocketAsyncApiFunction {
  21  protected:
  22   virtual ~UDPSocketAsyncApiFunction();
  23
  24   virtual scoped_ptr<SocketResourceManagerInterface>
  25       CreateSocketResourceManager() OVERRIDE;
  26
  27   ResumableUDPSocket* GetUdpSocket(int socket_id);
  28 };
  29
  30 class UDPSocketExtensionWithDnsLookupFunction
  31     : public SocketExtensionWithDnsLookupFunction {
  32  protected:
  33   virtual ~UDPSocketExtensionWithDnsLookupFunction();
  34
  35   virtual scoped_ptr<SocketResourceManagerInterface>
  36       CreateSocketResourceManager() 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   virtual ~SocketsUdpCreateFunction();
  49
  50   // AsyncApiFunction:
  51   virtual bool Prepare() OVERRIDE;
  52   virtual 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   virtual ~SocketsUdpUpdateFunction();
  67
  68   // AsyncApiFunction:
  69   virtual bool Prepare() OVERRIDE;
  70   virtual void Work() OVERRIDE;
  71
  72  private:
  73   scoped_ptr<sockets_udp::Update::Params> params_;
  74 };
  75
  76 class SocketsUdpBindFunction : public UDPSocketAsyncApiFunction {
  77  public:
  78   DECLARE_EXTENSION_FUNCTION("sockets.udp.bind", SOCKETS_UDP_BIND)
  79
  80   SocketsUdpBindFunction();
  81
  82  protected:
  83   virtual ~SocketsUdpBindFunction();
  84
  85   // AsyncApiFunction:
  86   virtual bool Prepare() OVERRIDE;
  87   virtual void Work() OVERRIDE;
  88
  89  private:
  90   scoped_ptr<sockets_udp::Bind::Params> params_;
  91   UDPSocketEventDispatcher* socket_event_dispatcher_;
  92 };
  93
  94 class SocketsUdpSendFunction : public UDPSocketExtensionWithDnsLookupFunction {
  95  public:
  96   DECLARE_EXTENSION_FUNCTION("sockets.udp.send", SOCKETS_UDP_SEND)
  97
  98   SocketsUdpSendFunction();
  99
 100  protected:
 101   virtual ~SocketsUdpSendFunction();
 102
 103   // AsyncApiFunction:
 104   virtual bool Prepare() OVERRIDE;
 105   virtual void AsyncWorkStart() OVERRIDE;
 106   void OnCompleted(int net_result);
 107   void SetSendResult(int net_result, int bytes_sent);
 108
 109   // SocketExtensionWithDnsLookupFunction:
 110   virtual void AfterDnsLookup(int lookup_result) OVERRIDE;
 111
 112  private:
 113   void StartSendTo();
 114
 115   scoped_ptr<sockets_udp::Send::Params> params_;
 116   scoped_refptr<net::IOBuffer> io_buffer_;
 117   size_t io_buffer_size_;
 118 };
 119
 120 class SocketsUdpCloseFunction : public UDPSocketAsyncApiFunction {
 121  public:
 122   DECLARE_EXTENSION_FUNCTION("sockets.udp.close", SOCKETS_UDP_CLOSE)
 123
 124   SocketsUdpCloseFunction();
 125
 126  protected:
 127   virtual ~SocketsUdpCloseFunction();
 128
 129   // AsyncApiFunction:
 130   virtual bool Prepare() OVERRIDE;
 131   virtual void Work() OVERRIDE;
 132
 133  private:
 134   scoped_ptr<sockets_udp::Close::Params> params_;
 135 };
 136
 137 class SocketsUdpGetInfoFunction : public UDPSocketAsyncApiFunction {
 138  public:
 139   DECLARE_EXTENSION_FUNCTION("sockets.udp.getInfo", SOCKETS_UDP_GETINFO)
 140
 141   SocketsUdpGetInfoFunction();
 142
 143  protected:
 144   virtual ~SocketsUdpGetInfoFunction();
 145
 146   // AsyncApiFunction:
 147   virtual bool Prepare() OVERRIDE;
 148   virtual void Work() OVERRIDE;
 149
 150  private:
 151   scoped_ptr<sockets_udp::GetInfo::Params> params_;
 152 };
 153
 154 class SocketsUdpGetSocketsFunction : public UDPSocketAsyncApiFunction {
 155  public:
 156   DECLARE_EXTENSION_FUNCTION("sockets.udp.getSockets", SOCKETS_UDP_GETSOCKETS)
 157
 158   SocketsUdpGetSocketsFunction();
 159
 160  protected:
 161   virtual ~SocketsUdpGetSocketsFunction();
 162
 163   // AsyncApiFunction:
 164   virtual bool Prepare() OVERRIDE;
 165   virtual void Work() OVERRIDE;
 166 };
 167
 168 class SocketsUdpJoinGroupFunction : public UDPSocketAsyncApiFunction {
 169  public:
 170   DECLARE_EXTENSION_FUNCTION("sockets.udp.joinGroup", SOCKETS_UDP_JOINGROUP)
 171
 172   SocketsUdpJoinGroupFunction();
 173
 174  protected:
 175   virtual ~SocketsUdpJoinGroupFunction();
 176
 177   // AsyncApiFunction
 178   virtual bool Prepare() OVERRIDE;
 179   virtual void Work() OVERRIDE;
 180
 181  private:
 182   scoped_ptr<sockets_udp::JoinGroup::Params> params_;
 183 };
 184
 185 class SocketsUdpLeaveGroupFunction : public UDPSocketAsyncApiFunction {
 186  public:
 187   DECLARE_EXTENSION_FUNCTION("sockets.udp.leaveGroup", SOCKETS_UDP_LEAVEGROUP)
 188
 189   SocketsUdpLeaveGroupFunction();
 190
 191  protected:
 192   virtual ~SocketsUdpLeaveGroupFunction();
 193
 194   // AsyncApiFunction
 195   virtual bool Prepare() OVERRIDE;
 196   virtual void Work() OVERRIDE;
 197
 198  private:
 199   scoped_ptr<sockets_udp::LeaveGroup::Params> params_;
 200 };
 201
 202 class SocketsUdpSetMulticastTimeToLiveFunction
 203     : public UDPSocketAsyncApiFunction {
 204  public:
 205   DECLARE_EXTENSION_FUNCTION("sockets.udp.setMulticastTimeToLive",
 206                              SOCKETS_UDP_SETMULTICASTTIMETOLIVE)
 207
 208   SocketsUdpSetMulticastTimeToLiveFunction();
 209
 210  protected:
 211   virtual ~SocketsUdpSetMulticastTimeToLiveFunction();
 212
 213   // AsyncApiFunction
 214   virtual bool Prepare() OVERRIDE;
 215   virtual void Work() OVERRIDE;
 216
 217  private:
 218   scoped_ptr<sockets_udp::SetMulticastTimeToLive::Params> params_;
 219 };
 220
 221 class SocketsUdpSetMulticastLoopbackModeFunction
 222     : public UDPSocketAsyncApiFunction {
 223  public:
 224   DECLARE_EXTENSION_FUNCTION("sockets.udp.setMulticastLoopbackMode",
 225                              SOCKETS_UDP_SETMULTICASTLOOPBACKMODE)
 226
 227   SocketsUdpSetMulticastLoopbackModeFunction();
 228
 229  protected:
 230   virtual ~SocketsUdpSetMulticastLoopbackModeFunction();
 231
 232   // AsyncApiFunction
 233   virtual bool Prepare() OVERRIDE;
 234   virtual void Work() OVERRIDE;
 235
 236  private:
 237   scoped_ptr<sockets_udp::SetMulticastLoopbackMode::Params> params_;
 238 };
 239
 240 class SocketsUdpGetJoinedGroupsFunction : public UDPSocketAsyncApiFunction {
 241  public:
 242   DECLARE_EXTENSION_FUNCTION("sockets.udp.getJoinedGroups",
 243                              SOCKETS_UDP_GETJOINEDGROUPS)
 244
 245   SocketsUdpGetJoinedGroupsFunction();
 246
 247  protected:
 248   virtual ~SocketsUdpGetJoinedGroupsFunction();
 249
 250   // AsyncApiFunction
 251   virtual bool Prepare() OVERRIDE;
 252   virtual void Work() OVERRIDE;
 253
 254  private:
 255   scoped_ptr<sockets_udp::GetJoinedGroups::Params> params_;
 256 };
 257
 258 }  // namespace api
 259 }  // namespace extensions
 260
 261 #endif  // CHROME_BROWSER_EXTENSIONS_API_SOCKETS_UDP_SOCKETS_UDP_API_H_