| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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_bool.h" | |
| 16 #include "ppapi/c/pp_completion_callback.h" | |
| 17 #include "ppapi/c/pp_errors.h" | |
| 18 | |
| 19 namespace ppapi { | |
| 20 | |
| 21 const int32_t UDPSocketPrivateImpl::kMaxReadSize = 1024 * 1024; | |
| 22 const int32_t UDPSocketPrivateImpl::kMaxWriteSize = 1024 * 1024; | |
| 23 | |
| 24 UDPSocketPrivateImpl::UDPSocketPrivateImpl(const HostResource& resource, | |
| 25 uint32 socket_id) | |
| 26 : Resource(OBJECT_IS_PROXY, resource) { | |
| 27 Init(socket_id); | |
| 28 } | |
| 29 | |
| 30 UDPSocketPrivateImpl::UDPSocketPrivateImpl(PP_Instance instance, | |
| 31 uint32 socket_id) | |
| 32 : Resource(OBJECT_IS_IMPL, instance) { | |
| 33 Init(socket_id); | |
| 34 } | |
| 35 | |
| 36 UDPSocketPrivateImpl::~UDPSocketPrivateImpl() { | |
| 37 } | |
| 38 | |
| 39 thunk::PPB_UDPSocket_Private_API* | |
| 40 UDPSocketPrivateImpl::AsPPB_UDPSocket_Private_API() { | |
| 41 return this; | |
| 42 } | |
| 43 | |
| 44 int32_t UDPSocketPrivateImpl::SetSocketFeature(PP_UDPSocketFeature_Private name, | |
| 45 PP_Var value) { | |
| 46 if (bound_ || closed_) | |
| 47 return PP_ERROR_FAILED; | |
| 48 | |
| 49 switch (name) { | |
| 50 case PP_UDPSOCKETFEATURE_ADDRESS_REUSE: | |
| 51 case PP_UDPSOCKETFEATURE_BROADCAST: | |
| 52 if (value.type != PP_VARTYPE_BOOL) | |
| 53 return PP_ERROR_BADARGUMENT; | |
| 54 SendBoolSocketFeature(static_cast<int32_t>(name), | |
| 55 PP_ToBool(value.value.as_bool)); | |
| 56 break; | |
| 57 default: | |
| 58 return PP_ERROR_BADARGUMENT; | |
| 59 } | |
| 60 return PP_OK; | |
| 61 } | |
| 62 | |
| 63 int32_t UDPSocketPrivateImpl::Bind(const PP_NetAddress_Private* addr, | |
| 64 scoped_refptr<TrackedCallback> callback) { | |
| 65 if (!addr) | |
| 66 return PP_ERROR_BADARGUMENT; | |
| 67 if (bound_ || closed_) | |
| 68 return PP_ERROR_FAILED; | |
| 69 if (TrackedCallback::IsPending(bind_callback_)) | |
| 70 return PP_ERROR_INPROGRESS; | |
| 71 | |
| 72 bind_callback_ = callback; | |
| 73 | |
| 74 // Send the request, the browser will call us back via BindACK. | |
| 75 SendBind(*addr); | |
| 76 return PP_OK_COMPLETIONPENDING; | |
| 77 } | |
| 78 | |
| 79 PP_Bool UDPSocketPrivateImpl::GetBoundAddress(PP_NetAddress_Private* addr) { | |
| 80 if (!addr || !bound_ || closed_) | |
| 81 return PP_FALSE; | |
| 82 | |
| 83 *addr = bound_addr_; | |
| 84 return PP_TRUE; | |
| 85 } | |
| 86 | |
| 87 int32_t UDPSocketPrivateImpl::RecvFrom( | |
| 88 char* buffer, | |
| 89 int32_t num_bytes, | |
| 90 scoped_refptr<TrackedCallback> callback) { | |
| 91 if (!buffer || num_bytes <= 0) | |
| 92 return PP_ERROR_BADARGUMENT; | |
| 93 if (!bound_) | |
| 94 return PP_ERROR_FAILED; | |
| 95 if (TrackedCallback::IsPending(recvfrom_callback_)) | |
| 96 return PP_ERROR_INPROGRESS; | |
| 97 | |
| 98 read_buffer_ = buffer; | |
| 99 bytes_to_read_ = std::min(num_bytes, kMaxReadSize); | |
| 100 recvfrom_callback_ = callback; | |
| 101 | |
| 102 // Send the request, the browser will call us back via RecvFromACK. | |
| 103 SendRecvFrom(bytes_to_read_); | |
| 104 return PP_OK_COMPLETIONPENDING; | |
| 105 } | |
| 106 | |
| 107 PP_Bool UDPSocketPrivateImpl::GetRecvFromAddress(PP_NetAddress_Private* addr) { | |
| 108 if (!addr) | |
| 109 return PP_FALSE; | |
| 110 | |
| 111 *addr = recvfrom_addr_; | |
| 112 return PP_TRUE; | |
| 113 } | |
| 114 | |
| 115 int32_t UDPSocketPrivateImpl::SendTo(const char* buffer, | |
| 116 int32_t num_bytes, | |
| 117 const PP_NetAddress_Private* addr, | |
| 118 scoped_refptr<TrackedCallback> callback) { | |
| 119 if (!buffer || num_bytes <= 0 || !addr) | |
| 120 return PP_ERROR_BADARGUMENT; | |
| 121 if (!bound_) | |
| 122 return PP_ERROR_FAILED; | |
| 123 if (TrackedCallback::IsPending(sendto_callback_)) | |
| 124 return PP_ERROR_INPROGRESS; | |
| 125 | |
| 126 if (num_bytes > kMaxWriteSize) | |
| 127 num_bytes = kMaxWriteSize; | |
| 128 | |
| 129 sendto_callback_ = callback; | |
| 130 | |
| 131 // Send the request, the browser will call us back via SendToACK. | |
| 132 SendSendTo(std::string(buffer, num_bytes), *addr); | |
| 133 return PP_OK_COMPLETIONPENDING; | |
| 134 } | |
| 135 | |
| 136 void UDPSocketPrivateImpl::Close() { | |
| 137 if(closed_) | |
| 138 return; | |
| 139 | |
| 140 bound_ = false; | |
| 141 closed_ = true; | |
| 142 | |
| 143 SendClose(); | |
| 144 | |
| 145 socket_id_ = 0; | |
| 146 | |
| 147 PostAbortIfNecessary(&bind_callback_); | |
| 148 PostAbortIfNecessary(&recvfrom_callback_); | |
| 149 PostAbortIfNecessary(&sendto_callback_); | |
| 150 } | |
| 151 | |
| 152 void UDPSocketPrivateImpl::OnBindCompleted( | |
| 153 bool succeeded, | |
| 154 const PP_NetAddress_Private& addr) { | |
| 155 if (!TrackedCallback::IsPending(bind_callback_)) { | |
| 156 NOTREACHED(); | |
| 157 return; | |
| 158 } | |
| 159 | |
| 160 if (succeeded) | |
| 161 bound_ = true; | |
| 162 | |
| 163 bound_addr_ = addr; | |
| 164 | |
| 165 bind_callback_->Run(succeeded ? PP_OK : PP_ERROR_FAILED); | |
| 166 } | |
| 167 | |
| 168 void UDPSocketPrivateImpl::OnRecvFromCompleted( | |
| 169 bool succeeded, | |
| 170 const std::string& data, | |
| 171 const PP_NetAddress_Private& addr) { | |
| 172 if (!TrackedCallback::IsPending(recvfrom_callback_) || !read_buffer_) { | |
| 173 NOTREACHED(); | |
| 174 return; | |
| 175 } | |
| 176 | |
| 177 if (succeeded) { | |
| 178 CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_); | |
| 179 if (!data.empty()) | |
| 180 memcpy(read_buffer_, data.c_str(), data.size()); | |
| 181 } | |
| 182 read_buffer_ = NULL; | |
| 183 bytes_to_read_ = -1; | |
| 184 recvfrom_addr_ = addr; | |
| 185 | |
| 186 recvfrom_callback_->Run(succeeded ? static_cast<int32_t>(data.size()) : | |
| 187 static_cast<int32_t>(PP_ERROR_FAILED)); | |
| 188 } | |
| 189 | |
| 190 void UDPSocketPrivateImpl::OnSendToCompleted(bool succeeded, | |
| 191 int32_t bytes_written) { | |
| 192 if (!TrackedCallback::IsPending(sendto_callback_)) { | |
| 193 NOTREACHED(); | |
| 194 return; | |
| 195 } | |
| 196 | |
| 197 sendto_callback_->Run( | |
| 198 succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED)); | |
| 199 } | |
| 200 | |
| 201 void UDPSocketPrivateImpl::Init(uint32 socket_id) { | |
| 202 DCHECK(socket_id != 0); | |
| 203 socket_id_ = socket_id; | |
| 204 bound_ = false; | |
| 205 closed_ = false; | |
| 206 read_buffer_ = NULL; | |
| 207 bytes_to_read_ = -1; | |
| 208 | |
| 209 recvfrom_addr_.size = 0; | |
| 210 memset(recvfrom_addr_.data, 0, | |
| 211 arraysize(recvfrom_addr_.data) * sizeof(*recvfrom_addr_.data)); | |
| 212 bound_addr_.size = 0; | |
| 213 memset(bound_addr_.data, 0, | |
| 214 arraysize(bound_addr_.data) * sizeof(*bound_addr_.data)); | |
| 215 } | |
| 216 | |
| 217 void UDPSocketPrivateImpl::PostAbortIfNecessary( | |
| 218 scoped_refptr<TrackedCallback>* callback) { | |
| 219 if (TrackedCallback::IsPending(*callback)) | |
| 220 (*callback)->PostAbort(); | |
| 221 } | |
| 222 | |
| 223 } // namespace ppapi | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 11441012:
PPB_UDPSocket_Private is switched to the new Pepper proxy. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src