Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(515)

Side by Side Diff: ppapi/shared_impl/private/udp_socket_private_impl.cc

Issue 8804006: Reland 8688002: PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Browser (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix destruction issue Created 9 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright (c) 2011 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 #include "ppapi/shared_impl/private/udp_socket_private_impl.h"
6
7 #include <string.h>
8
9 #include <algorithm>
10
11 #include "base/basictypes.h"
12 #include "base/bind.h"
13 #include "base/logging.h"
14 #include "base/message_loop.h"
15 #include "ppapi/c/pp_completion_callback.h"
16 #include "ppapi/c/pp_errors.h"
17
18 namespace ppapi {
19
20 namespace {
21
22 void AbortCallback(PP_CompletionCallback callback) {
23 PP_RunCompletionCallback(&callback, PP_ERROR_ABORTED);
24 }
25
26 } // namespace
27
28 const int32_t UDPSocketPrivateImpl::kMaxReadSize = 1024 * 1024;
29 const int32_t UDPSocketPrivateImpl::kMaxWriteSize = 1024 * 1024;
30
31 UDPSocketPrivateImpl::UDPSocketPrivateImpl(const HostResource& resource,
32 uint32 socket_id)
33 : Resource(resource) {
34 Init(socket_id);
35 }
36
37 UDPSocketPrivateImpl::UDPSocketPrivateImpl(PP_Instance instance,
38 uint32 socket_id)
39 : Resource(instance) {
40 Init(socket_id);
41 }
42
43 UDPSocketPrivateImpl::~UDPSocketPrivateImpl() {
44 }
45
46 thunk::PPB_UDPSocket_Private_API*
47 UDPSocketPrivateImpl::AsPPB_UDPSocket_Private_API() {
48 return this;
49 }
50
51 int32_t UDPSocketPrivateImpl::Bind(const PP_NetAddress_Private* addr,
52 PP_CompletionCallback callback) {
53 if (!addr || !callback.func)
54 return PP_ERROR_BADARGUMENT;
55 if (bound_ || closed_)
56 return PP_ERROR_FAILED;
57 if (bind_callback_.func)
58 return PP_ERROR_INPROGRESS;
59 // TODO(dmichael): use some other strategy for determining if an
60 // operation is in progress
61
62 bind_callback_ = callback;
63
64 // Send the request, the browser will call us back via BindACK.
65 SendBind(*addr);
66 return PP_OK_COMPLETIONPENDING;
67 }
68
69 int32_t UDPSocketPrivateImpl::RecvFrom(char* buffer,
70 int32_t num_bytes,
71 PP_CompletionCallback callback) {
72 if (!buffer || num_bytes <= 0 || !callback.func)
73 return PP_ERROR_BADARGUMENT;
74 if (!bound_)
75 return PP_ERROR_FAILED;
76 if (recvfrom_callback_.func)
77 return PP_ERROR_INPROGRESS;
78
79 read_buffer_ = buffer;
80 bytes_to_read_ = std::min(num_bytes, kMaxReadSize);
81 recvfrom_callback_ = callback;
82
83 // Send the request, the browser will call us back via RecvFromACK.
84 SendRecvFrom(bytes_to_read_);
85 return PP_OK_COMPLETIONPENDING;
86 }
87
88 PP_Bool UDPSocketPrivateImpl::GetRecvFromAddress(PP_NetAddress_Private* addr) {
89 if (!addr)
90 return PP_FALSE;
91
92 *addr = recvfrom_addr_;
93 return PP_TRUE;
94 }
95
96 int32_t UDPSocketPrivateImpl::SendTo(const char* buffer,
97 int32_t num_bytes,
98 const PP_NetAddress_Private* addr,
99 PP_CompletionCallback callback) {
100 if (!buffer || num_bytes <= 0 || !addr || !callback.func)
101 return PP_ERROR_BADARGUMENT;
102 if (!bound_)
103 return PP_ERROR_FAILED;
104 if (sendto_callback_.func)
105 return PP_ERROR_INPROGRESS;
106
107 if (num_bytes > kMaxWriteSize)
108 num_bytes = kMaxWriteSize;
109
110 sendto_callback_ = callback;
111
112 // Send the request, the browser will call us back via SendToACK.
113 SendSendTo(std::string(buffer, num_bytes), *addr);
114 return PP_OK_COMPLETIONPENDING;
115 }
116
117 void UDPSocketPrivateImpl::Close() {
118 if(closed_)
119 return;
120
121 bound_ = false;
122 closed_ = true;
123
124 SendClose();
125
126 socket_id_ = 0;
127
128 PostAbortAndClearIfNecessary(&bind_callback_);
129 PostAbortAndClearIfNecessary(&recvfrom_callback_);
130 PostAbortAndClearIfNecessary(&sendto_callback_);
131 }
132
133 void UDPSocketPrivateImpl::OnBindCompleted(bool succeeded) {
134 if (!bind_callback_.func) {
135 NOTREACHED();
136 return;
137 }
138
139 if (succeeded)
140 bound_ = true;
141
142 PP_RunAndClearCompletionCallback(&bind_callback_,
143 succeeded ? PP_OK : PP_ERROR_FAILED);
144 }
145
146 void UDPSocketPrivateImpl::OnRecvFromCompleted(
147 bool succeeded,
148 const std::string& data,
149 const PP_NetAddress_Private& addr) {
150 if (!recvfrom_callback_.func || !read_buffer_) {
151 NOTREACHED();
152 return;
153 }
154
155 if (succeeded) {
156 CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
157 if (!data.empty())
158 memcpy(read_buffer_, data.c_str(), data.size());
159 }
160 read_buffer_ = NULL;
161 bytes_to_read_ = -1;
162 recvfrom_addr_ = addr;
163
164 PP_RunAndClearCompletionCallback(
165 &recvfrom_callback_,
166 succeeded ? static_cast<int32_t>(data.size()) :
167 static_cast<int32_t>(PP_ERROR_FAILED));
168 }
169
170 void UDPSocketPrivateImpl::OnSendToCompleted(bool succeeded,
171 int32_t bytes_written) {
172 if (!sendto_callback_.func) {
173 NOTREACHED();
174 return;
175 }
176
177 PP_RunAndClearCompletionCallback(
178 &sendto_callback_,
179 succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED));
180 }
181
182 void UDPSocketPrivateImpl::Init(uint32 socket_id) {
183 DCHECK(socket_id != 0);
184 socket_id_ = socket_id;
185 bound_ = false;
186 closed_ = false;
187 bind_callback_ = PP_BlockUntilComplete();
188 recvfrom_callback_ = PP_BlockUntilComplete();
189 sendto_callback_ = PP_BlockUntilComplete();
190 read_buffer_ = NULL;
191 bytes_to_read_ = -1;
192
193 recvfrom_addr_.size = 0;
194 memset(recvfrom_addr_.data, 0,
195 arraysize(recvfrom_addr_.data) * sizeof(*recvfrom_addr_.data));
196 }
197
198 void UDPSocketPrivateImpl::PostAbortAndClearIfNecessary(
199 PP_CompletionCallback* callback) {
200 DCHECK(callback);
201
202 if (callback->func) {
203 MessageLoop::current()->PostTask(FROM_HERE,
204 base::Bind(&AbortCallback, *callback));
205 *callback = PP_BlockUntilComplete();
206 }
207 }
208
209 } // namespace ppapi
OLDNEW
« no previous file with comments | « ppapi/shared_impl/private/udp_socket_private_impl.h ('k') | ppapi/tests/test_tcp_socket_private_shared.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698