Added queued SendTo/RecvFrom calls.

ppapi/shared_impl/private/udp_socket_private_impl.cc

Index: ppapi/shared_impl/private/udp_socket_private_impl.cc
diff --git a/ppapi/shared_impl/private/udp_socket_private_impl.cc b/ppapi/shared_impl/private/udp_socket_private_impl.cc
index d3e94c1a48391352a3c5696ba18e3e9b953fbd08..cde0b2e7aaf469d1def041ce43f7f655c3012a33 100644
--- a/ppapi/shared_impl/private/udp_socket_private_impl.cc
+++ b/ppapi/shared_impl/private/udp_socket_private_impl.cc
@@ -92,15 +92,15 @@ int32_t UDPSocketPrivateImpl::RecvFrom(
     return PP_ERROR_BADARGUMENT;
   if (!bound_)
     return PP_ERROR_FAILED;
-  if (TrackedCallback::IsPending(recvfrom_callback_))
-    return PP_ERROR_INPROGRESS;
 
-  read_buffer_ = buffer;
-  bytes_to_read_ = std::min(num_bytes, kMaxReadSize);
-  recvfrom_callback_ = callback;
+  if (num_bytes > kMaxReadSize)
+    num_bytes = kMaxReadSize;
+  recvfrom_requests_.push(RecvFromRequest(callback,
+                                          buffer,
+                                          num_bytes));
 
   // Send the request, the browser will call us back via RecvFromACK.
-  SendRecvFrom(bytes_to_read_);
+  SendRecvFrom(num_bytes);
   return PP_OK_COMPLETIONPENDING;
 }
 
@@ -120,13 +120,11 @@ int32_t UDPSocketPrivateImpl::SendTo(const char* buffer,
     return PP_ERROR_BADARGUMENT;
   if (!bound_)
     return PP_ERROR_FAILED;
-  if (TrackedCallback::IsPending(sendto_callback_))
-    return PP_ERROR_INPROGRESS;
 
   if (num_bytes > kMaxWriteSize)
     num_bytes = kMaxWriteSize;
 
-  sendto_callback_ = callback;
+  sendto_callbacks_.push(callback);
 
   // Send the request, the browser will call us back via SendToACK.
   SendSendTo(std::string(buffer, num_bytes), *addr);
@@ -145,8 +143,16 @@ void UDPSocketPrivateImpl::Close() {
   socket_id_ = 0;
 
   PostAbortIfNecessary(&bind_callback_);
-  PostAbortIfNecessary(&recvfrom_callback_);
-  PostAbortIfNecessary(&sendto_callback_);
+  while (!recvfrom_requests_.empty()) {
+    RecvFromRequest recvfrom_callback = recvfrom_requests_.front();
+    recvfrom_requests_.pop();
+    PostAbortIfNecessary(&recvfrom_callback.callback);
+  }
+  while (!sendto_callbacks_.empty()) {
+    scoped_refptr<TrackedCallback> sendto_callback = sendto_callbacks_.front();
+    sendto_callbacks_.pop();
+    PostAbortIfNecessary(&sendto_callback);
+  }
 }
 
 void UDPSocketPrivateImpl::OnBindCompleted(
@@ -170,33 +176,43 @@ void UDPSocketPrivateImpl::OnRecvFromCompleted(
     bool succeeded,
     const std::string& data,
     const PP_NetAddress_Private& addr) {
-  if (!TrackedCallback::IsPending(recvfrom_callback_) || !read_buffer_) {
+  if (recvfrom_requests_.empty()) {
+    NOTREACHED();
+    return;
+  }
+
+  RecvFromRequest recvfrom_request = recvfrom_requests_.front();
+  recvfrom_requests_.pop();
+  if (!TrackedCallback::IsPending(recvfrom_request.callback)) {
     NOTREACHED();
     return;
   }
 
   if (succeeded) {
-    CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
+    CHECK_LE(static_cast<int32_t>(data.size()), recvfrom_request.num_bytes);
     if (!data.empty())
-      memcpy(read_buffer_, data.c_str(), data.size());
+      memcpy(recvfrom_request.buffer, data.c_str(), data.size());
   }
-  read_buffer_ = NULL;
-  bytes_to_read_ = -1;
   recvfrom_addr_ = addr;
 
-  TrackedCallback::ClearAndRun(&recvfrom_callback_,
+  TrackedCallback::ClearAndRun(&recvfrom_request.callback,
       succeeded ? static_cast<int32_t>(data.size()) :
       static_cast<int32_t>(PP_ERROR_FAILED));
 }
 
 void UDPSocketPrivateImpl::OnSendToCompleted(bool succeeded,
                                              int32_t bytes_written) {
-  if (!TrackedCallback::IsPending(sendto_callback_)) {
+  if (sendto_callbacks_.empty()) {
     NOTREACHED();
     return;
   }
-
-  TrackedCallback::ClearAndRun(&sendto_callback_,
+  scoped_refptr<TrackedCallback> callback = sendto_callbacks_.front();
+  sendto_callbacks_.pop();
+  if (!TrackedCallback::IsPending(callback)) {
+    NOTREACHED();
+    return;
+  }
+  TrackedCallback::ClearAndRun(&callback,
       succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED));
 }
 
@@ -205,8 +221,6 @@ void UDPSocketPrivateImpl::Init(uint32 socket_id) {
   socket_id_ = socket_id;
   bound_ = false;
   closed_ = false;
-  read_buffer_ = NULL;
-  bytes_to_read_ = -1;
 
   recvfrom_addr_.size = 0;
   memset(recvfrom_addr_.data, 0,