PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Renderer process.

BUG=105859
TEST=build, tests are in next CL with render implementation

Review URL: http://codereview.chromium.org/8555002

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

18 files changed, 2130 insertions, 0 deletions

diff --git a/ppapi/native_client/src/shared/ppapi_proxy/browser_globals.cc b/ppapi/native_client/src/shared/ppapi_proxy/browser_globals.cc
index 868a56b..8fcb957 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/browser_globals.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/browser_globals.cc
@@ -410,4 +410,18 @@ const PPB_PDF* PPBPDFInterface() {
   return ppb;
 }
 
+const PPB_TCPSocket_Private* PPBTCPSocketPrivateInterface() {
+  static const PPB_TCPSocket_Private* ppb =
+      static_cast<const PPB_TCPSocket_Private*>(
+          GetBrowserInterfaceSafe(PPB_TCPSOCKET_PRIVATE_INTERFACE));
+  return ppb;
+}
+
+const PPB_UDPSocket_Private* PPBUDPSocketPrivateInterface() {
+  static const PPB_UDPSocket_Private* ppb =
+      static_cast<const PPB_UDPSocket_Private*>(
+          GetBrowserInterfaceSafe(PPB_UDPSOCKET_PRIVATE_INTERFACE));
+  return ppb;
+}
+
 }  // namespace ppapi_proxy
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/browser_globals.h b/ppapi/native_client/src/shared/ppapi_proxy/browser_globals.h
index 854054a..c5a2066e 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/browser_globals.h
+++ b/ppapi/native_client/src/shared/ppapi_proxy/browser_globals.h
@@ -34,6 +34,8 @@
 #include "ppapi/c/ppb_url_response_info.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/private/ppb_pdf.h"
+#include "ppapi/c/private/ppb_tcp_socket_private.h"
+#include "ppapi/c/private/ppb_udp_socket_private.h"
 #include "ppapi/c/trusted/ppb_graphics_3d_trusted.h"
 #include "ppapi/c/trusted/ppb_image_data_trusted.h"
 
@@ -115,7 +117,9 @@ const PPB_Messaging* PPBMessagingInterface();
 const PPB_MouseLock* PPBMouseLockInterface();
 const PPB_PDF* PPBPDFInterface();
 const PPB_Scrollbar_Dev* PPBScrollbarInterface();
+const PPB_TCPSocket_Private* PPBTCPSocketPrivateInterface();
 const PPB_Testing_Dev* PPBTestingInterface();
