Remove 'Flash' from TCP/UDP Pepper interfaces names. This CL preserves old idl and C/C++ headers for backward compatibility. Also TCP interface should be returned by old name.

BUG=none
TEST=build

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

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

8 files changed, 206 insertions, 205 deletions

diff --git a/ppapi/proxy/interface_list.cc b/ppapi/proxy/interface_list.cc
index f855f90..0d654a5 100644
--- a/ppapi/proxy/interface_list.cc
+++ b/ppapi/proxy/interface_list.cc
@@ -48,9 +48,10 @@
 #include "ppapi/c/private/ppb_flash_menu.h"
 #include "ppapi/c/private/ppb_flash_net_connector.h"
 #include "ppapi/c/private/ppb_flash_tcp_socket.h"
-#include "ppapi/c/private/ppb_flash_udp_socket.h"
 #include "ppapi/c/private/ppb_net_address_private.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_broker_trusted.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/proxy/interface_proxy.h"
@@ -68,8 +69,6 @@
 #include "ppapi/proxy/ppb_flash_menu_proxy.h"
 #include "ppapi/proxy/ppb_flash_net_connector_proxy.h"
 #include "ppapi/proxy/ppb_flash_proxy.h"
-#include "ppapi/proxy/ppb_flash_tcp_socket_proxy.h"
-#include "ppapi/proxy/ppb_flash_udp_socket_proxy.h"
 #include "ppapi/proxy/ppb_font_proxy.h"
 #include "ppapi/proxy/ppb_graphics_2d_proxy.h"
 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
@@ -77,8 +76,10 @@
 #include "ppapi/proxy/ppb_instance_proxy.h"
 #include "ppapi/proxy/ppb_pdf_proxy.h"
 #include "ppapi/proxy/ppb_surface_3d_proxy.h"
+#include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
 #include "ppapi/proxy/ppb_testing_proxy.h"
 #include "ppapi/proxy/ppb_text_input_proxy.h"
+#include "ppapi/proxy/ppb_udp_socket_private_proxy.h"
 #include "ppapi/proxy/ppb_url_loader_proxy.h"
 #include "ppapi/proxy/ppb_url_response_info_proxy.h"
 #include "ppapi/proxy/ppb_var_deprecated_proxy.h"
