Added queued SendTo/RecvFrom calls.

content/browser/renderer_host/pepper/pepper_udp_socket.cc

Index: content/browser/renderer_host/pepper/pepper_udp_socket.cc
diff --git a/content/browser/renderer_host/pepper/pepper_udp_socket.cc b/content/browser/renderer_host/pepper/pepper_udp_socket.cc
index fdb2c5e0e3d515dcca8c6bd91582391bc0ff42b0..21db212ce3b5d46331a7e90e56514b69c0dd1ebc 100644
--- a/content/browser/renderer_host/pepper/pepper_udp_socket.cc
+++ b/content/browser/renderer_host/pepper/pepper_udp_socket.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2012 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.
 
@@ -10,7 +10,6 @@
 #include "base/logging.h"
 #include "content/browser/renderer_host/pepper/pepper_message_filter.h"
 #include "content/public/browser/browser_thread.h"
-#include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/udp/udp_server_socket.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ -29,7 +28,9 @@ PepperUDPSocket::PepperUDPSocket(
       plugin_dispatcher_id_(plugin_dispatcher_id),
       socket_id_(socket_id),
       allow_address_reuse_(false),
-      allow_broadcast_(false) {
+      allow_broadcast_(false),
+      recvfrom_state_(IO_STATE_IDLE),
+      sendto_state_(IO_STATE_IDLE) {
   DCHECK(manager);
 }
 
@@ -75,24 +76,15 @@ void PepperUDPSocket::Bind(const PP_NetAddress_Private& addr) {
 }
 
 void PepperUDPSocket::RecvFrom(int32_t num_bytes) {
-  if (recvfrom_buffer_.get()) {
-    SendRecvFromACKError();
-    return;
-  }
-
-  recvfrom_buffer_ = new net::IOBuffer(num_bytes);
-  int result = socket_->RecvFrom(
-      recvfrom_buffer_, num_bytes, &recvfrom_address_,
-      base::Bind(&PepperUDPSocket::OnRecvFromCompleted,
-                 base::Unretained(this)));
-
-  if (result != net::ERR_IO_PENDING)
-    OnRecvFromCompleted(result);
+  scoped_refptr<net::IOBuffer> recvfrom_buffer(new net::IOBuffer(num_bytes));
+  linked_ptr<net::IPEndPoint> end_point(new net::IPEndPoint());
+  recvfrom_requests_.push(IORequest(recvfrom_buffer, num_bytes, end_point));
+  RecvFromInternal();
 }
 
 void PepperUDPSocket::SendTo(const std::string& data,
                              const PP_NetAddress_Private& addr) {
-  if (sendto_buffer_.get() || data.empty()) {
+  if (data.empty()) {
     SendSendToACKError();
     return;
   }
@@ -105,15 +97,11 @@ void PepperUDPSocket::SendTo(const std::string& data,
   }
 
   int data_size = data.size();
-
-  sendto_buffer_ = new net::IOBuffer(data_size);
-  memcpy(sendto_buffer_->data(), data.data(), data_size);
-  int result = socket_->SendTo(
-      sendto_buffer_, data_size, net::IPEndPoint(address, port),
-      base::Bind(&PepperUDPSocket::OnSendToCompleted, base::Unretained(this)));
-
-  if (result != net::ERR_IO_PENDING)
-    OnSendToCompleted(result);
+  scoped_refptr<net::IOBuffer> sendto_buffer(new net::IOBuffer(data_size));
+  memcpy(sendto_buffer->data(), data.data(), data_size);
+  linked_ptr<net::IPEndPoint> end_point(new net::IPEndPoint(address, port));
+  sendto_requests_.push(IORequest(sendto_buffer, data_size, end_point));
+  SendToInternal();
 }
 
 void PepperUDPSocket::SendRecvFromACKError() {
@@ -134,6 +122,36 @@ void PepperUDPSocket::SendBindACKError() {
       routing_id_, plugin_dispatcher_id_, socket_id_, false, addr));
 }
 
+void PepperUDPSocket::RecvFromInternal() {
+  if (recvfrom_requests_.empty() || recvfrom_state_ != IO_STATE_IDLE)
+    return;
+  recvfrom_state_ = IO_STATE_IN_PROCESS;
+  IORequest request = recvfrom_requests_.front();
+  int result = socket_->RecvFrom(
+      request.buffer.get(),
+      request.buffer_size,
+      request.end_point.get(),
+      base::Bind(&PepperUDPSocket::OnRecvFromCompleted,
+                 base::Unretained(this)));
+  if (result != net::ERR_IO_PENDING)
+    OnRecvFromCompleted(result);
+}
+
+void PepperUDPSocket::SendToInternal() {
+  if (sendto_requests_.empty() || sendto_state_ != IO_STATE_IDLE)
+    return;
+  sendto_state_ = IO_STATE_IN_PROCESS;
+  IORequest request = sendto_requests_.front();
+  int result = socket_->SendTo(
+      request.buffer.get(),
+      request.buffer_size,
+      *request.end_point,
+      base::Bind(&PepperUDPSocket::OnSendToCompleted,
+                 base::Unretained(this)));
+  if (result != net::ERR_IO_PENDING)
+    OnSendToCompleted(result);
+}
+
 void PepperUDPSocket::OnBindCompleted(int result) {
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
   if (result < 0 ||
@@ -148,28 +166,36 @@ void PepperUDPSocket::OnBindCompleted(int result) {
 }
 
 void PepperUDPSocket::OnRecvFromCompleted(int result) {
-  DCHECK(recvfrom_buffer_.get());
+  DCHECK(!recvfrom_requests_.empty());
+  DCHECK(recvfrom_state_ == IO_STATE_IN_PROCESS);
+
+  IORequest request = recvfrom_requests_.front();
 
   // Convert IPEndPoint we get back from RecvFrom to a PP_NetAddress_Private,
   // to send back.
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
   if (result < 0 ||
       !NetAddressPrivateImpl::IPEndPointToNetAddress(
-          recvfrom_address_.address(),
-          recvfrom_address_.port(),
+          request.end_point->address(),
+          request.end_point->port(),
           &addr)) {
     SendRecvFromACKError();
   } else {
     manager_->Send(new PpapiMsg_PPBUDPSocket_RecvFromACK(
         routing_id_, plugin_dispatcher_id_, socket_id_, true,
-        std::string(recvfrom_buffer_->data(), result), addr));
+        std::string(request.buffer->data(), result), addr));
   }
 
-  recvfrom_buffer_ = NULL;
+  recvfrom_requests_.pop();
+  recvfrom_state_ = IO_STATE_IDLE;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&PepperUDPSocket::RecvFromInternal,
+                 base::Unretained(this)));
 }
 
 void PepperUDPSocket::OnSendToCompleted(int result) {
-  DCHECK(sendto_buffer_.get());
+  DCHECK(!sendto_requests_.empty());
+  DCHECK(sendto_state_ == IO_STATE_IN_PROCESS);
 
   if (result < 0) {
     SendSendToACKError();
@@ -178,5 +204,9 @@ void PepperUDPSocket::OnSendToCompleted(int result) {
         routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
   }
 
-  sendto_buffer_ = NULL;
+  sendto_requests_.pop();
+  sendto_state_ = IO_STATE_IDLE;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&PepperUDPSocket::SendToInternal,
+                 base::Unretained(this)));
 }