Implement PPB_UDPSocket_Dev: part 2

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 <vector>
 
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/var_value_conversions.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/resource_creation_api.h"
 
 namespace ppapi {
 namespace proxy {
 
+namespace {
+
+int32_t ConvertPPError(int32_t pp_error, bool private_api) {
+  // The private API doesn't return network-specific error codes or
+  // PP_ERROR_NOACCESS. In order to preserve the behavior, we convert those to
+  // PP_ERROR_FAILED.
+  if (private_api &&
+      (pp_error <= PP_ERROR_CONNECTION_CLOSED ||
+       pp_error == PP_ERROR_NOACCESS)) {
+    return PP_ERROR_FAILED;
+  }
+
+  return pp_error;
+}
+
+}  // namespace
+
 const int32_t UDPSocketResourceBase::kMaxReadSize = 1024 * 1024;
 const int32_t UDPSocketResourceBase::kMaxWriteSize = 1024 * 1024;
+const int32_t UDPSocketResourceBase::kMaxSendBufferSize =
+    1024 * UDPSocketResourceBase::kMaxWriteSize;
+const int32_t UDPSocketResourceBase::kMaxReceiveBufferSize =
+    1024 * UDPSocketResourceBase::kMaxReadSize;
+
 
 UDPSocketResourceBase::UDPSocketResourceBase(Connection connection,
-                                             PP_Instance instance)
+                                             PP_Instance instance,
+                                             bool private_api)
     : PluginResource(connection, instance),
+      private_api_(private_api),
       bound_(false),
       closed_(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));
   bound_addr_.size = 0;
   memset(bound_addr_.data, 0,
          arraysize(bound_addr_.data) * sizeof(*bound_addr_.data));
 
-  SendCreate(BROWSER, PpapiHostMsg_UDPSocketPrivate_Create());
+  if (private_api)
+    SendCreate(BROWSER, PpapiHostMsg_UDPSocket_CreatePrivate());
+  else
+    SendCreate(BROWSER, PpapiHostMsg_UDPSocket_Create());
 }
 
 UDPSocketResourceBase::~UDPSocketResourceBase() {
 }
 
