Revert 191401 "Implemented queued UDP SendTo/RecvFrom requests. ..."

Broken on Linux ChromiumOS

> Implemented queued UDP SendTo/RecvFrom requests. Exposed SO_SNDBUF and SO_RVFBUF socket options.
> 
> BUG=154338
> TEST=browser_tests:*UDPSocketPrivate*
> TBR=jschuh
> 
> Review URL: https://chromiumcodereview.appspot.com/12316095

TBR=ygorshenin@chromium.org
Review URL: https://codereview.chromium.org/13154008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@191415 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 44 insertions, 130 deletions

diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index 8183b3d..eb921d9 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -1224,9 +1224,6 @@ IPC_MESSAGE_CONTROL0(PpapiHostMsg_UDPSocketPrivate_Create)
 IPC_MESSAGE_CONTROL2(PpapiHostMsg_UDPSocketPrivate_SetBoolSocketFeature,
                      int32_t /* name */,
                      bool /* value */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_UDPSocketPrivate_SetInt32SocketFeature,
-                     int32_t /* name */,
-                     int32_t /* value */)
 IPC_MESSAGE_CONTROL1(PpapiHostMsg_UDPSocketPrivate_Bind,
                      PP_NetAddress_Private /* net_addr */)
 IPC_MESSAGE_CONTROL1(PpapiHostMsg_UDPSocketPrivate_RecvFrom,
diff --git a/ppapi/proxy/udp_socket_private_resource.cc b/ppapi/proxy/udp_socket_private_resource.cc
index 9db535c..608fc00 100644
--- a/ppapi/proxy/udp_socket_private_resource.cc
+++ b/ppapi/proxy/udp_socket_private_resource.cc
@@ -25,7 +25,8 @@ UDPSocketPrivateResource::UDPSocketPrivateResource(Connection connection,
     : PluginResource(connection, instance),
       bound_(false),
       closed_(false),
-      pending_recvfrom_0_4_(false) {
+      read_buffer_(NULL),
+      bytes_to_read_(-1) {
   recvfrom_addr_.size = 0;
   memset(recvfrom_addr_.data, 0,
          arraysize(recvfrom_addr_.data) * sizeof(*recvfrom_addr_.data));
@@ -47,25 +48,17 @@ UDPSocketPrivateResource::AsPPB_UDPSocket_Private_API() {
 int32_t UDPSocketPrivateResource::SetSocketFeature(
     PP_UDPSocketFeature_Private name,
     PP_Var value) {
-  if (closed_)
+  if (bound_ || closed_)
     return PP_ERROR_FAILED;
 
   switch (name) {
     case PP_UDPSOCKETFEATURE_ADDRESS_REUSE:
     case PP_UDPSOCKETFEATURE_BROADCAST:
-      if (bound_)
-        return PP_ERROR_FAILED;
       if (value.type != PP_VARTYPE_BOOL)
         return PP_ERROR_BADARGUMENT;
       SendBoolSocketFeature(static_cast<int32_t>(name),
                             PP_ToBool(value.value.as_bool));
       break;
-    case PP_UDPSOCKETFEATURE_SEND_BUFFER_SIZE:
-    case PP_UDPSOCKETFEATURE_RECV_BUFFER_SIZE:
-      if (value.type != PP_VARTYPE_INT32)
-        return PP_ERROR_BADARGUMENT;
-      SendInt32SocketFeature(static_cast<int32_t>(name), value.value.as_int);
-      break;
     default:
       return PP_ERROR_BADARGUMENT;
   }
@@ -97,19 +90,24 @@ PP_Bool UDPSocketPrivateResource::GetBoundAddress(PP_NetAddress_Private* addr) {
   return PP_TRUE;
 }
 
-int32_t UDPSocketPrivateResource::RecvFrom_0_4(
+int32_t UDPSocketPrivateResource::RecvFrom(
     char* buffer,
     int32_t num_bytes,
     scoped_refptr<TrackedCallback> callback) {
-  return RecvFrom(buffer, num_bytes, &recvfrom_addr_, callback, true);
-}
+  if (!buffer || num_bytes <= 0)
+    return PP_ERROR_BADARGUMENT;
+  if (!bound_)
+    return PP_ERROR_FAILED;
+  if (TrackedCallback::IsPending(recvfrom_callback_))
+    return PP_ERROR_INPROGRESS;
 
-int32_t UDPSocketPrivateResource::RecvFrom_0_5(
-    char* buffer,
-    int32_t num_bytes,
-    PP_NetAddress_Private* addr,
-    scoped_refptr<TrackedCallback> callback) {
-  return RecvFrom(buffer, num_bytes, addr, callback, false);
+  read_buffer_ = buffer;
+  bytes_to_read_ = std::min(num_bytes, kMaxReadSize);
+  recvfrom_callback_ = callback;
+
+  // Send the request, the browser will call us back via RecvFromReply.
+  SendRecvFrom(bytes_to_read_);
+  return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool UDPSocketPrivateResource::GetRecvFromAddress(
@@ -120,31 +118,6 @@ PP_Bool UDPSocketPrivateResource::GetRecvFromAddress(
   return PP_TRUE;
 }
 
-int32_t UDPSocketPrivateResource::RecvFrom(
-    char* buffer,
-    int32_t num_bytes,
-    PP_NetAddress_Private* addr,
-    scoped_refptr<TrackedCallback> callback,
-    bool recvfrom_0_4) {
-  if (!buffer || num_bytes <= 0)
-    return PP_ERROR_BADARGUMENT;
-  if (!bound_)
-    return PP_ERROR_FAILED;
-  if (recvfrom_0_4 && pending_recvfrom_0_4_)
-    return PP_ERROR_INPROGRESS;
-  if (recvfrom_0_4)
-    pending_recvfrom_0_4_ = true;
-  num_bytes = std::min(num_bytes, kMaxReadSize);
-  recvfrom_requests_.push(RecvFromRequest(callback,
-                                          buffer,
-                                          addr,
-                                          num_bytes,
-                                          recvfrom_0_4));
-  // Send the request, the browser will call us back via RecvFromReply.
-  SendRecvFrom(num_bytes);
-  return PP_OK_COMPLETIONPENDING;
-}
-
 void UDPSocketPrivateResource::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (TrackedCallback::IsPending(*callback))
@@ -160,11 +133,13 @@ int32_t UDPSocketPrivateResource::SendTo(
     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_callbacks_.push(callback);
+  sendto_callback_ = callback;
 
   // Send the request, the browser will call us back via SendToReply.
   SendSendTo(std::string(buffer, num_bytes), *addr);
@@ -181,15 +156,8 @@ void UDPSocketPrivateResource::Close() {
   SendClose();
 
   PostAbortIfNecessary(&bind_callback_);
-  while (!recvfrom_requests_.empty()) {
-    RecvFromRequest& request = recvfrom_requests_.front();
-    PostAbortIfNecessary(&request.callback);
-    recvfrom_requests_.pop();
-  }
-  while (!sendto_callbacks_.empty()) {
-    PostAbortIfNecessary(&sendto_callbacks_.front());
-    sendto_callbacks_.pop();
-  }
+  PostAbortIfNecessary(&recvfrom_callback_);
+  PostAbortIfNecessary(&sendto_callback_);
 }
 
 void UDPSocketPrivateResource::SendBoolSocketFeature(int32_t name, bool value) {
@@ -197,12 +165,6 @@ void UDPSocketPrivateResource::SendBoolSocketFeature(int32_t name, bool value) {
   Post(BROWSER, msg);
 }
 
-void UDPSocketPrivateResource::SendInt32SocketFeature(int32_t name,
-                                                      int32_t value) {
-  PpapiHostMsg_UDPSocketPrivate_SetInt32SocketFeature msg(name, value);
-  Post(BROWSER, msg);
-}
-
 void UDPSocketPrivateResource::SendBind(const PP_NetAddress_Private& addr) {
   PpapiHostMsg_UDPSocketPrivate_Bind msg(addr);
   Call<PpapiPluginMsg_UDPSocketPrivate_BindReply>(
@@ -253,44 +215,37 @@ void UDPSocketPrivateResource::OnPluginMsgRecvFromReply(
     const ResourceMessageReplyParams& params,
     const std::string& data,
     const PP_NetAddress_Private& addr) {
-  if (recvfrom_requests_.empty())
+  if (!TrackedCallback::IsPending(recvfrom_callback_) || !read_buffer_) {
+    NOTREACHED();
     return;
-  RecvFromRequest request = recvfrom_requests_.front();
-  recvfrom_requests_.pop();
-  if (request.recvfrom_0_4_) {
-    DCHECK(pending_recvfrom_0_4_);
-    pending_recvfrom_0_4_ = false;
   }
-  if (!TrackedCallback::IsPending(request.callback))
-    return;
   bool succeeded = (params.result() == PP_OK);
-  if (succeeded && !data.empty() && request.buffer) {
-    CHECK_LE(static_cast<int32_t>(data.size()), request.num_bytes);
-    memcpy(request.buffer, data.c_str(), data.size());
+  if (succeeded) {
+    CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
+    if (!data.empty())
+      memcpy(read_buffer_, data.c_str(), data.size());
   }
-  if (request.addr)
-    *request.addr = addr;
+  read_buffer_ = NULL;
+  bytes_to_read_ = -1;
+  recvfrom_addr_ = addr;
+
   if (succeeded)
-    request.callback->Run(static_cast<int32_t>(data.size()));
+    recvfrom_callback_->Run(static_cast<int32_t>(data.size()));
   else
-    request.callback->Run(params.result());
+    recvfrom_callback_->Run(params.result());
 }
 
 void UDPSocketPrivateResource::OnPluginMsgSendToReply(
     const ResourceMessageReplyParams& params,
     int32_t bytes_written) {
-  if (sendto_callbacks_.empty())
-    return;
-  scoped_refptr<TrackedCallback> callback  = sendto_callbacks_.front();
-  sendto_callbacks_.pop();
-  if (!TrackedCallback::IsPending(callback)) {
+  if (!TrackedCallback::IsPending(sendto_callback_)) {
     NOTREACHED();
     return;
   }
   if (params.result() == PP_OK)
-    callback->Run(bytes_written);
+    sendto_callback_->Run(bytes_written);
   else
-    callback->Run(params.result());
+    sendto_callback_->Run(params.result());
 }
 
 }  // namespace proxy
diff --git a/ppapi/proxy/udp_socket_private_resource.h b/ppapi/proxy/udp_socket_private_resource.h
index d84505e..6403f6b 100644
--- a/ppapi/proxy/udp_socket_private_resource.h
+++ b/ppapi/proxy/udp_socket_private_resource.h
@@ -5,8 +5,6 @@
 #ifndef PPAPI_PROXY_UDP_SOCKET_PRIVATE_RESOURCE_H_
 #define PPAPI_PROXY_UDP_SOCKET_PRIVATE_RESOURCE_H_
 
-#include <queue>
-
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "ppapi/proxy/plugin_resource.h"
@@ -42,15 +40,9 @@ class PPAPI_PROXY_EXPORT UDPSocketPrivateResource
   virtual int32_t Bind(const PP_NetAddress_Private* addr,
                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Bool GetBoundAddress(PP_NetAddress_Private* addr) OVERRIDE;
-  virtual int32_t RecvFrom_0_4(
-      char* buffer,
-      int32_t num_bytes,
-      scoped_refptr<TrackedCallback> callback) OVERRIDE;
-  virtual int32_t RecvFrom_0_5(
-      char* buffer,
-      int32_t num_bytes,
-      PP_NetAddress_Private* addr,
-      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t RecvFrom(char* buffer,
+                           int32_t num_bytes,
+                           scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Bool GetRecvFromAddress(PP_NetAddress_Private* addr) OVERRIDE;
   virtual int32_t SendTo(const char* buffer,
                          int32_t num_bytes,
@@ -59,36 +51,9 @@ class PPAPI_PROXY_EXPORT UDPSocketPrivateResource
   virtual void Close() OVERRIDE;
 
  private:
-  struct RecvFromRequest {
-    RecvFromRequest(scoped_refptr<TrackedCallback> callback,
-                    char* buffer,
-                    PP_NetAddress_Private* addr,
-                    int32_t num_bytes,
-                    bool recvfrom_0_4)
-        : callback(callback),
-          buffer(buffer),
-          addr(addr),
-          num_bytes(num_bytes),
-          recvfrom_0_4_(recvfrom_0_4) {
-    }
-
-    scoped_refptr<TrackedCallback> callback;
-    char* buffer;
-    PP_NetAddress_Private* addr;
-    int32_t num_bytes;
-    bool recvfrom_0_4_;
-  };
-
-  int32_t RecvFrom(char* buffer,
-                   int32_t num_bytes,
-                   PP_NetAddress_Private* addr,
-                   scoped_refptr<TrackedCallback> callback,
-                   bool recvfrom_0_4);
-
   void PostAbortIfNecessary(scoped_refptr<TrackedCallback>* callback);
 
   void SendBoolSocketFeature(int32_t name, bool value);
-  void SendInt32SocketFeature(int32_t name, int32_t value);
   void SendBind(const PP_NetAddress_Private& addr);
   void SendRecvFrom(int32_t num_bytes);
   void SendSendTo(const std::string& buffer,
@@ -108,14 +73,11 @@ class PPAPI_PROXY_EXPORT UDPSocketPrivateResource
   bool closed_;
 
   scoped_refptr<TrackedCallback> bind_callback_;
+  scoped_refptr<TrackedCallback> recvfrom_callback_;
+  scoped_refptr<TrackedCallback> sendto_callback_;
 
-  // Queue of RecvFrom requests, used since v0.5.
-  std::queue<RecvFromRequest> recvfrom_requests_;
-
-  // True if RecvFrom() v0.4 is in process.
-  bool pending_recvfrom_0_4_;
-
-  std::queue<scoped_refptr<TrackedCallback> > sendto_callbacks_;
+  char* read_buffer_;
+  int32_t bytes_to_read_;
 
   PP_NetAddress_Private recvfrom_addr_;
   PP_NetAddress_Private bound_addr_;