Pepper: Allow plugins to call PPB_UDP_Socket::SendTo multiple times.

ppapi/proxy/udp_socket_resource_base.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/proxy/udp_socket_resource_base.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 namespace ppapi {
 namespace proxy {
 
 const int32_t UDPSocketResourceBase::kMaxReadSize = 128 * 1024;
 const int32_t UDPSocketResourceBase::kMaxWriteSize = 128 * 1024;
 const int32_t UDPSocketResourceBase::kMaxSendBufferSize =
     1024 * UDPSocketResourceBase::kMaxWriteSize;
 const int32_t UDPSocketResourceBase::kMaxReceiveBufferSize =
     1024 * UDPSocketResourceBase::kMaxReadSize;
 const size_t UDPSocketResourceBase::kPluginReceiveBufferSlots = 32u;
+const size_t UDPSocketResourceBase::kPluginSendBufferSlots = 8u;
 
 UDPSocketResourceBase::UDPSocketResourceBase(Connection connection,
                                              PP_Instance instance,
                                              bool private_api)
     : PluginResource(connection, instance),
       private_api_(private_api),
       bound_(false),
       closed_(false),
       read_buffer_(NULL),
       bytes_to_read_(-1),
@@ skipping 136 matching lines @@
 
 int32_t UDPSocketResourceBase::SendToImpl(
     const char* buffer,
     int32_t num_bytes,
     const PP_NetAddress_Private* addr,
     scoped_refptr<TrackedCallback> callback) {
   if (!buffer || num_bytes <= 0 || !addr)
     return PP_ERROR_BADARGUMENT;
   if (!bound_)
     return PP_ERROR_FAILED;
-  if (TrackedCallback::IsPending(sendto_callback_))
+  if (sendto_callbacks_.size() == kPluginSendBufferSlots)
     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 SendToReply.
   Call<PpapiPluginMsg_UDPSocket_SendToReply>(
       BROWSER,
       PpapiHostMsg_UDPSocket_SendTo(std::string(buffer, num_bytes), *addr),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgSendToReply,
                  base::Unretained(this)),
       callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void UDPSocketResourceBase::CloseImpl() {
   if(closed_)
     return;
 
   bound_ = false;
   closed_ = true;
 
   Post(BROWSER, PpapiHostMsg_UDPSocket_Close());
 
   PostAbortIfNecessary(&bind_callback_);
   PostAbortIfNecessary(&recvfrom_callback_);
-  PostAbortIfNecessary(&sendto_callback_);
+  while (!sendto_callbacks_.empty()) {
+    scoped_refptr<TrackedCallback> callback = sendto_callbacks_.front();
+    sendto_callbacks_.pop();
+    PostAbortIfNecessary(&callback);
+  }
 
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
 }
 
 void UDPSocketResourceBase::OnReplyReceived(
     const ResourceMessageReplyParams& params,
     const IPC::Message& msg) {
   PPAPI_BEGIN_MESSAGE_MAP(UDPSocketResourceBase, msg)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
@@ skipping 72 matching lines @@
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
   recvfrom_addr_resource_ = NULL;
 
   RunCallback(recvfrom_callback_, result);
 }
 
 void UDPSocketResourceBase::OnPluginMsgSendToReply(
     const ResourceMessageReplyParams& params,
     int32_t bytes_written) {
-  if (!TrackedCallback::IsPending(sendto_callback_))
+  scoped_refptr<TrackedCallback> callback = sendto_callbacks_.front();
+  sendto_callbacks_.pop();
+  if (!TrackedCallback::IsPending(callback))
     return;
 
   if (params.result() == PP_OK)
-    RunCallback(sendto_callback_, bytes_written);
+    RunCallback(callback, bytes_written);
   else
-    RunCallback(sendto_callback_, params.result());
+    RunCallback(callback, params.result());
 }
 
 void UDPSocketResourceBase::RunCallback(scoped_refptr<TrackedCallback> callback,
                                         int32_t pp_result) {
   callback->Run(ConvertNetworkAPIErrorForCompatibility(pp_result,
                                                        private_api_));
 }
 
 int32_t UDPSocketResourceBase::SetRecvFromOutput(
     int32_t browser_result,
@@ skipping 18 matching lines @@
   if (result == PP_OK && !data.empty())
     memcpy(output_buffer, data.c_str(), data.size());
 
   recvfrom_addr_ = addr;
 
   return result == PP_OK ? static_cast<int32_t>(data.size()) : result;
 }
 
 }  // namespace proxy
 }  // namespace ppapi