-int32_t UDPSocketResourceBase::SetSocketFeatureImpl(
-    PP_UDPSocketFeature_Private name,
-    const PP_Var& value) {
-  if (bound_ || closed_)
+int32_t UDPSocketResourceBase::SetOptionImpl(
+    PP_UDPSocket_Option_Dev name,
+    const PP_Var& value,
+    scoped_refptr<TrackedCallback> callback) {
+  if (closed_)
     return PP_ERROR_FAILED;
 
   switch (name) {
-    case PP_UDPSOCKETFEATURE_ADDRESS_REUSE:
-    case PP_UDPSOCKETFEATURE_BROADCAST: {
+    case PP_UDPSOCKET_OPTION_ADDRESS_REUSE:
+    case PP_UDPSOCKET_OPTION_BROADCAST: {
       if (value.type != PP_VARTYPE_BOOL)
         return PP_ERROR_BADARGUMENT;
-      Post(BROWSER,
-           PpapiHostMsg_UDPSocketPrivate_SetBoolSocketFeature(
-               static_cast<int32_t>(name), PP_ToBool(value.value.as_bool)));
+      if (bound_)
+        return PP_ERROR_FAILED;
+      break;
+    }
+    case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE:
+    case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
+      if (value.type != PP_VARTYPE_INT32)
+        return PP_ERROR_BADARGUMENT;
+      if (!bound_)
+        return PP_ERROR_FAILED;
       break;
     }
     default: {
+      NOTREACHED();
       return PP_ERROR_BADARGUMENT;
     }
   }
-  return PP_OK;
+
+  scoped_ptr<base::ListValue> list_value(
+      CreateListValueFromVarVector(std::vector<PP_Var>(1, value)));
+  if (!list_value.get())
+    return PP_ERROR_FAILED;
+
+  Call<PpapiPluginMsg_UDPSocket_SetOptionReply>(
+      BROWSER,
+      PpapiHostMsg_UDPSocket_SetOption(name, *list_value),
+      base::Bind(&UDPSocketResourceBase::OnPluginMsgSetOptionReply,
+                 base::Unretained(this),
+                 callback));
+  return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t UDPSocketResourceBase::BindImpl(
     const PP_NetAddress_Private* addr,
     scoped_refptr<TrackedCallback> callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
   if (bound_ || closed_)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(bind_callback_))
     return PP_ERROR_INPROGRESS;
 
   bind_callback_ = callback;
 
   // Send the request, the browser will call us back via BindReply.
-  Call<PpapiPluginMsg_UDPSocketPrivate_BindReply>(
+  Call<PpapiPluginMsg_UDPSocket_BindReply>(
       BROWSER,
-      PpapiHostMsg_UDPSocketPrivate_Bind(*addr),
+      PpapiHostMsg_UDPSocket_Bind(*addr),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgBindReply,
                  base::Unretained(this)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool UDPSocketResourceBase::GetBoundAddressImpl(
     PP_NetAddress_Private* addr) {
   if (!addr || !bound_ || closed_)
     return PP_FALSE;
 
@@ skipping 11 matching lines @@
   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;
 
   // Send the request, the browser will call us back via RecvFromReply.
-  Call<PpapiPluginMsg_UDPSocketPrivate_RecvFromReply>(
+  Call<PpapiPluginMsg_UDPSocket_RecvFromReply>(
       BROWSER,
-      PpapiHostMsg_UDPSocketPrivate_RecvFrom(bytes_to_read_),
+      PpapiHostMsg_UDPSocket_RecvFrom(bytes_to_read_),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgRecvFromReply,
                  base::Unretained(this), addr));
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool UDPSocketResourceBase::GetRecvFromAddressImpl(
     PP_NetAddress_Private* addr) {
   if (!addr)
     return PP_FALSE;
   *addr = recvfrom_addr_;
@@ skipping 11 matching lines @@
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(sendto_callback_))
     return PP_ERROR_INPROGRESS;
 
   if (num_bytes > kMaxWriteSize)
     num_bytes = kMaxWriteSize;
 
   sendto_callback_ = callback;
 
   // Send the request, the browser will call us back via SendToReply.
-  Call<PpapiPluginMsg_UDPSocketPrivate_SendToReply>(
+  Call<PpapiPluginMsg_UDPSocket_SendToReply>(
       BROWSER,
-      PpapiHostMsg_UDPSocketPrivate_SendTo(
-          std::string(buffer, num_bytes), *addr),
+      PpapiHostMsg_UDPSocket_SendTo(std::string(buffer, num_bytes), *addr),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgSendToReply,
                  base::Unretained(this)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void UDPSocketResourceBase::CloseImpl() {
   if(closed_)
     return;
 
   bound_ = false;
   closed_ = true;
 
-  Post(BROWSER, PpapiHostMsg_UDPSocketPrivate_Close());
+  Post(BROWSER, PpapiHostMsg_UDPSocket_Close());
 
   PostAbortIfNecessary(&bind_callback_);
   PostAbortIfNecessary(&recvfrom_callback_);
   PostAbortIfNecessary(&sendto_callback_);
 }
 
 void UDPSocketResourceBase::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (TrackedCallback::IsPending(*callback))
     (*callback)->PostAbort();
 }
 
+void UDPSocketResourceBase::OnPluginMsgSetOptionReply(
+    scoped_refptr<TrackedCallback> callback,
+    const ResourceMessageReplyParams& params) {
+  if (TrackedCallback::IsPending(callback))
+    callback->Run(ConvertPPError(params.result(), private_api_));
+}
+
 void UDPSocketResourceBase::OnPluginMsgBindReply(
     const ResourceMessageReplyParams& params,
     const PP_NetAddress_Private& bound_addr) {
   if (!TrackedCallback::IsPending(bind_callback_)) {
     NOTREACHED();
     return;
   }
   if (params.result() == PP_OK)
     bound_ = true;
   bound_addr_ = bound_addr;
-  bind_callback_->Run(params.result());
+  bind_callback_->Run(ConvertPPError(params.result(), private_api_));
 }
 
 void UDPSocketResourceBase::OnPluginMsgRecvFromReply(
     PP_Resource* output_addr,
     const ResourceMessageReplyParams& params,
     const std::string& data,
     const PP_NetAddress_Private& addr) {
   if (!TrackedCallback::IsPending(recvfrom_callback_)) {
     NOTREACHED();
     return;
@@ skipping 15 matching lines @@
       memcpy(read_buffer_, data.c_str(), data.size());
   }
 
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
   recvfrom_addr_ = addr;
 
   if (succeeded)
     recvfrom_callback_->Run(static_cast<int32_t>(data.size()));
   else
-    recvfrom_callback_->Run(params.result());
+    recvfrom_callback_->Run(ConvertPPError(params.result(), private_api_));
 }
 
 void UDPSocketResourceBase::OnPluginMsgSendToReply(
     const ResourceMessageReplyParams& params,
     int32_t bytes_written) {
   if (!TrackedCallback::IsPending(sendto_callback_)) {
     NOTREACHED();
     return;
   }
   if (params.result() == PP_OK)
     sendto_callback_->Run(bytes_written);
   else
-    sendto_callback_->Run(params.result());
+    sendto_callback_->Run(ConvertPPError(params.result(), private_api_));
 }
 
 }  // namespace proxy
 }  // namespace ppapi