Home | History | Annotate | Download | only in sockets_udp 
      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   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 SocketsUdpSetPausedFunction : public UDPSocketAsyncApiFunction {
     77  public:
     78   DECLARE_EXTENSION_FUNCTION("sockets.udp.setPaused", SOCKETS_UDP_SETPAUSED)
     79 
     80   SocketsUdpSetPausedFunction();
     81 
     82  protected:
     83   virtual ~SocketsUdpSetPausedFunction();
     84 
     85   // AsyncApiFunction
     86   virtual bool Prepare() OVERRIDE;
     87   virtual 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   virtual ~SocketsUdpBindFunction();
    102 
    103   // AsyncApiFunction:
    104   virtual bool Prepare() OVERRIDE;
    105   virtual void Work() 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   virtual ~SocketsUdpSendFunction();
    120 
    121   // AsyncApiFunction:
    122   virtual bool Prepare() OVERRIDE;
    123   virtual void AsyncWorkStart() OVERRIDE;
    124   void OnCompleted(int net_result);
    125   void SetSendResult(int net_result, int bytes_sent);
    126 
    127   // SocketExtensionWithDnsLookupFunction:
    128   virtual 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   virtual ~SocketsUdpCloseFunction();
    146 
    147   // AsyncApiFunction:
    148   virtual bool Prepare() OVERRIDE;
    149   virtual 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   virtual ~SocketsUdpGetInfoFunction();
    163 
    164   // AsyncApiFunction:
    165   virtual bool Prepare() OVERRIDE;
    166   virtual 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   virtual ~SocketsUdpGetSocketsFunction();
    180 
    181   // AsyncApiFunction:
    182   virtual bool Prepare() OVERRIDE;
    183   virtual 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   virtual ~SocketsUdpJoinGroupFunction();
    194 
    195   // AsyncApiFunction
    196   virtual bool Prepare() OVERRIDE;
    197   virtual 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   virtual ~SocketsUdpLeaveGroupFunction();
    211 
    212   // AsyncApiFunction
    213   virtual bool Prepare() OVERRIDE;
    214   virtual 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   virtual ~SocketsUdpSetMulticastTimeToLiveFunction();
    230 
    231   // AsyncApiFunction
    232   virtual bool Prepare() OVERRIDE;
    233   virtual 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   virtual ~SocketsUdpSetMulticastLoopbackModeFunction();
    249 
    250   // AsyncApiFunction
    251   virtual bool Prepare() OVERRIDE;
    252   virtual 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   virtual ~SocketsUdpGetJoinedGroupsFunction();
    267 
    268   // AsyncApiFunction
    269   virtual bool Prepare() OVERRIDE;
    270   virtual void Work() OVERRIDE;
    271 
    272  private:
    273   scoped_ptr<sockets_udp::GetJoinedGroups::Params> params_;
    274 };
    275 
    276 }  // namespace core_api
    277 }  // namespace extensions
    278 
    279 #endif  // EXTENSIONS_BROWSER_API_SOCKETS_UDP_SOCKETS_UDP_API_H_
    280