@@ -264,15 +265,9 @@ void InterfaceList::AddFlashInterfaces() {
   AddPPB(PPB_FLASH_MENU_INTERFACE, API_ID_PPB_FLASH_MENU,
          thunk::GetPPB_Flash_Menu_Thunk());
 
-  AddProxy(API_ID_PPB_FLASH_TCPSOCKET,
-           &ProxyFactory<PPB_Flash_TCPSocket_Proxy>);
-  AddPPB(PPB_FLASH_TCPSOCKET_INTERFACE, API_ID_PPB_FLASH_TCPSOCKET,
-         thunk::GetPPB_Flash_TCPSocket_Thunk());
-
-  AddProxy(API_ID_PPB_FLASH_UDPSOCKET,
-           &ProxyFactory<PPB_Flash_UDPSocket_Proxy>);
-  AddPPB(PPB_FLASH_UDPSOCKET_INTERFACE, API_ID_PPB_FLASH_UDPSOCKET,
-         thunk::GetPPB_Flash_UDPSocket_Thunk());
+  // Only add PPB because proxy for the this API ID was already added.
+  AddPPB(PPB_FLASH_TCPSOCKET_INTERFACE, API_ID_PPB_TCPSOCKET_PRIVATE,
+         thunk::GetPPB_TCPSocket_Private_Thunk());
 
 #ifdef ENABLE_FLAPPER_HACKS
   AddProxy(API_ID_PPB_FLASH_NETCONNECTOR,
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index a66b2b2..6a41a38 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -29,7 +29,7 @@
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_size.h"
 #include "ppapi/c/dev/pp_video_dev.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
+#include "ppapi/c/private/ppb_tcp_socket_private.h"
 #include "ppapi/proxy/ppapi_param_traits.h"
 #include "ppapi/proxy/ppapi_proxy_export.h"
 #include "ppapi/proxy/serialized_flash_menu.h"
@@ -251,40 +251,40 @@ IPC_MESSAGE_ROUTED5(PpapiMsg_PPBFlashNetConnector_ConnectACK,
                     std::string /* local_addr_as_string */,
                     std::string /* remote_addr_as_string */)
 
-// PPB_Flash_TCPSocket.
-IPC_MESSAGE_ROUTED5(PpapiMsg_PPBFlashTCPSocket_ConnectACK,
+// PPB_TCPSocket_Private.
+IPC_MESSAGE_ROUTED5(PpapiMsg_PPBTCPSocket_ConnectACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
                     bool /* succeeded */,
                     PP_NetAddress_Private /* local_addr */,
                     PP_NetAddress_Private /* remote_addr */)
-IPC_MESSAGE_ROUTED3(PpapiMsg_PPBFlashTCPSocket_SSLHandshakeACK,
+IPC_MESSAGE_ROUTED3(PpapiMsg_PPBTCPSocket_SSLHandshakeACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
                     bool /* succeeded */)
-IPC_MESSAGE_ROUTED4(PpapiMsg_PPBFlashTCPSocket_ReadACK,
+IPC_MESSAGE_ROUTED4(PpapiMsg_PPBTCPSocket_ReadACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
                     bool /* succeeded */,
                     std::string /* data */)
-IPC_MESSAGE_ROUTED4(PpapiMsg_PPBFlashTCPSocket_WriteACK,
+IPC_MESSAGE_ROUTED4(PpapiMsg_PPBTCPSocket_WriteACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
                     bool /* succeeded */,
                     int32_t /* bytes_written */)
 
-// PPB_Flash_UDPSocket
-IPC_MESSAGE_ROUTED3(PpapiMsg_PPBFlashUDPSocket_BindACK,
+// PPB_UDPSocket_Private
+IPC_MESSAGE_ROUTED3(PpapiMsg_PPBUDPSocket_BindACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
                     bool /* succeeded */)
-IPC_MESSAGE_ROUTED5(PpapiMsg_PPBFlashUDPSocket_RecvFromACK,
+IPC_MESSAGE_ROUTED5(PpapiMsg_PPBUDPSocket_RecvFromACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
                     bool /* succeeded */,
                     std::string /* data */,
                     PP_NetAddress_Private /* remote_addr */)
-IPC_MESSAGE_ROUTED4(PpapiMsg_PPBFlashUDPSocket_SendToACK,
+IPC_MESSAGE_ROUTED4(PpapiMsg_PPBUDPSocket_SendToACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
                     bool /* succeeded */,
@@ -737,47 +737,47 @@ IPC_MESSAGE_ROUTED2(PpapiHostMsg_PPBFlashNetConnector_ConnectTcpAddress,
                     ppapi::HostResource /* connector */,
                     std::string /* net_address_as_string */)
 
-// PPB_Flash_TCPSocket.
-IPC_SYNC_MESSAGE_CONTROL2_1(PpapiHostMsg_PPBFlashTCPSocket_Create,
+// PPB_TCPSocket_Private.
+IPC_SYNC_MESSAGE_CONTROL2_1(PpapiHostMsg_PPBTCPSocket_Create,
                             int32 /* routing_id */,
                             uint32 /* plugin_dispatcher_id */,
                             uint32 /* socket_id */)
-IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashTCPSocket_Connect,
+IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBTCPSocket_Connect,
                      uint32 /* socket_id */,
                      std::string /* host */,
                      uint16_t /* port */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress,
+IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress,
                      uint32 /* socket_id */,
                      PP_NetAddress_Private /* net_addr */)
-IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashTCPSocket_SSLHandshake,
+IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBTCPSocket_SSLHandshake,
                      uint32 /* socket_id */,
                      std::string /* server_name */,
                      uint16_t /* server_port */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_Read,
+IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBTCPSocket_Read,
                      uint32 /* socket_id */,
                      int32_t /* bytes_to_read */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_Write,
+IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBTCPSocket_Write,
                      uint32 /* socket_id */,
                      std::string /* data */)
-IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBFlashTCPSocket_Disconnect,
+IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBTCPSocket_Disconnect,
                      uint32 /* socket_id */)
 
-// PPB_Flash_UDPSocket
-IPC_SYNC_MESSAGE_CONTROL2_1(PpapiHostMsg_PPBFlashUDPSocket_Create,
+// PPB_UDPSocket_Private.
+IPC_SYNC_MESSAGE_CONTROL2_1(PpapiHostMsg_PPBUDPSocket_Create,
                             int32 /* routing_id */,
                             uint32 /* plugin_dispatcher_id */,
                             uint32 /* socket_id */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashUDPSocket_Bind,
+IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBUDPSocket_Bind,
                      uint32 /* socket_id */,
                      PP_NetAddress_Private /* net_addr */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashUDPSocket_RecvFrom,
+IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBUDPSocket_RecvFrom,
                      uint32 /* socket_id */,
                      int32_t /* num_bytes */)
-IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashUDPSocket_SendTo,
+IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBUDPSocket_SendTo,
                      uint32 /* socket_id */,
                      std::string /* data */,
                      PP_NetAddress_Private /* net_addr */)
-IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBFlashUDPSocket_Close,
+IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBUDPSocket_Close,
                      uint32 /* socket_id */)
 
 // PPB_Font.
diff --git a/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc b/ppapi/proxy/ppb_tcp_socket_private_proxy.cc
index dc1bd9a..555e833 100644
--- a/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc
+++ b/ppapi/proxy/ppb_tcp_socket_private_proxy.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ppapi/proxy/ppb_flash_tcp_socket_proxy.h"
+#include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
 
 #include <algorithm>
 #include <cstring>
@@ -17,22 +17,22 @@
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/resource.h"
-#include "ppapi/thunk/ppb_flash_tcp_socket_api.h"
+#include "ppapi/thunk/ppb_tcp_socket_private_api.h"
 #include "ppapi/thunk/thunk.h"
 
-using ppapi::thunk::PPB_Flash_TCPSocket_API;
+using ppapi::thunk::PPB_TCPSocket_Private_API;
 
 namespace ppapi {
 namespace proxy {
 
-const int32_t kFlashTCPSocketMaxReadSize = 1024 * 1024;
-const int32_t kFlashTCPSocketMaxWriteSize = 1024 * 1024;
+const int32_t kTCPSocketMaxReadSize = 1024 * 1024;
+const int32_t kTCPSocketMaxWriteSize = 1024 * 1024;
 
-class FlashTCPSocket;
+class TCPSocket;
 
 namespace {
 
-typedef std::map<uint32, FlashTCPSocket*> IDToSocketMap;
+typedef std::map<uint32, TCPSocket*> IDToSocketMap;
 IDToSocketMap* g_id_to_socket = NULL;
 
 class AbortCallbackTask : public Task {
@@ -51,16 +51,16 @@ class AbortCallbackTask : public Task {
 
 }  // namespace
 
-class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
-                       public Resource {
+class TCPSocket : public PPB_TCPSocket_Private_API,
+                  public Resource {
  public:
-  FlashTCPSocket(const HostResource& resource, uint32 socket_id);
-  virtual ~FlashTCPSocket();
+  TCPSocket(const HostResource& resource, uint32 socket_id);
+  virtual ~TCPSocket();
 
   // Resource overrides.
-  virtual PPB_Flash_TCPSocket_API* AsPPB_Flash_TCPSocket_API() OVERRIDE;
+  virtual PPB_TCPSocket_Private_API* AsPPB_TCPSocket_Private_API() OVERRIDE;
 
-  // PPB_Flash_TCPSocket_API implementation.
+  // PPB_TCPSocket_Private_API implementation.
   virtual int32_t Connect(const char* host,
                           uint16_t port,
                           PP_CompletionCallback callback) OVERRIDE;
@@ -129,10 +129,10 @@ class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
   PP_NetAddress_Private local_addr_;
   PP_NetAddress_Private remote_addr_;
 
-  DISALLOW_COPY_AND_ASSIGN(FlashTCPSocket);
+  DISALLOW_COPY_AND_ASSIGN(TCPSocket);
 };
 
-FlashTCPSocket::FlashTCPSocket(const HostResource& resource, uint32 socket_id)
+TCPSocket::TCPSocket(const HostResource& resource, uint32 socket_id)
     : Resource(resource),
       socket_id_(socket_id),
       connection_state_(BEFORE_CONNECT),
@@ -155,38 +155,38 @@ FlashTCPSocket::FlashTCPSocket(const HostResource& resource, uint32 socket_id)
   (*g_id_to_socket)[socket_id] = this;
 }
 
-FlashTCPSocket::~FlashTCPSocket() {
+TCPSocket::~TCPSocket() {
   Disconnect();
 }
 
-PPB_Flash_TCPSocket_API* FlashTCPSocket::AsPPB_Flash_TCPSocket_API() {
+PPB_TCPSocket_Private_API* TCPSocket::AsPPB_TCPSocket_Private_API() {
   return this;
 }
 
-int32_t FlashTCPSocket::Connect(const char* host,
-                                uint16_t port,
-                                PP_CompletionCallback callback) {
+int32_t TCPSocket::Connect(const char* host,
+                           uint16_t port,
+                           PP_CompletionCallback callback) {
   if (!host)
     return PP_ERROR_BADARGUMENT;
 
   return ConnectWithMessage(
-      new PpapiHostMsg_PPBFlashTCPSocket_Connect(socket_id_, host, port),
+      new PpapiHostMsg_PPBTCPSocket_Connect(socket_id_, host, port),
       callback);
 }
 
-int32_t FlashTCPSocket::ConnectWithNetAddress(
+int32_t TCPSocket::ConnectWithNetAddress(
     const PP_NetAddress_Private* addr,
     PP_CompletionCallback callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
 
   return ConnectWithMessage(
-      new PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress(
+      new PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress(
           socket_id_, *addr),
       callback);
 }
 
-PP_Bool FlashTCPSocket::GetLocalAddress(PP_NetAddress_Private* local_addr) {
+PP_Bool TCPSocket::GetLocalAddress(PP_NetAddress_Private* local_addr) {
   if (!IsConnected() || !local_addr)
     return PP_FALSE;
 
@@ -194,7 +194,7 @@ PP_Bool FlashTCPSocket::GetLocalAddress(PP_NetAddress_Private* local_addr) {
   return PP_TRUE;
 }
 
-PP_Bool FlashTCPSocket::GetRemoteAddress(PP_NetAddress_Private* remote_addr) {
+PP_Bool TCPSocket::GetRemoteAddress(PP_NetAddress_Private* remote_addr) {
   if (!IsConnected() || !remote_addr)
     return PP_FALSE;
 
@@ -202,9 +202,9 @@ PP_Bool FlashTCPSocket::GetRemoteAddress(PP_NetAddress_Private* remote_addr) {
   return PP_TRUE;
 }
 
-int32_t FlashTCPSocket::SSLHandshake(const char* server_name,
-                                     uint16_t server_port,
-                                     PP_CompletionCallback callback) {
+int32_t TCPSocket::SSLHandshake(const char* server_name,
+                                uint16_t server_port,
+                                PP_CompletionCallback callback) {
   if (!server_name)
     return PP_ERROR_BADARGUMENT;
   if (!callback.func)
@@ -220,14 +220,14 @@ int32_t FlashTCPSocket::SSLHandshake(const char* server_name,
 
   // Send the request, the browser will call us back via SSLHandshakeACK.
   GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashTCPSocket_SSLHandshake(
+      new PpapiHostMsg_PPBTCPSocket_SSLHandshake(
           socket_id_, std::string(server_name), server_port));
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t FlashTCPSocket::Read(char* buffer,
-                             int32_t bytes_to_read,
-                             PP_CompletionCallback callback) {
+int32_t TCPSocket::Read(char* buffer,
+                        int32_t bytes_to_read,
+                        PP_CompletionCallback callback) {
   if (!buffer || bytes_to_read <= 0)
     return PP_ERROR_BADARGUMENT;
   if (!callback.func)
@@ -239,18 +239,18 @@ int32_t FlashTCPSocket::Read(char* buffer,
     return PP_ERROR_INPROGRESS;
 
   read_buffer_ = buffer;
-  bytes_to_read_ = std::min(bytes_to_read, kFlashTCPSocketMaxReadSize);
+  bytes_to_read_ = std::min(bytes_to_read, kTCPSocketMaxReadSize);
   read_callback_ = callback;
 
   // Send the request, the browser will call us back via ReadACK.
   GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashTCPSocket_Read(socket_id_, bytes_to_read_));
+      new PpapiHostMsg_PPBTCPSocket_Read(socket_id_, bytes_to_read_));
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t FlashTCPSocket::Write(const char* buffer,
-                              int32_t bytes_to_write,
-                              PP_CompletionCallback callback) {
+int32_t TCPSocket::Write(const char* buffer,
+                         int32_t bytes_to_write,
+                         PP_CompletionCallback callback) {
   if (!buffer || bytes_to_write <= 0)
     return PP_ERROR_BADARGUMENT;
   if (!callback.func)
@@ -261,19 +261,19 @@ int32_t FlashTCPSocket::Write(const char* buffer,
   if (write_callback_.func || ssl_handshake_callback_.func)
     return PP_ERROR_INPROGRESS;
 
-  if (bytes_to_write > kFlashTCPSocketMaxWriteSize)
-    bytes_to_write = kFlashTCPSocketMaxWriteSize;
+  if (bytes_to_write > kTCPSocketMaxWriteSize)
+    bytes_to_write = kTCPSocketMaxWriteSize;
 
   write_callback_ = callback;
 
   // Send the request, the browser will call us back via WriteACK.
   GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashTCPSocket_Write(
+      new PpapiHostMsg_PPBTCPSocket_Write(
           socket_id_, std::string(buffer, bytes_to_write)));
   return PP_OK_COMPLETIONPENDING;
 }
 
-void FlashTCPSocket::Disconnect() {
+void TCPSocket::Disconnect() {
   if (connection_state_ == DISCONNECTED)
     return;
 
@@ -284,7 +284,7 @@ void FlashTCPSocket::Disconnect() {
   g_id_to_socket->erase(socket_id_);
 
   GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashTCPSocket_Disconnect(socket_id_));
+      new PpapiHostMsg_PPBTCPSocket_Disconnect(socket_id_));
   socket_id_ = 0;
 
   PostAbortAndClearIfNecessary(&connect_callback_);
@@ -295,7 +295,7 @@ void FlashTCPSocket::Disconnect() {
   bytes_to_read_ = -1;
 }
 
-void FlashTCPSocket::OnConnectCompleted(
+void TCPSocket::OnConnectCompleted(
     bool succeeded,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr) {
@@ -313,7 +313,7 @@ void FlashTCPSocket::OnConnectCompleted(
                                    succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
-void FlashTCPSocket::OnSSLHandshakeCompleted(bool succeeded) {
+void TCPSocket::OnSSLHandshakeCompleted(bool succeeded) {
   if (connection_state_ != CONNECTED || !ssl_handshake_callback_.func) {
     NOTREACHED();
     return;
@@ -328,7 +328,7 @@ void FlashTCPSocket::OnSSLHandshakeCompleted(bool succeeded) {
   }
 }
 
-void FlashTCPSocket::OnReadCompleted(bool succeeded, const std::string& data) {
+void TCPSocket::OnReadCompleted(bool succeeded, const std::string& data) {
   if (!read_callback_.func || !read_buffer_) {
     NOTREACHED();
     return;
@@ -348,7 +348,7 @@ void FlashTCPSocket::OnReadCompleted(bool succeeded, const std::string& data) {
                   static_cast<int32_t>(PP_ERROR_FAILED));
 }
 
-void FlashTCPSocket::OnWriteCompleted(bool succeeded, int32_t bytes_written) {
+void TCPSocket::OnWriteCompleted(bool succeeded, int32_t bytes_written) {
   if (!write_callback_.func || (succeeded && bytes_written < 0)) {
     NOTREACHED();
     return;
@@ -359,12 +359,12 @@ void FlashTCPSocket::OnWriteCompleted(bool succeeded, int32_t bytes_written) {
       succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED));
 }
 
-bool FlashTCPSocket::IsConnected() const {
+bool TCPSocket::IsConnected() const {
   return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
 }
 
-int32_t FlashTCPSocket::ConnectWithMessage(IPC::Message* msg,
-                                           PP_CompletionCallback callback) {
+int32_t TCPSocket::ConnectWithMessage(IPC::Message* msg,
+                                      PP_CompletionCallback callback) {
   scoped_ptr<IPC::Message> msg_deletor(msg);
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
@@ -379,7 +379,7 @@ int32_t FlashTCPSocket::ConnectWithMessage(IPC::Message* msg,
   return PP_OK_COMPLETIONPENDING;
 }
 
-void FlashTCPSocket::PostAbortAndClearIfNecessary(
+void TCPSocket::PostAbortAndClearIfNecessary(
     PP_CompletionCallback* callback) {
   DCHECK(callback);
 
@@ -390,44 +390,45 @@ void FlashTCPSocket::PostAbortAndClearIfNecessary(
   }
 }
 
-PPB_Flash_TCPSocket_Proxy::PPB_Flash_TCPSocket_Proxy(Dispatcher* dispatcher)
+PPB_TCPSocket_Private_Proxy::PPB_TCPSocket_Private_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher) {
 }
 
-PPB_Flash_TCPSocket_Proxy::~PPB_Flash_TCPSocket_Proxy() {
+PPB_TCPSocket_Private_Proxy::~PPB_TCPSocket_Private_Proxy() {
 }
 
 // static
-PP_Resource PPB_Flash_TCPSocket_Proxy::CreateProxyResource(
+PP_Resource PPB_TCPSocket_Private_Proxy::CreateProxyResource(
     PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   uint32 socket_id = 0;
-  dispatcher->SendToBrowser(new PpapiHostMsg_PPBFlashTCPSocket_Create(
-      API_ID_PPB_FLASH_TCPSOCKET, dispatcher->plugin_dispatcher_id(),
+  dispatcher->SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Create(
+      API_ID_PPB_TCPSOCKET_PRIVATE, dispatcher->plugin_dispatcher_id(),
       &socket_id));
   if (socket_id == 0)
     return 0;
-  return (new FlashTCPSocket(HostResource::MakeInstanceOnly(instance),
-                             socket_id))->GetReference();
+  return (new TCPSocket(HostResource::MakeInstanceOnly(instance),
+                        socket_id))->GetReference();
 }
 
-bool PPB_Flash_TCPSocket_Proxy::OnMessageReceived(const IPC::Message& msg) {
+bool PPB_TCPSocket_Private_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PPB_Flash_TCPSocket_Proxy, msg)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_ConnectACK, OnMsgConnectACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_SSLHandshakeACK,
+  IPC_BEGIN_MESSAGE_MAP(PPB_TCPSocket_Private_Proxy, msg)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ConnectACK,
+                        OnMsgConnectACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SSLHandshakeACK,
                         OnMsgSSLHandshakeACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_ReadACK, OnMsgReadACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_WriteACK, OnMsgWriteACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ReadACK, OnMsgReadACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_WriteACK, OnMsgWriteACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void PPB_Flash_TCPSocket_Proxy::OnMsgConnectACK(
+void PPB_TCPSocket_Private_Proxy::OnMsgConnectACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
@@ -443,7 +444,7 @@ void PPB_Flash_TCPSocket_Proxy::OnMsgConnectACK(
   iter->second->OnConnectCompleted(succeeded, local_addr, remote_addr);
 }
 
-void PPB_Flash_TCPSocket_Proxy::OnMsgSSLHandshakeACK(
+void PPB_TCPSocket_Private_Proxy::OnMsgSSLHandshakeACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded) {
@@ -457,10 +458,11 @@ void PPB_Flash_TCPSocket_Proxy::OnMsgSSLHandshakeACK(
   iter->second->OnSSLHandshakeCompleted(succeeded);
 }
 
-void PPB_Flash_TCPSocket_Proxy::OnMsgReadACK(uint32 /* plugin_dispatcher_id */,
-                                             uint32 socket_id,
-                                             bool succeeded,
-                                             const std::string& data) {
+void PPB_TCPSocket_Private_Proxy::OnMsgReadACK(
+    uint32 /* plugin_dispatcher_id */,
+    uint32 socket_id,
+    bool succeeded,
+    const std::string& data) {
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
@@ -471,10 +473,11 @@ void PPB_Flash_TCPSocket_Proxy::OnMsgReadACK(uint32 /* plugin_dispatcher_id */,
   iter->second->OnReadCompleted(succeeded, data);
 }
 
-void PPB_Flash_TCPSocket_Proxy::OnMsgWriteACK(uint32 /* plugin_dispatcher_id */,
-                                              uint32 socket_id,
-                                              bool succeeded,
-                                              int32_t bytes_written) {
+void PPB_TCPSocket_Private_Proxy::OnMsgWriteACK(
+    uint32 /* plugin_dispatcher_id */,
+    uint32 socket_id,
+    bool succeeded,
+    int32_t bytes_written) {
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
diff --git a/ppapi/proxy/ppb_flash_tcp_socket_proxy.h b/ppapi/proxy/ppb_tcp_socket_private_proxy.h
index f20f15e..ec89fe2 100644
--- a/ppapi/proxy/ppb_flash_tcp_socket_proxy.h
+++ b/ppapi/proxy/ppb_tcp_socket_private_proxy.h
@@ -2,38 +2,40 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef PPAPI_PROXY_PPB_FLASH_TCP_SOCKET_PROXY_H_
-#define PPAPI_PROXY_PPB_FLASH_TCP_SOCKET_PROXY_H_
+#ifndef PPAPI_PROXY_PPB_TCP_SOCKET_PRIVATE_PROXY_H_
+#define PPAPI_PROXY_PPB_TCP_SOCKET_PRIVATE_PROXY_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
+#include "ppapi/c/private/ppb_tcp_socket_private.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/ppapi_proxy_export.h"
 
 namespace ppapi {
 namespace proxy {
 
-// The maximum number of bytes that each PpapiHostMsg_PPBFlashTCPSocket_Read
+// The maximum number of bytes that each PpapiHostMsg_PPBTCPSocket_Read
 // message is allowed to request.
-PPAPI_PROXY_EXPORT extern const int32_t kFlashTCPSocketMaxReadSize;
-// The maximum number of bytes that each PpapiHostMsg_PPBFlashTCPSocket_Write
+PPAPI_PROXY_EXPORT extern const int32_t kTCPSocketMaxReadSize;
+// The maximum number of bytes that each PpapiHostMsg_PPBTCPSocket_Write
 // message is allowed to carry.
-PPAPI_PROXY_EXPORT extern const int32_t kFlashTCPSocketMaxWriteSize;
+PPAPI_PROXY_EXPORT extern const int32_t kTCPSocketMaxWriteSize;
 
-class PPB_Flash_TCPSocket_Proxy : public InterfaceProxy {
+class PPB_TCPSocket_Private_Proxy : public InterfaceProxy {
  public:
-  PPB_Flash_TCPSocket_Proxy(Dispatcher* dispatcher);
-  virtual ~PPB_Flash_TCPSocket_Proxy();
+  PPB_TCPSocket_Private_Proxy(Dispatcher* dispatcher);
+  virtual ~PPB_TCPSocket_Private_Proxy();
 
   static PP_Resource CreateProxyResource(PP_Instance instance);
 
   // InterfaceProxy implementation.
   virtual bool OnMessageReceived(const IPC::Message& msg);
 
+  static const ApiID kApiID = API_ID_PPB_TCPSOCKET_PRIVATE;
+
  private:
   // Browser->plugin message handlers.
   void OnMsgConnectACK(uint32 plugin_dispatcher_id,
@@ -53,10 +55,10 @@ class PPB_Flash_TCPSocket_Proxy : public InterfaceProxy {
                      bool succeeded,
                      int32_t bytes_written);
 
-  DISALLOW_COPY_AND_ASSIGN(PPB_Flash_TCPSocket_Proxy);
+  DISALLOW_COPY_AND_ASSIGN(PPB_TCPSocket_Private_Proxy);
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
-#endif  // PPAPI_PROXY_PPB_FLASH_TCP_SOCKET_PROXY_H_
+#endif  // PPAPI_PROXY_PPB_TCP_SOCKET_PRIVATE_PROXY_H_
diff --git a/ppapi/proxy/ppb_flash_udp_socket_proxy.cc b/ppapi/proxy/ppb_udp_socket_private_proxy.cc
index 8988e87..1808fb0 100644
--- a/ppapi/proxy/ppb_flash_udp_socket_proxy.cc
+++ b/ppapi/proxy/ppb_udp_socket_private_proxy.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ppapi/proxy/ppb_flash_udp_socket_proxy.h"
+#include "ppapi/proxy/ppb_udp_socket_private_proxy.h"
 
 #include <algorithm>
 #include <cstring>
@@ -17,22 +17,22 @@
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/resource.h"
-#include "ppapi/thunk/ppb_flash_udp_socket_api.h"
+#include "ppapi/thunk/ppb_udp_socket_private_api.h"
 #include "ppapi/thunk/thunk.h"
 
-using ppapi::thunk::PPB_Flash_UDPSocket_API;
+using ppapi::thunk::PPB_UDPSocket_Private_API;
 
 namespace ppapi {
 namespace proxy {
 
-const int32_t kFlashUDPSocketMaxReadSize = 1024 * 1024;
-const int32_t kFlashUDPSocketMaxWriteSize = 1024 * 1024;
+const int32_t kUDPSocketMaxReadSize = 1024 * 1024;
+const int32_t kUDPSocketMaxWriteSize = 1024 * 1024;
 
 namespace {
 
-class FlashUDPSocket;
+class UDPSocket;
 
-typedef std::map<uint32, FlashUDPSocket*> IDToSocketMap;
+typedef std::map<uint32, UDPSocket*> IDToSocketMap;
 IDToSocketMap* g_id_to_socket = NULL;
 
 class AbortCallbackTask : public Task {
@@ -49,16 +49,16 @@ class AbortCallbackTask : public Task {
   PP_CompletionCallback callback_;
 };
 
-class FlashUDPSocket : public PPB_Flash_UDPSocket_API,
-                       public Resource {
+class UDPSocket : public PPB_UDPSocket_Private_API,
+                  public Resource {
  public:
-  FlashUDPSocket(const HostResource& resource, uint32 socket_id);
-  virtual ~FlashUDPSocket();
+  UDPSocket(const HostResource& resource, uint32 socket_id);
+  virtual ~UDPSocket();
 
   // ResourceObjectBase overrides.
-  virtual PPB_Flash_UDPSocket_API* AsPPB_Flash_UDPSocket_API() OVERRIDE;
+  virtual PPB_UDPSocket_Private_API* AsPPB_UDPSocket_Private_API() OVERRIDE;
 
-  // PPB_Flash_UDPSocket_API implementation.
+  // PPB_UDPSocket_Private_API implementation.
   virtual int32_t Bind(const PP_NetAddress_Private* addr,
                        PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t RecvFrom(char* buffer,
@@ -101,11 +101,10 @@ class FlashUDPSocket : public PPB_Flash_UDPSocket_API,
 
   PP_NetAddress_Private recvfrom_addr_;
 
-  DISALLOW_COPY_AND_ASSIGN(FlashUDPSocket);
+  DISALLOW_COPY_AND_ASSIGN(UDPSocket);
 };
 
-FlashUDPSocket::FlashUDPSocket(const HostResource& resource,
-                               uint32 socket_id)
+UDPSocket::UDPSocket(const HostResource& resource, uint32 socket_id)
     : Resource(resource),
       socket_id_(socket_id),
       binded_(false),
@@ -126,16 +125,16 @@ FlashUDPSocket::FlashUDPSocket(const HostResource& resource,
   (*g_id_to_socket)[socket_id] = this;
 }
 
-FlashUDPSocket::~FlashUDPSocket() {
+UDPSocket::~UDPSocket() {
   Close();
 }
 
-PPB_Flash_UDPSocket_API* FlashUDPSocket::AsPPB_Flash_UDPSocket_API() {
+PPB_UDPSocket_Private_API* UDPSocket::AsPPB_UDPSocket_Private_API() {
   return this;
 }
 
-int32_t FlashUDPSocket::Bind(const PP_NetAddress_Private* addr,
-                             PP_CompletionCallback callback) {
+int32_t UDPSocket::Bind(const PP_NetAddress_Private* addr,
+                        PP_CompletionCallback callback) {
   if (!addr || !callback.func)
     return PP_ERROR_BADARGUMENT;
   if (binded_ || closed_)
@@ -146,14 +145,14 @@ int32_t FlashUDPSocket::Bind(const PP_NetAddress_Private* addr,
   bind_callback_ = callback;
 
   GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashUDPSocket_Bind(socket_id_, *addr));
+      new PpapiHostMsg_PPBUDPSocket_Bind(socket_id_, *addr));
 
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t FlashUDPSocket::RecvFrom(char* buffer,
-                                 int32_t num_bytes,
-                                 PP_CompletionCallback callback) {
+int32_t UDPSocket::RecvFrom(char* buffer,
+                            int32_t num_bytes,
+                            PP_CompletionCallback callback) {
   if (!buffer || num_bytes <= 0 || !callback.func)
     return PP_ERROR_BADARGUMENT;
   if (!binded_)
@@ -162,17 +161,17 @@ int32_t FlashUDPSocket::RecvFrom(char* buffer,
     return PP_ERROR_INPROGRESS;
 
   read_buffer_ = buffer;
-  bytes_to_read_ = std::min(num_bytes, kFlashUDPSocketMaxReadSize);
+  bytes_to_read_ = std::min(num_bytes, kUDPSocketMaxReadSize);
   recvfrom_callback_ = callback;
 
   // Send the request, the browser will call us back via RecvFromACK.
   GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashUDPSocket_RecvFrom(
+      new PpapiHostMsg_PPBUDPSocket_RecvFrom(
           socket_id_, num_bytes));
   return PP_OK_COMPLETIONPENDING;
 }
 
-PP_Bool FlashUDPSocket::GetRecvFromAddress(PP_NetAddress_Private* addr) {
+PP_Bool UDPSocket::GetRecvFromAddress(PP_NetAddress_Private* addr) {
   if (!addr)
     return PP_FALSE;
 
@@ -180,10 +179,10 @@ PP_Bool FlashUDPSocket::GetRecvFromAddress(PP_NetAddress_Private* addr) {
   return PP_TRUE;
 }
 
-int32_t FlashUDPSocket::SendTo(const char* buffer,
-                               int32_t num_bytes,
-                               const PP_NetAddress_Private* addr,
-                               PP_CompletionCallback callback) {
+int32_t UDPSocket::SendTo(const char* buffer,
+                          int32_t num_bytes,
+                          const PP_NetAddress_Private* addr,
+                          PP_CompletionCallback callback) {
   if (!buffer || num_bytes <= 0 || !addr || !callback.func)
     return PP_ERROR_BADARGUMENT;
   if (!binded_)
@@ -191,20 +190,20 @@ int32_t FlashUDPSocket::SendTo(const char* buffer,
   if (sendto_callback_.func)
     return PP_ERROR_INPROGRESS;
 
-  if (num_bytes > kFlashUDPSocketMaxWriteSize)
-    num_bytes = kFlashUDPSocketMaxWriteSize;
+  if (num_bytes > kUDPSocketMaxWriteSize)
+    num_bytes = kUDPSocketMaxWriteSize;
 
   sendto_callback_ = callback;
 
   // Send the request, the browser will call us back via SendToACK.
   GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashUDPSocket_SendTo(
+      new PpapiHostMsg_PPBUDPSocket_SendTo(
           socket_id_, std::string(buffer, num_bytes), *addr));
 
   return PP_OK_COMPLETIONPENDING;
 }
 
-void FlashUDPSocket::Close() {
+void UDPSocket::Close() {
   if(closed_)
     return;
 
@@ -217,7 +216,7 @@ void FlashUDPSocket::Close() {
   g_id_to_socket->erase(socket_id_);
 
   GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashUDPSocket_Close(socket_id_));
+      new PpapiHostMsg_PPBUDPSocket_Close(socket_id_));
   socket_id_ = 0;
 
   PostAbortAndClearIfNecessary(&bind_callback_);
@@ -225,7 +224,7 @@ void FlashUDPSocket::Close() {
   PostAbortAndClearIfNecessary(&sendto_callback_);
 }
 
-void FlashUDPSocket::OnBindCompleted(bool succeeded) {
+void UDPSocket::OnBindCompleted(bool succeeded) {
   if (!bind_callback_.func) {
     NOTREACHED();
     return;
@@ -238,9 +237,9 @@ void FlashUDPSocket::OnBindCompleted(bool succeeded) {
                                    succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
-void FlashUDPSocket::OnRecvFromCompleted(bool succeeded,
-                                         const std::string& data,
-                                         const PP_NetAddress_Private& addr) {
+void UDPSocket::OnRecvFromCompleted(bool succeeded,
+                                    const std::string& data,
+                                    const PP_NetAddress_Private& addr) {
   if (!recvfrom_callback_.func || !read_buffer_) {
     NOTREACHED();
     return;
@@ -261,8 +260,7 @@ void FlashUDPSocket::OnRecvFromCompleted(bool succeeded,
                   static_cast<int32_t>(PP_ERROR_FAILED));
 }
 
-void FlashUDPSocket::OnSendToCompleted(bool succeeded,
-                                       int32_t bytes_written) {
+void UDPSocket::OnSendToCompleted(bool succeeded, int32_t bytes_written) {
   if (!sendto_callback_.func) {
     NOTREACHED();
     return;
@@ -273,7 +271,7 @@ void FlashUDPSocket::OnSendToCompleted(bool succeeded,
       succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED));
 }
 
-void FlashUDPSocket::PostAbortAndClearIfNecessary(
+void UDPSocket::PostAbortAndClearIfNecessary(
     PP_CompletionCallback* callback) {
   DCHECK(callback);
 
@@ -285,46 +283,46 @@ void FlashUDPSocket::PostAbortAndClearIfNecessary(
 }
 }  // namespace
 
-PPB_Flash_UDPSocket_Proxy::PPB_Flash_UDPSocket_Proxy(Dispatcher* dispatcher)
+PPB_UDPSocket_Private_Proxy::PPB_UDPSocket_Private_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher) {
 }
 
-PPB_Flash_UDPSocket_Proxy::~PPB_Flash_UDPSocket_Proxy() {
+PPB_UDPSocket_Private_Proxy::~PPB_UDPSocket_Private_Proxy() {
 }
 
 // static
-PP_Resource PPB_Flash_UDPSocket_Proxy::CreateProxyResource(
+PP_Resource PPB_UDPSocket_Private_Proxy::CreateProxyResource(
     PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   uint32 socket_id = 0;
-  dispatcher->SendToBrowser(new PpapiHostMsg_PPBFlashUDPSocket_Create(
-      API_ID_PPB_FLASH_UDPSOCKET, dispatcher->plugin_dispatcher_id(),
+  dispatcher->SendToBrowser(new PpapiHostMsg_PPBUDPSocket_Create(
+      API_ID_PPB_UDPSOCKET_PRIVATE, dispatcher->plugin_dispatcher_id(),
       &socket_id));
   if (socket_id == 0)
     return 0;
 
-  return (new FlashUDPSocket(HostResource::MakeInstanceOnly(instance),
-                             socket_id))->GetReference();
+  return (new UDPSocket(HostResource::MakeInstanceOnly(instance),
+                        socket_id))->GetReference();
 }
 
-bool PPB_Flash_UDPSocket_Proxy::OnMessageReceived(const IPC::Message& msg) {
+bool PPB_UDPSocket_Private_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PPB_Flash_UDPSocket_Proxy, msg)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashUDPSocket_BindACK,
+  IPC_BEGIN_MESSAGE_MAP(PPB_UDPSocket_Private_Proxy, msg)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_BindACK,
                         OnMsgBindACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashUDPSocket_RecvFromACK,
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_RecvFromACK,
                         OnMsgRecvFromACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashUDPSocket_SendToACK,
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_SendToACK,
                         OnMsgSendToACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void PPB_Flash_UDPSocket_Proxy::OnMsgBindACK(
+void PPB_UDPSocket_Private_Proxy::OnMsgBindACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded) {
@@ -338,7 +336,7 @@ void PPB_Flash_UDPSocket_Proxy::OnMsgBindACK(
   iter->second->OnBindCompleted(succeeded);
 }
 
-void PPB_Flash_UDPSocket_Proxy::OnMsgRecvFromACK(
+void PPB_UDPSocket_Private_Proxy::OnMsgRecvFromACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
@@ -354,7 +352,7 @@ void PPB_Flash_UDPSocket_Proxy::OnMsgRecvFromACK(
   iter->second->OnRecvFromCompleted(succeeded, data, addr);
 }
 
-void PPB_Flash_UDPSocket_Proxy::OnMsgSendToACK(
+void PPB_UDPSocket_Private_Proxy::OnMsgSendToACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
diff --git a/ppapi/proxy/ppb_flash_udp_socket_proxy.h b/ppapi/proxy/ppb_udp_socket_private_proxy.h
index ab5f84d..337cf6b 100644
--- a/ppapi/proxy/ppb_flash_udp_socket_proxy.h
+++ b/ppapi/proxy/ppb_udp_socket_private_proxy.h
@@ -2,37 +2,39 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef PPAPI_PROXY_PPB_FLASH_UDP_SOCKET_PROXY_H_
-#define PPAPI_PROXY_PPB_FLASH_UDP_SOCKET_PROXY_H_
+#ifndef PPAPI_PROXY_PPB_UDP_SOCKET_PRIVATE_PROXY_H_
+#define PPAPI_PROXY_PPB_UDP_SOCKET_PRIVATE_PROXY_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
-#include "ppapi/c/private/ppb_flash_udp_socket.h"
+#include "ppapi/c/private/ppb_udp_socket_private.h"
 #include "ppapi/proxy/interface_proxy.h"
 
 namespace ppapi {
 namespace proxy {
 
-// The maximum number of bytes that each PpapiHostMsg_PPBFlashUDPSocket_RecvFrom
+// The maximum number of bytes that each PpapiHostMsg_PPBUDPSocket_RecvFrom
 // message is allowed to request.
-extern const int32_t kFlashUDPSocketMaxReadSize;
-// The maximum number of bytes that each PpapiHostMsg_PPBFlashUDPSocket_SendTo
+extern const int32_t kUDPSocketMaxReadSize;
+// The maximum number of bytes that each PpapiHostMsg_PPBUDPSocket_SendTo
 // message is allowed to carry.
-extern const int32_t kFlashUDPSocketMaxWriteSize;
+extern const int32_t kUDPSocketMaxWriteSize;
 
-class PPB_Flash_UDPSocket_Proxy : public InterfaceProxy {
+class PPB_UDPSocket_Private_Proxy : public InterfaceProxy {
  public:
-  PPB_Flash_UDPSocket_Proxy(Dispatcher* dispatcher);
-  virtual ~PPB_Flash_UDPSocket_Proxy();
+  PPB_UDPSocket_Private_Proxy(Dispatcher* dispatcher);
+  virtual ~PPB_UDPSocket_Private_Proxy();
 
   static PP_Resource CreateProxyResource(PP_Instance instance);
 
   // InterfaceProxy implementation.
   virtual bool OnMessageReceived(const IPC::Message& msg);
 
+  static const ApiID kApiID = API_ID_PPB_UDPSOCKET_PRIVATE;
+
  private:
   // Browser->plugin message handlers.
   void OnMsgBindACK(uint32 plugin_dispatcher_id,
@@ -48,11 +50,11 @@ class PPB_Flash_UDPSocket_Proxy : public InterfaceProxy {
                       bool succeeded,
                       int32_t bytes_written);
 
-  DISALLOW_COPY_AND_ASSIGN(PPB_Flash_UDPSocket_Proxy);
+  DISALLOW_COPY_AND_ASSIGN(PPB_UDPSocket_Private_Proxy);
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
-#endif  // PPAPI_PROXY_PPB_FLASH_UDP_SOCKET_PROXY_H_
+#endif  // PPAPI_PROXY_PPB_UDP_SOCKET_PRIVATE_PROXY_H_
 
diff --git a/ppapi/proxy/resource_creation_proxy.cc b/ppapi/proxy/resource_creation_proxy.cc
index 2c074df..afdf56d 100644
--- a/ppapi/proxy/resource_creation_proxy.cc
+++ b/ppapi/proxy/resource_creation_proxy.cc
@@ -19,13 +19,13 @@
 #include "ppapi/proxy/ppb_file_system_proxy.h"
 #include "ppapi/proxy/ppb_flash_menu_proxy.h"
 #include "ppapi/proxy/ppb_flash_net_connector_proxy.h"
-#include "ppapi/proxy/ppb_flash_tcp_socket_proxy.h"
-#include "ppapi/proxy/ppb_flash_udp_socket_proxy.h"
 #include "ppapi/proxy/ppb_font_proxy.h"
 #include "ppapi/proxy/ppb_graphics_2d_proxy.h"
 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
 #include "ppapi/proxy/ppb_image_data_proxy.h"
 #include "ppapi/proxy/ppb_surface_3d_proxy.h"
+#include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
+#include "ppapi/proxy/ppb_udp_socket_private_proxy.h"
 #include "ppapi/proxy/ppb_url_loader_proxy.h"
 #include "ppapi/proxy/ppb_video_capture_proxy.h"
 #include "ppapi/proxy/ppb_video_decoder_proxy.h"
@@ -152,16 +152,6 @@ PP_Resource ResourceCreationProxy::CreateFlashNetConnector(
   return PPB_Flash_NetConnector_Proxy::CreateProxyResource(instance);
 }
 
-PP_Resource ResourceCreationProxy::CreateFlashTCPSocket(
-    PP_Instance instance) {
-  return PPB_Flash_TCPSocket_Proxy::CreateProxyResource(instance);
-}
-
-PP_Resource ResourceCreationProxy::CreateFlashUDPSocket(
-    PP_Instance instance) {
-  return PPB_Flash_UDPSocket_Proxy::CreateProxyResource(instance);
-}
-
 PP_Resource ResourceCreationProxy::CreateFontObject(
     PP_Instance instance,
     const PP_FontDescription_Dev* description) {
@@ -291,6 +281,12 @@ PP_Resource ResourceCreationProxy::CreateSurface3D(
                                                   attrib_list);
 }
 
+
+PP_Resource ResourceCreationProxy::CreateTCPSocketPrivate(
+    PP_Instance instance) {
+  return PPB_TCPSocket_Private_Proxy::CreateProxyResource(instance);
+}
+
 PP_Resource ResourceCreationProxy::CreateTransport(PP_Instance instance,
                                                    const char* name,
                                                    PP_TransportType type) {
@@ -298,6 +294,11 @@ PP_Resource ResourceCreationProxy::CreateTransport(PP_Instance instance,
   return 0;
 }
 
+PP_Resource ResourceCreationProxy::CreateUDPSocketPrivate(
+    PP_Instance instance) {
+  return PPB_UDPSocket_Private_Proxy::CreateProxyResource(instance);
+}
+
 PP_Resource ResourceCreationProxy::CreateURLLoader(PP_Instance instance) {
   return PPB_URLLoader_Proxy::CreateProxyResource(instance);
 }
diff --git a/ppapi/proxy/resource_creation_proxy.h b/ppapi/proxy/resource_creation_proxy.h
index 74812f4..20924d1 100644
--- a/ppapi/proxy/resource_creation_proxy.h
+++ b/ppapi/proxy/resource_creation_proxy.h
@@ -70,8 +70,6 @@ class ResourceCreationProxy : public InterfaceProxy,
   virtual PP_Resource CreateFlashMenu(PP_Instance instance,
                                       const PP_Flash_Menu* menu_data) OVERRIDE;
   virtual PP_Resource CreateFlashNetConnector(PP_Instance instance) OVERRIDE;
-  virtual PP_Resource CreateFlashTCPSocket(PP_Instance instance) OVERRIDE;
-  virtual PP_Resource CreateFlashUDPSocket(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateFontObject(
       PP_Instance instance,
       const PP_FontDescription_Dev* description) OVERRIDE;
@@ -109,9 +107,11 @@ class ResourceCreationProxy : public InterfaceProxy,
   virtual PP_Resource CreateSurface3D(PP_Instance instance,
                                       PP_Config3D_Dev config,
                                       const int32_t* attrib_list) OVERRIDE;
+  virtual PP_Resource CreateTCPSocketPrivate(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateTransport(PP_Instance instance,
                                       const char* name,
                                       PP_TransportType type) OVERRIDE;
+  virtual PP_Resource CreateUDPSocketPrivate(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateURLLoader(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateURLRequestInfo(
       PP_Instance instance,