+const PPB_UDPSocket_Private* PPBUDPSocketPrivateInterface();
 const PPB_URLLoader* PPBURLLoaderInterface();
 const PPB_URLRequestInfo* PPBURLRequestInfoInterface();
 const PPB_URLResponseInfo* PPBURLResponseInfoInterface();
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_tcp_socket_private_rpc_server.cc b/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_tcp_socket_private_rpc_server.cc
new file mode 100644
index 0000000..85614a2
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_tcp_socket_private_rpc_server.cc
@@ -0,0 +1,310 @@
+// Copyright (c) 2011 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.
+//
+// SRPC-abstraction wrappers around PPB_TCPSocket_Private functions.
+
+#include <string.h>
+#include <limits>
+
+#include "native_client/src/include/nacl_macros.h"
+#include "native_client/src/shared/ppapi_proxy/browser_callback.h"
+#include "native_client/src/shared/ppapi_proxy/browser_globals.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_tcp_socket_private.h"
+#include "srpcgen/ppb_rpc.h"
+
+using ppapi_proxy::DebugPrintf;
+using ppapi_proxy::DeleteRemoteCallbackInfo;
+using ppapi_proxy::MakeRemoteCompletionCallback;
+using ppapi_proxy::PPBTCPSocketPrivateInterface;
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Create(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Instance instance,
+    // output
+    PP_Resource* resource) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  *resource = PPBTCPSocketPrivateInterface()->Create(instance);
+
+  DebugPrintf("PPB_TCPSocket_Private::Create: resource=%"NACL_PRIu32"\n",
+              *resource);
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_IsTCPSocket(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource resource,
+    // output
+    int32_t* is_tcp_socket) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  PP_Bool pp_success =
+      PPBTCPSocketPrivateInterface()->IsTCPSocket(resource);
+
+  DebugPrintf("PPB_TCPSocket_Private::IsTCPSocket: pp_success=%d\n",
+              pp_success);
+
+  *is_tcp_socket = (pp_success == PP_TRUE);
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Connect(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    char* host,
+    int32_t port,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBTCPSocketPrivateInterface()->Connect(
+      tcp_socket,
+      host,
+      port,
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::Connect: "
+              "pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)  // Async error.
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_ConnectWithNetAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (addr_bytes != sizeof(PP_NetAddress_Private))
+    return;
+
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBTCPSocketPrivateInterface()->ConnectWithNetAddress(
+      tcp_socket,
+      reinterpret_cast<struct PP_NetAddress_Private*>(addr),
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::ConnectWithNetAddress: "
+              "pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)  // Async error.
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_GetLocalAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    // output
+    nacl_abi_size_t* local_addr_bytes, char* local_addr,
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (*local_addr_bytes !=
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private)))
+    return;
+
+  PP_Bool pp_success = PPBTCPSocketPrivateInterface()->GetLocalAddress(
+      tcp_socket, reinterpret_cast<struct PP_NetAddress_Private*>(local_addr));
+
+  DebugPrintf("PPB_TCPSocket_Private::GetLocalAddress: pp_success=%d\n",
+              pp_success);
+
+  *success = (pp_success == PP_TRUE);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_GetRemoteAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    // output
+    nacl_abi_size_t* remote_addr_bytes, char* remote_addr,
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (*remote_addr_bytes !=
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private)))
+    return;
+
+  PP_Bool pp_success =
+      PPBTCPSocketPrivateInterface()->GetRemoteAddress(
+          tcp_socket,
+          reinterpret_cast<struct PP_NetAddress_Private*>(remote_addr));
+
+  DebugPrintf("PPB_TCPSocket_Private::GetRemoteAddress: pp_success=%d\n",
+              pp_success);
+
+  *success = (pp_success == PP_TRUE);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_SSLHandshake(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    char* server_name,
+    int32_t server_port,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_CompletionCallback remote_callback = MakeRemoteCompletionCallback(
+      rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBTCPSocketPrivateInterface()->SSLHandshake(
+      tcp_socket,
+      server_name,
+      server_port,
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::SSLHandshake: "
+              "pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING) // Async error.
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Read(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure *done,
+    // input
+    PP_Resource tcp_socket,
+    int32_t bytes_to_read,
+    int32_t callback_id,
+    // output
+    nacl_abi_size_t* buffer_bytes, char* buffer,
+    int32_t* pp_error_or_bytes) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (*buffer_bytes != static_cast<nacl_abi_size_t>(bytes_to_read))
+    return;
+
+  char* callback_buffer = NULL;
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id, bytes_to_read,
+                                   &callback_buffer);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error_or_bytes = PPBTCPSocketPrivateInterface()->Read(
+      tcp_socket,
+      callback_buffer,
+      bytes_to_read,
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::Read: "
+              "pp_error_or_bytes=%"NACL_PRId32"\n", *pp_error_or_bytes);
+
+  if (!(*pp_error_or_bytes <= bytes_to_read))
+    return;
+
+  if (*pp_error_or_bytes > 0) {  // Bytes read into |callback_buffer|.
+    // No callback scheduled.
+    if (!(static_cast<nacl_abi_size_t>(*pp_error_or_bytes) <= *buffer_bytes))
+      return;
+    *buffer_bytes = static_cast<nacl_abi_size_t>(*pp_error_or_bytes);
+    memcpy(buffer, callback_buffer, *buffer_bytes);
+    DeleteRemoteCallbackInfo(remote_callback);
+  } else if (*pp_error_or_bytes != PP_OK_COMPLETIONPENDING) {  // Async error.
+    // No callback scheduled.
+    *buffer_bytes = 0;
+    DeleteRemoteCallbackInfo(remote_callback);
+  } else {
+    // Callback scheduled.
+    *buffer_bytes = 0;
+  }
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Write(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    PP_Resource tcp_socket,
+    // input
+    nacl_abi_size_t buffer_bytes, char* buffer,
+    int32_t bytes_to_write,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error_or_bytes) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (!(static_cast<nacl_abi_size_t>(bytes_to_write) <= buffer_bytes))
+    return;
+
+  PP_CompletionCallback remote_callback = MakeRemoteCompletionCallback(
+      rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error_or_bytes = PPBTCPSocketPrivateInterface()->Write(
+      tcp_socket,
+      buffer,
+      bytes_to_write,
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::Write: "
+              "pp_error_or_bytes=%"NACL_PRId32"\n", *pp_error_or_bytes);
+
+  // Bytes must be written asynchronously.
+  if (*pp_error_or_bytes != PP_OK_COMPLETIONPENDING)
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Disconnect(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  DebugPrintf("PPB_TCPSocket_Private::Disconnect: tcp_socket=%"NACL_PRIu32"\n",
+              tcp_socket);
+
+  PPBTCPSocketPrivateInterface()->Disconnect(tcp_socket);
+}
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_udp_socket_private_rpc_server.cc b/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_udp_socket_private_rpc_server.cc
new file mode 100644
index 0000000..7bc8e88
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_udp_socket_private_rpc_server.cc
@@ -0,0 +1,226 @@
+// Copyright (c) 2011 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.
+//
+// SRPC-abstraction wrappers around PPB_UDPSocket_Private functions.
+
+#include <string.h>
+#include <limits>
+
+#include "native_client/src/include/nacl_macros.h"
+#include "native_client/src/shared/ppapi_proxy/browser_callback.h"
+#include "native_client/src/shared/ppapi_proxy/browser_globals.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_udp_socket_private.h"
+#include "srpcgen/ppb_rpc.h"
+
+using ppapi_proxy::DebugPrintf;
+using ppapi_proxy::DeleteRemoteCallbackInfo;
+using ppapi_proxy::MakeRemoteCompletionCallback;
+using ppapi_proxy::PPBUDPSocketPrivateInterface;
+
+void PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_Create(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Instance instance_id,
+    // output
+    PP_Resource* resource) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  *resource = PPBUDPSocketPrivateInterface()->Create(instance_id);
+
+  DebugPrintf("PPB_UDPSocket_Private::Create: "
+              "resource=%"NACL_PRIu32"\n", *resource);
+}
+
+void PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_IsUDPSocket(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource resource_id,
+    // output
+    int32_t* is_udp_socket) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  PP_Bool pp_success =
+      PPBUDPSocketPrivateInterface()->IsUDPSocket(resource_id);
+
+  DebugPrintf("PPB_UDPSocket_Private::IsUDPSocket: "
+              "pp_success=%d\n", pp_success);
+
+  *is_udp_socket = (pp_success == PP_TRUE);
+}
+
+void PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_Bind(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource udp_socket,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (addr_bytes != sizeof(PP_NetAddress_Private))
+    return;
+
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBUDPSocketPrivateInterface()->Bind(
+      udp_socket,
+      reinterpret_cast<PP_NetAddress_Private*>(addr),
+      remote_callback);
+
+  DebugPrintf("PPB_UDPSocket_Private::Bind: "
+              "pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)  // Async error.
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_RecvFrom(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource udp_socket,
+    int32_t num_bytes,
+    int32_t callback_id,
+    // output
+    nacl_abi_size_t* buffer_bytes, char* buffer,
+    int32_t* pp_error_or_bytes) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (*buffer_bytes != static_cast<nacl_abi_size_t>(num_bytes))
+    return;
+
+  char* callback_buffer = NULL;
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id, num_bytes,
+                                   &callback_buffer);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error_or_bytes = PPBUDPSocketPrivateInterface()->RecvFrom(
+      udp_socket,
+      callback_buffer,
+      num_bytes,
+      remote_callback);
+
+  DebugPrintf("PPB_UDPSocket_Private::RecvFrom: "
+              "pp_error_or_bytes=%"NACL_PRId32"\n", *pp_error_or_bytes);
+
+  if (!(*pp_error_or_bytes <= num_bytes))
+    return;
+
+  if (*pp_error_or_bytes > 0) {  // Bytes read into |callback_buffer|.
+    // No callback scheduled.
+    if (!(static_cast<nacl_abi_size_t>(*pp_error_or_bytes) <= *buffer_bytes))
+      return;
+    *buffer_bytes = static_cast<nacl_abi_size_t>(*pp_error_or_bytes);
+    memcpy(buffer, callback_buffer, *buffer_bytes);
+    DeleteRemoteCallbackInfo(remote_callback);
+  } else if (*pp_error_or_bytes != PP_OK_COMPLETIONPENDING) {  // Async error.
+    // No callback scheduled.
+    *buffer_bytes = 0;
+    DeleteRemoteCallbackInfo(remote_callback);
+  } else {
+    // Callback scheduled.
+    *buffer_bytes = 0;
+  }
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_GetRecvFromAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource udp_socket,
+    // output
+    nacl_abi_size_t* addr_bytes, char* addr,
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (*addr_bytes !=
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private)))
+    return;
+
+  PP_Bool pp_success =
+      PPBUDPSocketPrivateInterface()->GetRecvFromAddress(
+          udp_socket,
+          reinterpret_cast<PP_NetAddress_Private*>(addr));
+
+  DebugPrintf("PPB_UDPSocket_Private::GetRecvFromAddress: "
+              "pp_success=%d\n", pp_success);
+
+  *success = (pp_success == PP_TRUE);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_SendTo(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource udp_socket,
+    nacl_abi_size_t buffer_bytes, char* buffer,
+    int32_t num_bytes,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error_or_bytes) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  if (addr_bytes != static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private)))
+    return;
+  if (!(static_cast<nacl_abi_size_t>(num_bytes) <= buffer_bytes))
+    return;
+
+  PP_CompletionCallback remote_callback = MakeRemoteCompletionCallback(
+      rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error_or_bytes =
+      PPBUDPSocketPrivateInterface()->SendTo(
+          udp_socket,
+          buffer,
+          num_bytes,
+          reinterpret_cast<PP_NetAddress_Private*>(addr),
+          remote_callback);
+
+  DebugPrintf("PPB_UDPSocket_Private::SendTo: "
+              "pp_error_or_bytes=%"NACL_PRId32"\n", *pp_error_or_bytes);
+
+  // Bytes must be written asynchronously.
+  if (*pp_error_or_bytes != PP_OK_COMPLETIONPENDING)
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_Close(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource udp_socket) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  DebugPrintf("PPB_UDPSocket_Private::Close: "
+              "udp_socket=%"NACL_PRIu32"\n", udp_socket);
+
+  PPBUDPSocketPrivateInterface()->Close(udp_socket);
+}
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/build.scons b/ppapi/native_client/src/shared/ppapi_proxy/build.scons
index 508b790..b7b9fc5 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/build.scons
+++ b/ppapi/native_client/src/shared/ppapi_proxy/build.scons
@@ -81,7 +81,9 @@ env.TrustedSrpc(is_client=False,
                             'ppb_mouse_lock.srpc',
                             'ppb_pdf.srpc',
                             'ppb_scrollbar.srpc',
+                            'ppb_tcp_socket_private.srpc',
                             'ppb_testing.srpc',
+                            'ppb_udp_socket_private.srpc',
                             'ppb_url_loader.srpc',
                             'ppb_url_request_info.srpc',
                             'ppb_url_response_info.srpc',
@@ -127,7 +129,9 @@ env.DualLibrary('ppapi_browser',
                  'browser_ppb_pdf_rpc_server.cc',
                  'browser_ppb_rpc_server.cc',
                  'browser_ppb_scrollbar_rpc_server.cc',
+                 'browser_ppb_tcp_socket_private_rpc_server.cc',
                  'browser_ppb_testing_rpc_server.cc',
+                 'browser_ppb_udp_socket_private_rpc_server.cc',
                  'browser_ppb_url_loader_rpc_server.cc',
                  'browser_ppb_url_request_info_rpc_server.cc',
                  'browser_ppb_url_response_info_rpc_server.cc',
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/nacl.scons b/ppapi/native_client/src/shared/ppapi_proxy/nacl.scons
index 998e5cd..73403ac 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/nacl.scons
+++ b/ppapi/native_client/src/shared/ppapi_proxy/nacl.scons
@@ -67,7 +67,9 @@ env.UntrustedSrpc(is_client=True,
                               'ppb_mouse_lock.srpc',
                               'ppb_pdf.srpc',
                               'ppb_scrollbar.srpc',
+                              'ppb_tcp_socket_private.srpc',
                               'ppb_testing.srpc',
+                              'ppb_udp_socket_private.srpc',
                               'ppb_url_loader.srpc',
                               'ppb_url_request_info.srpc',
                               'ppb_url_response_info.srpc',
@@ -142,7 +144,9 @@ libppruntime = env.NaClSdkLibrary(
     'plugin_ppb_mouse_lock.cc',
     'plugin_ppb_pdf.cc',
     'plugin_ppb_scrollbar.cc',
+    'plugin_ppb_tcp_socket_private.cc',
     'plugin_ppb_testing.cc',
+    'plugin_ppb_udp_socket_private.cc',
     'plugin_ppb_url_loader.cc',
     'plugin_ppb_url_request_info.cc',
     'plugin_ppb_url_response_info.cc',
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc
index 0f318ef..7c50328 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb.cc
@@ -28,7 +28,9 @@
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_mouse_lock.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_pdf.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_scrollbar.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_ppb_tcp_socket_private.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_testing.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_ppb_udp_socket_private.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_url_loader.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_url_request_info.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_url_response_info.h"
@@ -79,8 +81,12 @@ InterfaceMapElement interface_map[] = {
     true },
   { PPB_PDF_INTERFACE, PluginPDF::GetInterface(), true },
   { PPB_SCROLLBAR_DEV_INTERFACE, PluginScrollbar::GetInterface(), true },
+  { PPB_TCPSOCKET_PRIVATE_INTERFACE, PluginTCPSocketPrivate::GetInterface(),
+    true },
   { PPB_TESTING_DEV_INTERFACE_0_7, PluginTesting::GetInterface(), true },
   { PPB_TESTING_DEV_INTERFACE_0_8, PluginTesting::GetInterface(), true },
+  { PPB_UDPSOCKET_PRIVATE_INTERFACE, PluginUDPSocketPrivate::GetInterface(),
+    true },
   { PPB_URLLOADER_INTERFACE, PluginURLLoader::GetInterface(), true },
   { PPB_URLREQUESTINFO_INTERFACE, PluginURLRequestInfo::GetInterface(), true },
   { PPB_URLRESPONSEINFO_INTERFACE, PluginURLResponseInfo::GetInterface(),
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_tcp_socket_private.cc b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_tcp_socket_private.cc
new file mode 100644
index 0000000..54f5aba
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_tcp_socket_private.cc
@@ -0,0 +1,293 @@
+// Copyright (c) 2011 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 "native_client/src/shared/ppapi_proxy/plugin_ppb_tcp_socket_private.h"
+
+#include <string.h>
+#include "native_client/src/include/nacl_macros.h"
+#include "native_client/src/include/portability.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_callback.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_globals.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "native_client/src/shared/srpc/nacl_srpc.h"
+#include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_tcp_socket_private.h"
+#include "srpcgen/ppb_rpc.h"
+
+namespace ppapi_proxy {
+
+namespace {
+
+PP_Resource Create(PP_Instance instance) {
+  DebugPrintf("PPB_TCPSocket_Private::Create: instance=%"NACL_PRIu32"\n",
+              instance);
+
+  PP_Resource resource;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Create(
+          GetMainSrpcChannel(), instance, &resource);
+
+  DebugPrintf("PPB_TCPSocket_Private::Create: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK)
+    return resource;
+  else
+    return kInvalidResourceId;
+}
+
+PP_Bool IsTCPSocket(PP_Resource resource) {
+  DebugPrintf("PPB_TCPSocket_Private::IsTCPSocket: "
+              "resource=%"NACL_PRIu32"\n", resource);
+
+  int32_t is_tcp_socket;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_IsTCPSocket(
+          GetMainSrpcChannel(), resource, &is_tcp_socket);
+
+  DebugPrintf("PPB_TCPSocket_Private::IsTCPSocket: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK && is_tcp_socket)
+    return PP_TRUE;
+  return PP_FALSE;
+}
+
+int32_t Connect(PP_Resource tcp_socket, const char* host, uint16_t port,
+                struct PP_CompletionCallback callback) {
+  DebugPrintf("PPB_TCPSocket_Private::Connect: tcp_socket=%"NACL_PRIu32", "
+              "host=%s, port=%"NACL_PRIu16"\n", tcp_socket, host, port);
+
+  int32_t callback_id = CompletionCallbackTable::Get()->AddCallback(callback);
+  if (callback_id == 0)
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  int32_t pp_error = PP_ERROR_FAILED;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Connect(
+          GetMainSrpcChannel(),
+          tcp_socket,
+          const_cast<char*>(host),
+          static_cast<int32_t>(port),
+          callback_id,
+          &pp_error);
+
+  DebugPrintf("PPB_TCPSocket_Private::Connect: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error);
+}
+
+int32_t ConnectWithNetAddress(PP_Resource tcp_socket,
+                              const struct PP_NetAddress_Private* addr,
+                              struct PP_CompletionCallback callback) {
+  DebugPrintf("PPB_TCPSocket_Private::ConnectWithNetAddress: "
+              "tcp_socket=%"NACL_PRIu32"\n", tcp_socket);
+
+  int32_t callback_id = CompletionCallbackTable::Get()->AddCallback(callback);
+  if (callback_id == 0) // Just like Chrome, for now disallow blocking calls.
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  char* const raw_addr =
+      reinterpret_cast<char*>(const_cast<struct PP_NetAddress_Private*>(addr));
+
+  int32_t pp_error = PP_ERROR_FAILED;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_ConnectWithNetAddress(
+          GetMainSrpcChannel(),
+          tcp_socket,
+          static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private)), raw_addr,
+          callback_id,
+          &pp_error);
+
+  DebugPrintf("PPB_TCPSocket_Private::ConnectWithNetAddress: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error);
+}
+
+PP_Bool GetLocalAddress(PP_Resource tcp_socket,
+                        struct PP_NetAddress_Private* local_addr) {
+  DebugPrintf("PPB_TCPSocket_Private::GetLocalAddress: "
+              "tcp_socket=%"NACL_PRIu32"\n", tcp_socket);
+
+  nacl_abi_size_t local_addr_bytes =
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private));
+
+  int32_t success;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_GetLocalAddress(
+          GetMainSrpcChannel(),
+          tcp_socket,
+          &local_addr_bytes,
+          reinterpret_cast<char*>(local_addr),
+          &success);
+
+  DebugPrintf("PPB_TCPSocket_Private::GetLocalAddress: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK && success)
+    return PP_TRUE;
+  return PP_FALSE;
+}
+
+PP_Bool GetRemoteAddress(PP_Resource tcp_socket,
+                         struct PP_NetAddress_Private* remote_addr) {
+  DebugPrintf("PPB_TCPSocket_Private::GetRemoteAddress: "
+              "tcp_socket=%"NACL_PRIu32"\n", tcp_socket);
+
+  nacl_abi_size_t remote_addr_bytes =
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private));
+
+  int32_t success;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_GetRemoteAddress(
+          GetMainSrpcChannel(),
+          tcp_socket,
+          &remote_addr_bytes,
+          reinterpret_cast<char*>(remote_addr),
+          &success);
+
+  DebugPrintf("PPB_TCPSocket_Private::GetRemoteAddress: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK && success)
+    return PP_TRUE;
+  return PP_FALSE;
+}
+
+int32_t SSLHandshake(PP_Resource tcp_socket,
+                     const char* server_name,
+                     uint16_t server_port,
+                     struct PP_CompletionCallback callback) {
+  DebugPrintf("PPB_TCPSocket_Private::SSLHandshake: "
+              "tcp_socket=%"NACL_PRIu32", "
+              "server_name=%s, server_port=%"NACL_PRIu16"\n",
+              tcp_socket, server_name, server_port);
+
+  int32_t callback_id = CompletionCallbackTable::Get()->AddCallback(callback);
+  if (callback_id == 0) // Just like Chrome, for now disallow blocking calls.
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  int32_t pp_error = PP_ERROR_FAILED;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_SSLHandshake(
+          GetMainSrpcChannel(),
+          tcp_socket,
+          const_cast<char*>(server_name),
+          static_cast<int32_t>(server_port),
+          callback_id,
+          &pp_error);
+
+  DebugPrintf("PPB_TCPSocket_Private::SSLHandshake: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error);
+}
+
+int32_t Read(PP_Resource tcp_socket,
+             char* buffer,
+             int32_t bytes_to_read,
+             struct PP_CompletionCallback callback) {
+  DebugPrintf("PPB_TCPSocket_Private::Read: tcp_socket=%"NACL_PRIu32", "
+              "bytes_to_read=%"NACL_PRId32"\n", tcp_socket, bytes_to_read);
+
+  if (bytes_to_read < 0)
+    bytes_to_read = 0;
+  nacl_abi_size_t buffer_size = bytes_to_read;
+
+  int32_t callback_id =
+      CompletionCallbackTable::Get()->AddCallback(callback, buffer);
+  if (callback_id == 0)  // Just like Chrome, for now disallow blocking calls.
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  int32_t pp_error_or_bytes;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Read(
+          GetMainSrpcChannel(),
+          tcp_socket,
+          bytes_to_read,
+          callback_id,
+          &buffer_size, buffer,
+          &pp_error_or_bytes);
+
+  DebugPrintf("PPB_TCPSocket_Private::Read: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error_or_bytes = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error_or_bytes);
+}
+
+int32_t Write(PP_Resource tcp_socket,
+              const char* buffer,
+              int32_t bytes_to_write,
+              struct PP_CompletionCallback callback) {
+  DebugPrintf("PPB_TCPSocket_Private::Write: tcp_socket=%"NACL_PRIu32", "
+              "bytes_to_write=%"NACL_PRId32"\n", tcp_socket, bytes_to_write);
+
+  if (bytes_to_write < 0)
+    bytes_to_write = 0;
+  nacl_abi_size_t buffer_size = static_cast<nacl_abi_size_t>(bytes_to_write);
+
+  int32_t callback_id =
+      CompletionCallbackTable::Get()->AddCallback(callback);
+  if (callback_id == 0)  // Just like Chrome, for now disallow blocking calls.
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  int32_t pp_error_or_bytes = PP_ERROR_FAILED;
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Write(
+          GetMainSrpcChannel(),
+          tcp_socket,
+          buffer_size, const_cast<char*>(buffer),
+          bytes_to_write,
+          callback_id,
+          &pp_error_or_bytes);
+
+  DebugPrintf("PPB_TCPSocket_Private::Write: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error_or_bytes = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error_or_bytes);
+}
+
+void Disconnect(PP_Resource tcp_socket) {
+  DebugPrintf("PPB_TCPSocket_Private::Disconnect: tcp_socket="NACL_PRIu32"\n",
+              tcp_socket);
+
+  NaClSrpcError srpc_result =
+      PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Disconnect(
+          GetMainSrpcChannel(), tcp_socket);
+  DebugPrintf("PPB_TCPSocket_Private::Disconnect: %s\n",
+              NaClSrpcErrorString(srpc_result));
+}
+
+}  // namespace
+
+const PPB_TCPSocket_Private* PluginTCPSocketPrivate::GetInterface() {
+  static const PPB_TCPSocket_Private tcpsocket_private_interface = {
+    Create,
+    IsTCPSocket,
+    Connect,
+    ConnectWithNetAddress,
+    GetLocalAddress,
+    GetRemoteAddress,
+    SSLHandshake,
+    Read,
+    Write,
+    Disconnect,
+  };
+  return &tcpsocket_private_interface;
+}
+
+}  // namespace ppapi_proxy
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_tcp_socket_private.h b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_tcp_socket_private.h
new file mode 100644
index 0000000..58ddde9
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_tcp_socket_private.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2011 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.
+
+#ifndef NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_TCP_SOCKET_PRIVATE_H_
+#define NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_TCP_SOCKET_PRIVATE_H_
+
+#include "native_client/src/include/nacl_macros.h"
+#include "ppapi/c/private/ppb_tcp_socket_private.h"
+
+namespace ppapi_proxy {
+
+// Implements the untrusted side of the PPB_TCPSocket_Private interface.
+class PluginTCPSocketPrivate {
+ public:
+  static const PPB_TCPSocket_Private* GetInterface();
+
+ private:
+  NACL_DISALLOW_COPY_AND_ASSIGN(PluginTCPSocketPrivate);
+};
+
+}  // namespace ppapi_proxy
+
+#endif  // NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_TCP_SOCKET_PRIVATE_H_
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_udp_socket_private.cc b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_udp_socket_private.cc
new file mode 100644
index 0000000..1c21d28
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_udp_socket_private.cc
@@ -0,0 +1,212 @@
+// Copyright (c) 2011 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 "native_client/src/shared/ppapi_proxy/plugin_ppb_udp_socket_private.h"
+
+#include <string.h>
+#include "native_client/src/include/nacl_macros.h"
+#include "native_client/src/include/portability.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_callback.h"
+#include "native_client/src/shared/ppapi_proxy/plugin_globals.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "native_client/src/shared/srpc/nacl_srpc.h"
+#include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_udp_socket_private.h"
+#include "srpcgen/ppb_rpc.h"
+
+namespace ppapi_proxy {
+
+namespace {
+
+PP_Resource Create(PP_Instance instance_id) {
+  DebugPrintf("PPB_UDPSocket_Private::Create: instance_id=%"NACL_PRIu32"\n",
+              instance_id);
+
+  PP_Resource resource;
+  NaClSrpcError srpc_result =
+      PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_Create(
+          GetMainSrpcChannel(),
+          instance_id,
+          &resource);
+
+  DebugPrintf("PPB_UDPSocket_Private::Create: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK)
+    return resource;
+  else
+    return kInvalidResourceId;
+}
+
+PP_Bool IsUDPSocket(PP_Resource resource_id) {
+  DebugPrintf("PPB_UDPSocket_Private::IsUDPSocket: "
+              "resource_id=%"NACL_PRIu32"\n", resource_id);
+
+  int32_t is_udp_socket;
+  NaClSrpcError srpc_result =
+      PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_IsUDPSocket(
+          GetMainSrpcChannel(), resource_id, &is_udp_socket);
+
+  DebugPrintf("PPB_UDPSocket_Private::IsUDPSocket: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK && is_udp_socket)
+    return PP_TRUE;
+  return PP_FALSE;
+}
+
+int32_t Bind(PP_Resource udp_socket, const struct PP_NetAddress_Private* addr,
+             struct PP_CompletionCallback callback) {
+  DebugPrintf("PPB_UDPSocket_Private::Bind: "
+              "udp_socket=%"NACL_PRIu32"\n", udp_socket);
+
+  int32_t callback_id = CompletionCallbackTable::Get()->AddCallback(callback);
+  if (callback_id == 0)  // Just like Chrome, for now disallow blocking calls.
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  char* const raw_addr =
+      reinterpret_cast<char*>(const_cast<struct PP_NetAddress_Private*>(addr));
+
+  int32_t pp_error = PP_ERROR_FAILED;
+  NaClSrpcError srpc_result =
+      PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_Bind(
+          GetMainSrpcChannel(),
+          udp_socket,
+          sizeof(PP_NetAddress_Private), raw_addr,
+          callback_id,
+          &pp_error);
+
+  DebugPrintf("PPB_UDPSocket_Private::Bind: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error);
+}
+
+int32_t RecvFrom(PP_Resource udp_socket, char* buffer, int32_t num_bytes,
+                 struct PP_CompletionCallback callback) {
+  DebugPrintf("PPB_UDPSocket_Private::RecvFrom: udp_socket=%"NACL_PRIu32", "
+              "num_bytes=%"NACL_PRId32"\n", udp_socket, num_bytes);
+
+  if (num_bytes < 0)
+    num_bytes = 0;
+  nacl_abi_size_t buffer_size = static_cast<nacl_abi_size_t>(num_bytes);
+
+  int32_t callback_id =
+      CompletionCallbackTable::Get()->AddCallback(callback, buffer);
+  if (callback_id == 0)  // Just like Chrome, for now disallow blocking calls.
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  int32_t pp_error_or_bytes;
+  NaClSrpcError srpc_result =
+      PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_RecvFrom(
+          GetMainSrpcChannel(),
+          udp_socket,
+          num_bytes,
+          callback_id,
+          &buffer_size,
+          buffer,
+          &pp_error_or_bytes);
+
+  DebugPrintf("PPB_UDPSocket_Private::RecvFrom: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error_or_bytes = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error_or_bytes);
+}
+
+PP_Bool GetRecvFromAddress(PP_Resource udp_socket,
+                           struct PP_NetAddress_Private* addr) {
+  DebugPrintf("PPB_UDPSocket_Private::GetRecvFromAddress: "
+              "udp_socket="NACL_PRIu32"\n", udp_socket);
+
+  nacl_abi_size_t addr_bytes;
+  int32_t success;
+  NaClSrpcError srpc_result =
+      PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_GetRecvFromAddress(
+          GetMainSrpcChannel(),
+          udp_socket,
+          &addr_bytes,
+          reinterpret_cast<char*>(addr),
+          &success);
+
+  DebugPrintf("PPB_UDPSocket_Private::GetRecvFromAddress: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result == NACL_SRPC_RESULT_OK && success)
+    return PP_TRUE;
+  return PP_FALSE;
+}
+
+int32_t SendTo(PP_Resource udp_socket, const char* buffer, int32_t num_bytes,
+               const struct PP_NetAddress_Private* addr,
+               struct PP_CompletionCallback callback) {
+  DebugPrintf("PPB_UDPSocket_Private::SendTo: udp_socket="NACL_PRIu32", "
+              "num_bytes="NACL_PRId32"\n", udp_socket, num_bytes);
+
+  if (num_bytes < 0)
+    num_bytes = 0;
+  nacl_abi_size_t buffer_size = static_cast<nacl_abi_size_t>(num_bytes);
+
+  int32_t callback_id =
+      CompletionCallbackTable::Get()->AddCallback(callback);
+  if (callback_id == 0)  // Just like Chrome, for now disallow blocking calls.
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  char* const raw_addr =
+      reinterpret_cast<char*>(const_cast<struct PP_NetAddress_Private*>(addr));
+
+  int32_t pp_error_or_bytes = PP_ERROR_FAILED;
+  NaClSrpcError srpc_result =
+      PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_SendTo(
+          GetMainSrpcChannel(),
+          udp_socket,
+          buffer_size,
+          const_cast<char*>(buffer),
+          num_bytes,
+          static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private)),
+          raw_addr,
+          callback_id,
+          &pp_error_or_bytes);
+
+  DebugPrintf("PPB_UDPSocket_Private::SendTo: %s\n",
+              NaClSrpcErrorString(srpc_result));
+
+  if (srpc_result != NACL_SRPC_RESULT_OK)
+    pp_error_or_bytes = PP_ERROR_FAILED;
+  return MayForceCallback(callback, pp_error_or_bytes);
+}
+
+void Close(PP_Resource udp_socket) {
+  DebugPrintf("PPB_UDPSocket_Private::Close: "
+              "udp_socket="NACL_PRIu32"\n", udp_socket);
+
+  NaClSrpcError srpc_result =
+      PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_Close(
+          GetMainSrpcChannel(),
+          udp_socket);
+
+  DebugPrintf("PPB_UDPSocket_Private::Close: %s\n",
+              NaClSrpcErrorString(srpc_result));
+}
+
+}  // namespace
+
+const PPB_UDPSocket_Private* PluginUDPSocketPrivate::GetInterface() {
+  static const PPB_UDPSocket_Private udpsocket_private_interface = {
+    Create,
+    IsUDPSocket,
+    Bind,
+    RecvFrom,
+    GetRecvFromAddress,
+    SendTo,
+    Close,
+  };
+  return &udpsocket_private_interface;
+}
+
+}  // namespace ppapi_proxy
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_udp_socket_private.h b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_udp_socket_private.h
new file mode 100644
index 0000000..efd5d16
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_udp_socket_private.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2011 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.
+
+#ifndef NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_UDP_SOCKET_PRIVATE_H_
+#define NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_UDP_SOCKET_PRIVATE_H_
+
+#include "native_client/src/include/nacl_macros.h"
+#include "ppapi/c/private/ppb_udp_socket_private.h"
+
+namespace ppapi_proxy {
+
+// Implements the untrusted side of the PPB_UDPSocket_Private interface.
+class PluginUDPSocketPrivate {
+ public:
+  static const PPB_UDPSocket_Private* GetInterface();
+
+ private:
+  NACL_DISALLOW_COPY_AND_ASSIGN(PluginUDPSocketPrivate);
+};
+
+}  // namespace ppapi_proxy
+
+#endif  // NATIVE_CLIENT_SRC_SHARED_PPAPI_PROXY_PLUGIN_UDP_SOCKET_PRIVATE_H_
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/ppapi_proxy.gyp b/ppapi/native_client/src/shared/ppapi_proxy/ppapi_proxy.gyp
index 4686b9b..21a905e 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/ppapi_proxy.gyp
+++ b/ppapi/native_client/src/shared/ppapi_proxy/ppapi_proxy.gyp
@@ -34,7 +34,9 @@
         'browser_ppb_pdf_rpc_server.cc',
         'browser_ppb_rpc_server.cc',
         'browser_ppb_scrollbar_rpc_server.cc',
+        'browser_ppb_tcp_socket_private_rpc_server.cc',
         'browser_ppb_testing_rpc_server.cc',
+        'browser_ppb_udp_socket_private_rpc_server.cc',
         'browser_ppb_url_loader_rpc_server.cc',
         'browser_ppb_url_request_info_rpc_server.cc',
         'browser_ppb_url_response_info_rpc_server.cc',
@@ -131,7 +133,9 @@
           'plugin_ppb_mouse_lock.cc',
           'plugin_ppb_pdf.cc',
           'plugin_ppb_scrollbar.cc',
+          'plugin_ppb_tcp_socket_private.cc',
           'plugin_ppb_testing.cc',
+          'plugin_ppb_udp_socket_private.cc',
           'plugin_ppb_url_loader.cc',
           'plugin_ppb_url_request_info.cc',
           'plugin_ppb_url_response_info.cc',
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc b/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc
index f4f0490..20ebd55 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_client.cc
@@ -2289,6 +2289,206 @@ NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_ScrollBy(
   return retval;
 }
 
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Create(
+    NaClSrpcChannel* channel,
+    PP_Instance instance,
+    PP_Resource* resource)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_Create:i:i",
+      instance,
+      resource
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_IsTCPSocket(
+    NaClSrpcChannel* channel,
+    PP_Resource resource,
+    int32_t* is_tcp_socket)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_IsTCPSocket:i:i",
+      resource,
+      is_tcp_socket
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Connect(
+    NaClSrpcChannel* channel,
+    PP_Resource tcp_socket,
+    char* host,
+    int32_t port,
+    int32_t callback_id,
+    int32_t* pp_error)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_Connect:isii:i",
+      tcp_socket,
+      host,
+      port,
+      callback_id,
+      pp_error
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_ConnectWithNetAddress(
+    NaClSrpcChannel* channel,
+    PP_Resource tcp_socket,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t callback_id,
+    int32_t* pp_error)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_ConnectWithNetAddress:iCi:i",
+      tcp_socket,
+      addr_bytes, addr,
+      callback_id,
+      pp_error
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_GetLocalAddress(
+    NaClSrpcChannel* channel,
+    PP_Resource tcp_socket,
+    nacl_abi_size_t* local_addr_bytes, char* local_addr,
+    int32_t* success)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_GetLocalAddress:i:Ci",
+      tcp_socket,
+      local_addr_bytes, local_addr,
+      success
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_GetRemoteAddress(
+    NaClSrpcChannel* channel,
+    PP_Resource tcp_socket,
+    nacl_abi_size_t* remote_addr_bytes, char* remote_addr,
+    int32_t* success)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_GetRemoteAddress:i:Ci",
+      tcp_socket,
+      remote_addr_bytes, remote_addr,
+      success
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_SSLHandshake(
+    NaClSrpcChannel* channel,
+    PP_Resource tcp_socket,
+    char* server_name,
+    int32_t server_port,
+    int32_t callback_id,
+    int32_t* pp_error)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_SSLHandshake:isii:i",
+      tcp_socket,
+      server_name,
+      server_port,
+      callback_id,
+      pp_error
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Read(
+    NaClSrpcChannel* channel,
+    PP_Resource tcp_socket,
+    int32_t bytes_to_read,
+    int32_t callback_id,
+    nacl_abi_size_t* buffer_bytes, char* buffer,
+    int32_t* pp_error_or_bytes)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_Read:iii:Ci",
+      tcp_socket,
+      bytes_to_read,
+      callback_id,
+      buffer_bytes, buffer,
+      pp_error_or_bytes
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Write(
+    NaClSrpcChannel* channel,
+    PP_Resource tcp_socket,
+    nacl_abi_size_t buffer_bytes, char* buffer,
+    int32_t bytes_to_write,
+    int32_t callback_id,
+    int32_t* pp_error_or_bytes)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_Write:iCii:i",
+      tcp_socket,
+      buffer_bytes, buffer,
+      bytes_to_write,
+      callback_id,
+      pp_error_or_bytes
+  );
+  return retval;
+}
+
+NaClSrpcError PpbTCPSocketPrivateRpcClient::PPB_TCPSocket_Private_Disconnect(
+    NaClSrpcChannel* channel,
+    PP_Resource tcp_socket)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_TCPSocket_Private_Disconnect:i:",
+      tcp_socket
+  );
+  return retval;
+}
+
 NaClSrpcError PpbTestingRpcClient::PPB_Testing_ReadImageData(
     NaClSrpcChannel* channel,
     PP_Resource device_context_2d,
@@ -2357,6 +2557,143 @@ NaClSrpcError PpbTestingRpcClient::PPB_Testing_GetLiveObjectsForInstance(
   return retval;
 }
 
+NaClSrpcError PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_Create(
+    NaClSrpcChannel* channel,
+    PP_Instance instance_id,
+    PP_Resource* resource)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_UDPSocket_Private_Create:i:i",
+      instance_id,
+      resource
+  );
+  return retval;
+}
+
+NaClSrpcError PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_IsUDPSocket(
+    NaClSrpcChannel* channel,
+    PP_Resource resource_id,
+    int32_t* is_udp_socket_private)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_UDPSocket_Private_IsUDPSocket:i:i",
+      resource_id,
+      is_udp_socket_private
+  );
+  return retval;
+}
+
+NaClSrpcError PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_Bind(
+    NaClSrpcChannel* channel,
+    PP_Resource udp_socket,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t callback_id,
+    int32_t* pp_error)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_UDPSocket_Private_Bind:iCi:i",
+      udp_socket,
+      addr_bytes, addr,
+      callback_id,
+      pp_error
+  );
+  return retval;
+}
+
+NaClSrpcError PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_RecvFrom(
+    NaClSrpcChannel* channel,
+    PP_Resource udp_socket,
+    int32_t num_bytes,
+    int32_t callback_id,
+    nacl_abi_size_t* buffer_bytes, char* buffer,
+    int32_t* pp_error_or_bytes)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_UDPSocket_Private_RecvFrom:iii:Ci",
+      udp_socket,
+      num_bytes,
+      callback_id,
+      buffer_bytes, buffer,
+      pp_error_or_bytes
+  );
+  return retval;
+}
+
+NaClSrpcError PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_GetRecvFromAddress(
+    NaClSrpcChannel* channel,
+    PP_Resource udp_socket,
+    nacl_abi_size_t* addr_bytes, char* addr,
+    int32_t* success)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_UDPSocket_Private_GetRecvFromAddress:i:Ci",
+      udp_socket,
+      addr_bytes, addr,
+      success
+  );
+  return retval;
+}
+
+NaClSrpcError PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_SendTo(
+    NaClSrpcChannel* channel,
+    PP_Resource udp_socket,
+    nacl_abi_size_t buffer_bytes, char* buffer,
+    int32_t num_bytes,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t callback_id,
+    int32_t* pp_error_or_bytes)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_UDPSocket_Private_SendTo:iCiCi:i",
+      udp_socket,
+      buffer_bytes, buffer,
+      num_bytes,
+      addr_bytes, addr,
+      callback_id,
+      pp_error_or_bytes
+  );
+  return retval;
+}
+
+NaClSrpcError PpbUDPSocketPrivateRpcClient::PPB_UDPSocket_Private_Close(
+    NaClSrpcChannel* channel,
+    PP_Resource udp_socket)  {
+  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),
+         ("%s: PPAPI calls are not supported off the main thread\n",
+          __FUNCTION__));
+  NaClSrpcError retval;
+  retval = NaClSrpcInvokeBySignature(
+      channel,
+      "PPB_UDPSocket_Private_Close:i:",
+      udp_socket
+  );
+  return retval;
+}
+
 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_Create(
     NaClSrpcChannel* channel,
     PP_Instance instance,
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc b/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc
index bdbb00e..54187d0 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc
+++ b/ppapi/native_client/src/shared/ppapi_proxy/ppb_rpc_server.cc
@@ -1843,6 +1843,162 @@ static void PPB_Scrollbar_ScrollByDispatcher(
   );
 }
 
