• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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