Implement PPB_UDPSocket_Dev: part 2

ppapi/proxy/udp_socket_resource_base.cc

Index: ppapi/proxy/udp_socket_resource_base.cc
diff --git a/ppapi/proxy/udp_socket_resource_base.cc b/ppapi/proxy/udp_socket_resource_base.cc
index 5d318902f3e875a20e611536bc2db48f6a4db9b1..632115548fda838cc07a80bbcb3c3e1531bcece3 100644
--- a/ppapi/proxy/udp_socket_resource_base.cc
+++ b/ppapi/proxy/udp_socket_resource_base.cc
@@ -6,24 +6,47 @@
 
 #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;
 
 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),
@@ -35,33 +58,55 @@ UDPSocketResourceBase::UDPSocketResourceBase(Connection connection,
   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;
       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(
@@ -77,9 +122,9 @@ int32_t UDPSocketResourceBase::BindImpl(
   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;
@@ -111,9 +156,9 @@ int32_t UDPSocketResourceBase::RecvFromImpl(
   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;
@@ -145,10 +190,9 @@ int32_t UDPSocketResourceBase::SendToImpl(
   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;
@@ -161,7 +205,7 @@ void UDPSocketResourceBase::CloseImpl() {
   bound_ = false;
   closed_ = true;
 
-  Post(BROWSER, PpapiHostMsg_UDPSocketPrivate_Close());
+  Post(BROWSER, PpapiHostMsg_UDPSocket_Close());
 
   PostAbortIfNecessary(&bind_callback_);
   PostAbortIfNecessary(&recvfrom_callback_);
@@ -174,6 +218,13 @@ void UDPSocketResourceBase::PostAbortIfNecessary(
     (*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) {
@@ -184,7 +235,7 @@ void UDPSocketResourceBase::OnPluginMsgBindReply(
   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(
@@ -220,7 +271,7 @@ void UDPSocketResourceBase::OnPluginMsgRecvFromReply(
   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(
@@ -233,7 +284,7 @@ void UDPSocketResourceBase::OnPluginMsgSendToReply(
   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