+static void PPB_TCPSocket_Private_CreateDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Create(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_IsTCPSocketDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_IsTCPSocket(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_ConnectDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Connect(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->arrays.str,
+      inputs[2]->u.ival,
+      inputs[3]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_ConnectWithNetAddressDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_ConnectWithNetAddress(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->u.count, inputs[1]->arrays.carr,
+      inputs[2]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_GetLocalAddressDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_GetLocalAddress(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.count), outputs[0]->arrays.carr,
+      &(outputs[1]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_GetRemoteAddressDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_GetRemoteAddress(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.count), outputs[0]->arrays.carr,
+      &(outputs[1]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_SSLHandshakeDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_SSLHandshake(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->arrays.str,
+      inputs[2]->u.ival,
+      inputs[3]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_ReadDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Read(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->u.ival,
+      inputs[2]->u.ival,
+      &(outputs[0]->u.count), outputs[0]->arrays.carr,
+      &(outputs[1]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_WriteDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Write(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->u.count, inputs[1]->arrays.carr,
+      inputs[2]->u.ival,
+      inputs[3]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_TCPSocket_Private_DisconnectDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  UNREFERENCED_PARAMETER(outputs);
+  PpbTCPSocketPrivateRpcServer::PPB_TCPSocket_Private_Disconnect(
+      rpc,
+      done,
+      inputs[0]->u.ival
+  );
+}
+
 static void PPB_Testing_ReadImageDataDispatcher(
     NaClSrpcRpc* rpc,
     NaClSrpcArg** inputs,
@@ -1901,6 +2057,114 @@ static void PPB_Testing_GetLiveObjectsForInstanceDispatcher(
   );
 }
 
+static void PPB_UDPSocket_Private_CreateDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_Create(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_UDPSocket_Private_IsUDPSocketDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_IsUDPSocket(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_UDPSocket_Private_BindDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_Bind(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->u.count, inputs[1]->arrays.carr,
+      inputs[2]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_UDPSocket_Private_RecvFromDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_RecvFrom(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->u.ival,
+      inputs[2]->u.ival,
+      &(outputs[0]->u.count), outputs[0]->arrays.carr,
+      &(outputs[1]->u.ival)
+  );
+}
+
+static void PPB_UDPSocket_Private_GetRecvFromAddressDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_GetRecvFromAddress(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      &(outputs[0]->u.count), outputs[0]->arrays.carr,
+      &(outputs[1]->u.ival)
+  );
+}
+
+static void PPB_UDPSocket_Private_SendToDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_SendTo(
+      rpc,
+      done,
+      inputs[0]->u.ival,
+      inputs[1]->u.count, inputs[1]->arrays.carr,
+      inputs[2]->u.ival,
+      inputs[3]->u.count, inputs[3]->arrays.carr,
+      inputs[4]->u.ival,
+      &(outputs[0]->u.ival)
+  );
+}
+
+static void PPB_UDPSocket_Private_CloseDispatcher(
+    NaClSrpcRpc* rpc,
+    NaClSrpcArg** inputs,
+    NaClSrpcArg** outputs,
+    NaClSrpcClosure* done
+) {
+  UNREFERENCED_PARAMETER(outputs);
+  PpbUDPSocketPrivateRpcServer::PPB_UDPSocket_Private_Close(
+      rpc,
+      done,
+      inputs[0]->u.ival
+  );
+}
+
 static void PPB_URLLoader_CreateDispatcher(
     NaClSrpcRpc* rpc,
     NaClSrpcArg** inputs,
@@ -2400,10 +2664,27 @@ NaClSrpcHandlerDesc PpbRpcs::srpc_methods[] = {
   { "PPB_Scrollbar_SetDocumentSize:ii:", PPB_Scrollbar_SetDocumentSizeDispatcher },
   { "PPB_Scrollbar_SetTickMarks:iCi:", PPB_Scrollbar_SetTickMarksDispatcher },
   { "PPB_Scrollbar_ScrollBy:iii:", PPB_Scrollbar_ScrollByDispatcher },
+  { "PPB_TCPSocket_Private_Create:i:i", PPB_TCPSocket_Private_CreateDispatcher },
+  { "PPB_TCPSocket_Private_IsTCPSocket:i:i", PPB_TCPSocket_Private_IsTCPSocketDispatcher },
+  { "PPB_TCPSocket_Private_Connect:isii:i", PPB_TCPSocket_Private_ConnectDispatcher },
+  { "PPB_TCPSocket_Private_ConnectWithNetAddress:iCi:i", PPB_TCPSocket_Private_ConnectWithNetAddressDispatcher },
+  { "PPB_TCPSocket_Private_GetLocalAddress:i:Ci", PPB_TCPSocket_Private_GetLocalAddressDispatcher },
+  { "PPB_TCPSocket_Private_GetRemoteAddress:i:Ci", PPB_TCPSocket_Private_GetRemoteAddressDispatcher },
+  { "PPB_TCPSocket_Private_SSLHandshake:isii:i", PPB_TCPSocket_Private_SSLHandshakeDispatcher },
+  { "PPB_TCPSocket_Private_Read:iii:Ci", PPB_TCPSocket_Private_ReadDispatcher },
+  { "PPB_TCPSocket_Private_Write:iCii:i", PPB_TCPSocket_Private_WriteDispatcher },
+  { "PPB_TCPSocket_Private_Disconnect:i:", PPB_TCPSocket_Private_DisconnectDispatcher },
   { "PPB_Testing_ReadImageData:iiC:i", PPB_Testing_ReadImageDataDispatcher },
   { "PPB_Testing_RunMessageLoop:i:", PPB_Testing_RunMessageLoopDispatcher },
   { "PPB_Testing_QuitMessageLoop:i:", PPB_Testing_QuitMessageLoopDispatcher },
   { "PPB_Testing_GetLiveObjectsForInstance:i:i", PPB_Testing_GetLiveObjectsForInstanceDispatcher },
+  { "PPB_UDPSocket_Private_Create:i:i", PPB_UDPSocket_Private_CreateDispatcher },
+  { "PPB_UDPSocket_Private_IsUDPSocket:i:i", PPB_UDPSocket_Private_IsUDPSocketDispatcher },
+  { "PPB_UDPSocket_Private_Bind:iCi:i", PPB_UDPSocket_Private_BindDispatcher },
+  { "PPB_UDPSocket_Private_RecvFrom:iii:Ci", PPB_UDPSocket_Private_RecvFromDispatcher },
+  { "PPB_UDPSocket_Private_GetRecvFromAddress:i:Ci", PPB_UDPSocket_Private_GetRecvFromAddressDispatcher },
+  { "PPB_UDPSocket_Private_SendTo:iCiCi:i", PPB_UDPSocket_Private_SendToDispatcher },
+  { "PPB_UDPSocket_Private_Close:i:", PPB_UDPSocket_Private_CloseDispatcher },
   { "PPB_URLLoader_Create:i:i", PPB_URLLoader_CreateDispatcher },
   { "PPB_URLLoader_IsURLLoader:i:i", PPB_URLLoader_IsURLLoaderDispatcher },
   { "PPB_URLLoader_Open:iii:i", PPB_URLLoader_OpenDispatcher },
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/ppb_tcp_socket_private.srpc b/ppapi/native_client/src/shared/ppapi_proxy/ppb_tcp_socket_private.srpc
new file mode 100644
index 0000000..f8f805a
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/ppb_tcp_socket_private.srpc
@@ -0,0 +1,87 @@
+# Copyright (c) 2011 The Native Client Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+#
+# RPC methods used to implement PPB_TCPSocket_Private calls from the plugin.
+# See ppapi/c/private/ppb_tcp_socket_private.h for interface details.
+
+{
+  'name': 'PpbTCPSocketPrivateRpc',
+  'rpcs': [
+    {'name': 'PPB_TCPSocket_Private_Create',
+     'inputs': [['instance', 'PP_Instance'],         # PP_Instance
+               ],
+     'outputs': [['resource', 'PP_Resource'],        # PP_Resource
+                ]
+    },
+    {'name': 'PPB_TCPSocket_Private_IsTCPSocket',
+     'inputs': [['resource', 'PP_Resource'],         # PP_Resource
+               ],
+     'outputs': [['is_tcp_socket', 'int32_t'],       # PP_Bool
+                ]
+    },
+    {'name': 'PPB_TCPSocket_Private_Connect',
+     'inputs': [['tcp_socket', 'PP_Resource'],       # PP_Resource
+                ['host', 'string'],                  # const char*
+                ['port', 'int32_t'],                 # uint16_t
+                ['callback_id', 'int32_t'],          # PP_CompletionCallback
+                ],
+     'outputs': [['pp_error', 'int32_t'],
+                 ]
+    },
+    {'name': 'PPB_TCPSocket_Private_ConnectWithNetAddress',
+     'inputs': [['tcp_socket', 'PP_Resource'],       # PP_Resource
+                ['addr', 'char[]'],                  # PP_NetAddress_Private*
+                ['callback_id', 'int32_t'],          # PP_CompletionCallback
+                ],
+     'outputs': [['pp_error', 'int32_t'],
+                 ]
+    },
+    {'name': 'PPB_TCPSocket_Private_GetLocalAddress',
+     'inputs': [['tcp_socket', 'PP_Resource'],       # PP_Resource
+                ],
+     'outputs': [['local_addr', 'char[]'],           # PP_NetAddress_Private*
+                 ['success', 'int32_t'],             # PP_Bool
+                 ]
+    },
+    {'name': 'PPB_TCPSocket_Private_GetRemoteAddress',
+     'inputs': [['tcp_socket', 'PP_Resource'],       # PP_Resource
+                ],
+     'outputs': [['remote_addr', 'char[]'],          # PP_NetAddress_Private*
+                 ['success', 'int32_t'],             # PP_Bool
+                 ]
+    },
+    {'name': 'PPB_TCPSocket_Private_SSLHandshake',
+     'inputs': [['tcp_socket', 'PP_Resource'],       # PP_Resource
+                ['server_name', 'string'],           # const char*
+                ['server_port', 'int32_t'],          # uint16_t
+                ['callback_id', 'int32_t'],          # PP_CompletionCallback
+		],
+     'outputs': [['pp_error', 'int32_t'],
+                 ]
+    },
+    {'name': 'PPB_TCPSocket_Private_Read',
+     'inputs': [['tcp_socket', 'PP_Resource'],       # PP_Resource
+                ['bytes_to_read', 'int32_t'],
+		['callback_id', 'int32_t'],          # PP_CompletionCallback
+		],
+     'outputs': [['buffer', 'char[]'],               # char*
+                 ['pp_error_or_bytes', 'int32_t'],
+		 ]
+    },
+    {'name': 'PPB_TCPSocket_Private_Write',
+     'inputs': [['tcp_socket', 'PP_Resource'],       # PP_Resource
+                ['buffer', 'char[]'],                # const char*
+                ['bytes_to_write', 'int32_t'],
+                ['callback_id', 'int32_t'],          # PP_CompletionCallback
+		],
+     'outputs': [['pp_error_or_bytes', 'int32_t'],
+                 ]
+    },
+    {'name': 'PPB_TCPSocket_Private_Disconnect',
+     'inputs': [['tcp_socket', 'PP_Resource'],       # PP_Resource
+                ],
+     'outputs': []
+    },
+   ]
+}
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/ppb_udp_socket_private.srpc b/ppapi/native_client/src/shared/ppapi_proxy/ppb_udp_socket_private.srpc
new file mode 100644
index 0000000..7268093
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/ppb_udp_socket_private.srpc
@@ -0,0 +1,63 @@
+# Copyright (c) 2011 The Native Client Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+#
+# RPC methods used to implement PPB_UDPSocket_Private calls from the plugin.
+# See ppapi/c/private/ppb_udp_socket_private.h for interface details.
+
+{
+  'name': 'PpbUDPSocketPrivateRpc',
+  'rpcs': [
+    {'name': 'PPB_UDPSocket_Private_Create',
+     'inputs': [['instance_id', 'PP_Instance'],        # PP_Instance
+                ],
+     'outputs': [['resource', 'PP_Resource'],          # PP_Resource
+                 ]
+    },
+    {'name': 'PPB_UDPSocket_Private_IsUDPSocket',
+     'inputs': [['resource_id', 'PP_Resource'],        # PP_Resource
+                ],
+     'outputs': [['is_udp_socket_private', 'int32_t'], # PP_Bool
+                 ]
+    },
+    {'name': 'PPB_UDPSocket_Private_Bind',
+     'inputs': [['udp_socket', 'PP_Resource'],         # PP_Resource
+                ['addr', 'char[]'],                    # PP_NetAddress_Private*
+                ['callback_id', 'int32_t'],            # PP_CompletionCallback
+		],
+     'outputs': [['pp_error', 'int32_t'],
+                 ]
+    },
+    {'name': 'PPB_UDPSocket_Private_RecvFrom',
+     'inputs': [['udp_socket', 'PP_Resource'],         # PP_Resource
+                ['num_bytes', 'int32_t'],
+                ['callback_id', 'int32_t'],            # PP_CompletionCallback
+                ],
+     'outputs': [['buffer', 'char[]'],                 # char*
+                 ['pp_error_or_bytes', 'int32_t'],
+                 ]
+    },
+    {'name': 'PPB_UDPSocket_Private_GetRecvFromAddress',
+     'inputs': [['udp_socket', 'PP_Resource'],         # PP_Resource
+                ],
+     'outputs': [['addr', 'char[]'],                   # PP_NetAddress_Private*
+                 ['success', 'int32_t'],               # PP_Bool
+		 ]
+    },
+    {'name': 'PPB_UDPSocket_Private_SendTo',
+     'inputs': [['udp_socket', 'PP_Resource'],         # PP_Resource
+                ['buffer', 'char[]'],                  # const char*
+                ['num_bytes', 'int32_t'],
+                ['addr', 'char[]'],                    # PP_NetAddress_Private*
+                ['callback_id', 'int32_t']             # PP_CompletionCallback
+                ],
+     'outputs': [['pp_error_or_bytes', 'int32_t'],
+                 ]
+    },
+    {'name': 'PPB_UDPSocket_Private_Close',
+     'inputs': [['udp_socket', 'PP_Resource'],         # PP_Resource
+                ],
+     'outputs': []
+    },
+   ]
+}
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h b/ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h
index 46f80d1..25feea6 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h
+++ b/ppapi/native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppb_rpc.h
@@ -927,6 +927,80 @@ class PpbScrollbarRpcServer {
   void operator=(const PpbScrollbarRpcServer);
 };  // class PpbScrollbarRpcServer
 
+class PpbTCPSocketPrivateRpcServer {
+ public:
+  static void PPB_TCPSocket_Private_Create(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Instance instance,
+      PP_Resource* resource);
+  static void PPB_TCPSocket_Private_IsTCPSocket(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource resource,
+      int32_t* is_tcp_socket);
+  static void PPB_TCPSocket_Private_Connect(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource tcp_socket,
+      char* host,
+      int32_t port,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static void PPB_TCPSocket_Private_ConnectWithNetAddress(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource tcp_socket,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static void PPB_TCPSocket_Private_GetLocalAddress(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource tcp_socket,
+      nacl_abi_size_t* local_addr_bytes, char* local_addr,
+      int32_t* success);
+  static void PPB_TCPSocket_Private_GetRemoteAddress(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource tcp_socket,
+      nacl_abi_size_t* remote_addr_bytes, char* remote_addr,
+      int32_t* success);
+  static void PPB_TCPSocket_Private_SSLHandshake(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource tcp_socket,
+      char* server_name,
+      int32_t server_port,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static void PPB_TCPSocket_Private_Read(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource tcp_socket,
+      int32_t bytes_to_read,
+      int32_t callback_id,
+      nacl_abi_size_t* buffer_bytes, char* buffer,
+      int32_t* pp_error_or_bytes);
+  static void PPB_TCPSocket_Private_Write(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource tcp_socket,
+      nacl_abi_size_t buffer_bytes, char* buffer,
+      int32_t bytes_to_write,
+      int32_t callback_id,
+      int32_t* pp_error_or_bytes);
+  static void PPB_TCPSocket_Private_Disconnect(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource tcp_socket);
+
+ private:
+  PpbTCPSocketPrivateRpcServer();
+  PpbTCPSocketPrivateRpcServer(const PpbTCPSocketPrivateRpcServer&);
+  void operator=(const PpbTCPSocketPrivateRpcServer);
+};  // class PpbTCPSocketPrivateRpcServer
+
 class PpbTestingRpcServer {
  public:
   static void PPB_Testing_ReadImageData(
@@ -956,6 +1030,59 @@ class PpbTestingRpcServer {
   void operator=(const PpbTestingRpcServer);
 };  // class PpbTestingRpcServer
 
+class PpbUDPSocketPrivateRpcServer {
+ public:
+  static void PPB_UDPSocket_Private_Create(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Instance instance_id,
+      PP_Resource* resource);
+  static void PPB_UDPSocket_Private_IsUDPSocket(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource resource_id,
+      int32_t* is_udp_socket_private);
+  static void PPB_UDPSocket_Private_Bind(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource udp_socket,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static void PPB_UDPSocket_Private_RecvFrom(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource udp_socket,
+      int32_t num_bytes,
+      int32_t callback_id,
+      nacl_abi_size_t* buffer_bytes, char* buffer,
+      int32_t* pp_error_or_bytes);
+  static void PPB_UDPSocket_Private_GetRecvFromAddress(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource udp_socket,
+      nacl_abi_size_t* addr_bytes, char* addr,
+      int32_t* success);
+  static void PPB_UDPSocket_Private_SendTo(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource udp_socket,
+      nacl_abi_size_t buffer_bytes, char* buffer,
+      int32_t num_bytes,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t callback_id,
+      int32_t* pp_error_or_bytes);
+  static void PPB_UDPSocket_Private_Close(
+      NaClSrpcRpc* rpc,
+      NaClSrpcClosure* done,
+      PP_Resource udp_socket);
+
+ private:
+  PpbUDPSocketPrivateRpcServer();
+  PpbUDPSocketPrivateRpcServer(const PpbUDPSocketPrivateRpcServer&);
+  void operator=(const PpbUDPSocketPrivateRpcServer);
+};  // class PpbUDPSocketPrivateRpcServer
+
 class PpbURLLoaderRpcServer {
  public:
   static void PPB_URLLoader_Create(
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h b/ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h
index aedb2da..aa2f7d0 100644
--- a/ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h
+++ b/ppapi/native_client/src/shared/ppapi_proxy/untrusted/srpcgen/ppb_rpc.h
@@ -808,6 +808,70 @@ class PpbScrollbarRpcClient {
   void operator=(const PpbScrollbarRpcClient);
 };  // class PpbScrollbarRpcClient
 
+class PpbTCPSocketPrivateRpcClient {
+ public:
+  static NaClSrpcError PPB_TCPSocket_Private_Create(
+      NaClSrpcChannel* channel,
+      PP_Instance instance,
+      PP_Resource* resource);
+  static NaClSrpcError PPB_TCPSocket_Private_IsTCPSocket(
+      NaClSrpcChannel* channel,
+      PP_Resource resource,
+      int32_t* is_tcp_socket);
+  static NaClSrpcError PPB_TCPSocket_Private_Connect(
+      NaClSrpcChannel* channel,
+      PP_Resource tcp_socket,
+      char* host,
+      int32_t port,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static NaClSrpcError PPB_TCPSocket_Private_ConnectWithNetAddress(
+      NaClSrpcChannel* channel,
+      PP_Resource tcp_socket,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static NaClSrpcError PPB_TCPSocket_Private_GetLocalAddress(
+      NaClSrpcChannel* channel,
+      PP_Resource tcp_socket,
+      nacl_abi_size_t* local_addr_bytes, char* local_addr,
+      int32_t* success);
+  static NaClSrpcError PPB_TCPSocket_Private_GetRemoteAddress(
+      NaClSrpcChannel* channel,
+      PP_Resource tcp_socket,
+      nacl_abi_size_t* remote_addr_bytes, char* remote_addr,
+      int32_t* success);
+  static NaClSrpcError PPB_TCPSocket_Private_SSLHandshake(
+      NaClSrpcChannel* channel,
+      PP_Resource tcp_socket,
+      char* server_name,
+      int32_t server_port,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static NaClSrpcError PPB_TCPSocket_Private_Read(
+      NaClSrpcChannel* channel,
+      PP_Resource tcp_socket,
+      int32_t bytes_to_read,
+      int32_t callback_id,
+      nacl_abi_size_t* buffer_bytes, char* buffer,
+      int32_t* pp_error_or_bytes);
+  static NaClSrpcError PPB_TCPSocket_Private_Write(
+      NaClSrpcChannel* channel,
+      PP_Resource tcp_socket,
+      nacl_abi_size_t buffer_bytes, char* buffer,
+      int32_t bytes_to_write,
+      int32_t callback_id,
+      int32_t* pp_error_or_bytes);
+  static NaClSrpcError PPB_TCPSocket_Private_Disconnect(
+      NaClSrpcChannel* channel,
+      PP_Resource tcp_socket);
+
+ private:
+  PpbTCPSocketPrivateRpcClient();
+  PpbTCPSocketPrivateRpcClient(const PpbTCPSocketPrivateRpcClient&);
+  void operator=(const PpbTCPSocketPrivateRpcClient);
+};  // class PpbTCPSocketPrivateRpcClient
+
 class PpbTestingRpcClient {
  public:
   static NaClSrpcError PPB_Testing_ReadImageData(
@@ -833,6 +897,52 @@ class PpbTestingRpcClient {
   void operator=(const PpbTestingRpcClient);
 };  // class PpbTestingRpcClient
 
+class PpbUDPSocketPrivateRpcClient {
+ public:
+  static NaClSrpcError PPB_UDPSocket_Private_Create(
+      NaClSrpcChannel* channel,
+      PP_Instance instance_id,
+      PP_Resource* resource);
+  static NaClSrpcError PPB_UDPSocket_Private_IsUDPSocket(
+      NaClSrpcChannel* channel,
+      PP_Resource resource_id,
+      int32_t* is_udp_socket_private);
+  static NaClSrpcError PPB_UDPSocket_Private_Bind(
+      NaClSrpcChannel* channel,
+      PP_Resource udp_socket,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t callback_id,
+      int32_t* pp_error);
+  static NaClSrpcError PPB_UDPSocket_Private_RecvFrom(
+      NaClSrpcChannel* channel,
+      PP_Resource udp_socket,
+      int32_t num_bytes,
+      int32_t callback_id,
+      nacl_abi_size_t* buffer_bytes, char* buffer,
+      int32_t* pp_error_or_bytes);
+  static NaClSrpcError PPB_UDPSocket_Private_GetRecvFromAddress(
+      NaClSrpcChannel* channel,
+      PP_Resource udp_socket,
+      nacl_abi_size_t* addr_bytes, char* addr,
+      int32_t* success);
+  static NaClSrpcError PPB_UDPSocket_Private_SendTo(
+      NaClSrpcChannel* channel,
+      PP_Resource udp_socket,
+      nacl_abi_size_t buffer_bytes, char* buffer,
+      int32_t num_bytes,
+      nacl_abi_size_t addr_bytes, char* addr,
+      int32_t callback_id,
+      int32_t* pp_error_or_bytes);
+  static NaClSrpcError PPB_UDPSocket_Private_Close(
+      NaClSrpcChannel* channel,
+      PP_Resource udp_socket);
+
+ private:
+  PpbUDPSocketPrivateRpcClient();
+  PpbUDPSocketPrivateRpcClient(const PpbUDPSocketPrivateRpcClient&);
+  void operator=(const PpbUDPSocketPrivateRpcClient);
+};  // class PpbUDPSocketPrivateRpcClient
+
 class PpbURLLoaderRpcClient {
  public:
   static NaClSrpcError PPB_URLLoader_Create(