Make the Pepper Flash net address just private, not Flash-specific.

Note that, though the PP_Flash_NetAddress struct is being renamed, binary
compatibility is being maintained. It's also safe to just rename the
PPB_Flash_NetAddress interface without maintaining backwards compatibility since
Pepper Flash isn't using it yet.

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

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

51 files changed, 421 insertions, 462 deletions

diff --git a/content/browser/renderer_host/pepper_message_filter.cc b/content/browser/renderer_host/pepper_message_filter.cc
index 3a37d80..43880d7 100644
--- a/content/browser/renderer_host/pepper_message_filter.cc
+++ b/content/browser/renderer_host/pepper_message_filter.cc
@@ -43,7 +43,7 @@
 #include "ppapi/c/private/ppb_flash_net_connector.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_flash_tcp_socket_proxy.h"
-#include "ppapi/shared_impl/private/flash_net_address_impl.h"
+#include "ppapi/shared_impl/private/net_address_private_impl.h"
 #include "webkit/plugins/ppapi/ppb_flash_net_connector_impl.h"
 
 #if defined(ENABLE_FLAPPER_HACKS)
@@ -55,10 +55,10 @@ using content::BrowserThread;
 
 namespace {
 
-// TODO(viettrungluu): Move (some of) these to flash_net_address_impl.h.
+// TODO(viettrungluu): Move (some of) these to net_address_private_impl.h.
 bool SockaddrToNetAddress(const sockaddr* sa,
                           socklen_t sa_length,
-                          PP_Flash_NetAddress* net_addr) {
+                          PP_NetAddress_Private* net_addr) {
   if (!sa || sa_length <= 0 || !net_addr)
     return false;
 
@@ -69,7 +69,7 @@ bool SockaddrToNetAddress(const sockaddr* sa,
 }
 
 bool IPEndPointToNetAddress(const net::IPEndPoint& ip,
-                            PP_Flash_NetAddress* net_addr) {
+                            PP_NetAddress_Private* net_addr) {
   sockaddr_storage storage = { 0 };
   size_t length = sizeof(storage);
 
@@ -78,18 +78,18 @@ bool IPEndPointToNetAddress(const net::IPEndPoint& ip,
                               length, net_addr);
 }
 
-// Converts the first address to a PP_Flash_NetAddress.
+// Converts the first address to a PP_NetAddress_Private.
 bool AddressListToNetAddress(const net::AddressList& address_list,
-                             PP_Flash_NetAddress* net_addr) {
+                             PP_NetAddress_Private* net_addr) {
   const addrinfo* head = address_list.head();
   return head &&
          SockaddrToNetAddress(head->ai_addr, head->ai_addrlen, net_addr);
 }
 
-bool NetAddressToIPEndPoint(const PP_Flash_NetAddress& net_addr,
+bool NetAddressToIPEndPoint(const PP_NetAddress_Private& net_addr,
                             net::IPEndPoint* ip_end_point) {
   if (!ip_end_point ||
-      !ppapi::FlashNetAddressImpl::ValidateNetAddress(net_addr))
+      !ppapi::NetAddressPrivateImpl::ValidateNetAddress(net_addr))
     return false;
 
   if (!ip_end_point->FromSockAddr(
@@ -100,7 +100,7 @@ bool NetAddressToIPEndPoint(const PP_Flash_NetAddress& net_addr,
   return true;
 }
 
-bool NetAddressToAddressList(const PP_Flash_NetAddress& net_addr,
+bool NetAddressToAddressList(const PP_NetAddress_Private& net_addr,
                              net::AddressList* address_list) {
   if (!address_list)
     return false;
@@ -118,13 +118,13 @@ bool NetAddressToAddressList(const PP_Flash_NetAddress& net_addr,
 
 // This assert fails on OpenBSD for an unknown reason at the moment.
 #if !defined(OS_OPENBSD)
-// Make sure the storage in |PP_Flash_NetAddress| is big enough. (Do it here
+// Make sure the storage in |PP_NetAddress_Private| is big enough. (Do it here
 // since the data is opaque elsewhere.)
-COMPILE_ASSERT(sizeof(reinterpret_cast<PP_Flash_NetAddress*>(0)->data) >=
-               sizeof(sockaddr_storage), PP_Flash_NetAddress_data_too_small);
+COMPILE_ASSERT(sizeof(reinterpret_cast<PP_NetAddress_Private*>(0)->data) >=
+               sizeof(sockaddr_storage), PP_NetAddress_Private_data_too_small);
 #endif
 
-const PP_Flash_NetAddress kInvalidNetAddress = { 0 };
+const PP_NetAddress_Private kInvalidNetAddress = { 0 };
 
 class PepperMessageFilter::FlashTCPSocket {
  public:
@@ -135,7 +135,7 @@ class PepperMessageFilter::FlashTCPSocket {
   ~FlashTCPSocket();
 
   void Connect(const std::string& host, uint16_t port);
-  void ConnectWithNetAddress(const PP_Flash_NetAddress& net_addr);
+  void ConnectWithNetAddress(const PP_NetAddress_Private& net_addr);
   void SSLHandshake(const std::string& server_name, uint16_t server_port);
   void Read(int32 bytes_to_read);
   void Write(const std::string& data);
@@ -263,7 +263,7 @@ class PepperMessageFilter::FlashTCPSocketManager
                     const std::string& host,
                     uint16_t port);
   void OnMsgConnectWithNetAddress(uint32 socket_id,
-                                  const PP_Flash_NetAddress& net_addr);
+                                  const PP_NetAddress_Private& net_addr);
   void OnMsgSSLHandshake(uint32 socket_id,
                          const std::string& server_name,
                          uint16_t server_port);
@@ -343,7 +343,7 @@ void PepperMessageFilter::FlashTCPSocket::Connect(const std::string& host,
 }
 
 void PepperMessageFilter::FlashTCPSocket::ConnectWithNetAddress(
-    const PP_Flash_NetAddress& net_addr) {
+    const PP_NetAddress_Private& net_addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (connection_state_ != BEFORE_CONNECT ||
@@ -486,8 +486,8 @@ void PepperMessageFilter::FlashTCPSocket::OnConnectCompleted(int result) {
   } else {
     net::IPEndPoint ip_end_point;
     net::AddressList address_list;
-    PP_Flash_NetAddress local_addr = kInvalidNetAddress;
-    PP_Flash_NetAddress remote_addr = kInvalidNetAddress;
+    PP_NetAddress_Private local_addr = kInvalidNetAddress;
+    PP_NetAddress_Private remote_addr = kInvalidNetAddress;
 
     if (socket_->GetLocalAddress(&ip_end_point) != net::OK ||
         !IPEndPointToNetAddress(ip_end_point, &local_addr) ||
@@ -554,9 +554,9 @@ class PepperMessageFilter::FlashUDPSocket {
                  uint32 socket_id);
   ~FlashUDPSocket();
 
-  void Bind(const PP_Flash_NetAddress& addr);
+  void Bind(const PP_NetAddress_Private& addr);
   void RecvFrom(int32_t num_bytes);
-  void SendTo(const std::string& data, const PP_Flash_NetAddress& addr);
+  void SendTo(const std::string& data, const PP_NetAddress_Private& addr);
 
  private:
   void SendBindACK(bool result);
@@ -607,7 +607,7 @@ PepperMessageFilter::FlashUDPSocket::~FlashUDPSocket() {
 }
 
 void PepperMessageFilter::FlashUDPSocket::Bind(
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress_Private& addr) {
   socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
 
   net::IPEndPoint address;
@@ -639,7 +639,7 @@ void PepperMessageFilter::FlashUDPSocket::RecvFrom(int32_t num_bytes) {
 
 void PepperMessageFilter::FlashUDPSocket::SendTo(
     const std::string& data,
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress_Private& addr) {
   if (sendto_buffer_.get() || data.empty()) {
     SendSendToACKError();
     return;
@@ -665,7 +665,7 @@ void PepperMessageFilter::FlashUDPSocket::SendTo(
 }
 
 void PepperMessageFilter::FlashUDPSocket::SendRecvFromACKError() {
-  PP_Flash_NetAddress addr = kInvalidNetAddress;
+  PP_NetAddress_Private addr = kInvalidNetAddress;
   pepper_message_filter_->Send(
       new PpapiMsg_PPBFlashUDPSocket_RecvFromACK(
           routing_id_, plugin_dispatcher_id_, socket_id_, false,
@@ -687,9 +687,9 @@ void PepperMessageFilter::FlashUDPSocket::SendBindACK(bool result) {
 void PepperMessageFilter::FlashUDPSocket::OnRecvFromCompleted(int result) {
   DCHECK(recvfrom_buffer_.get());
 
-  // Convert IPEndPoint we get back from RecvFrom to a PP_Flash_NetAddress,
+  // Convert IPEndPoint we get back from RecvFrom to a PP_NetAddress_Private,
   // to send back to Flash.
-  PP_Flash_NetAddress addr = kInvalidNetAddress;
+  PP_NetAddress_Private addr = kInvalidNetAddress;
   if (!IPEndPointToNetAddress(recvfrom_address_, &addr) || result < 0) {
     SendRecvFromACKError();
   } else {
@@ -743,7 +743,7 @@ void PepperMessageFilter::FlashTCPSocketManager::OnMsgConnect(
 
 void PepperMessageFilter::FlashTCPSocketManager::OnMsgConnectWithNetAddress(
     uint32 socket_id,
-    const PP_Flash_NetAddress& net_addr) {
+    const PP_NetAddress_Private& net_addr) {
   SocketMap::iterator iter = sockets_.find(socket_id);
   if (iter == sockets_.end()) {
     NOTREACHED();
@@ -823,12 +823,12 @@ class PepperMessageFilter::FlashUDPSocketManager
                    uint32 plugin_dispatcher_id,
                    uint32* socket_id);
   void OnMsgBind(uint32 socket_id,
-                 const PP_Flash_NetAddress& addr);
+                 const PP_NetAddress_Private& addr);
   void OnMsgRecvFrom(uint32 socket_id,
                      int32_t num_bytes);
   void OnMsgSendTo(uint32 socket_id,
                    const std::string& data,
-                   const PP_Flash_NetAddress& addr);
+                   const PP_NetAddress_Private& addr);
   void OnMsgClose(uint32 socket_id);
 
  private:
@@ -854,7 +854,7 @@ void PepperMessageFilter::FlashUDPSocketManager::OnMsgCreate(
 
 void PepperMessageFilter::FlashUDPSocketManager::OnMsgBind(
     uint32 socket_id,
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress_Private& addr) {
   SocketMap::iterator iter = sockets_.find(socket_id);
   if (iter == sockets_.end()) {
     NOTREACHED();
@@ -879,7 +879,7 @@ void PepperMessageFilter::FlashUDPSocketManager::OnMsgRecvFrom(
 void PepperMessageFilter::FlashUDPSocketManager::OnMsgSendTo(
     uint32 socket_id,
     const std::string& data,
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress_Private& addr) {
   SocketMap::iterator iter = sockets_.find(socket_id);
   if (iter == sockets_.end()) {
     NOTREACHED();
@@ -988,9 +988,9 @@ bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg,
 
 namespace {
 
-int ConnectTcpSocket(const PP_Flash_NetAddress& addr,
-                     PP_Flash_NetAddress* local_addr_out,
-                     PP_Flash_NetAddress* remote_addr_out) {
+int ConnectTcpSocket(const PP_NetAddress_Private& addr,
+                     PP_NetAddress_Private* local_addr_out,
+                     PP_NetAddress_Private* remote_addr_out) {
   *local_addr_out = kInvalidNetAddress;
   *remote_addr_out = kInvalidNetAddress;
 
@@ -1082,14 +1082,15 @@ void PepperMessageFilter::OnConnectTcp(int routing_id,
   lookup_request->Start();
 }
 
-void PepperMessageFilter::OnConnectTcpAddress(int routing_id,
-                                              int request_id,
-                                              const PP_Flash_NetAddress& addr) {
+void PepperMessageFilter::OnConnectTcpAddress(
+    int routing_id,
+    int request_id,
+    const PP_NetAddress_Private& addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Validate the address and then continue (doing |connect()|) on a worker
   // thread.
-  if (!ppapi::FlashNetAddressImpl::ValidateNetAddress(addr) ||
+  if (!ppapi::NetAddressPrivateImpl::ValidateNetAddress(addr) ||
       !base::WorkerPool::PostTask(FROM_HERE,
            NewRunnableMethod(
                this,
@@ -1132,9 +1133,9 @@ void PepperMessageFilter::ConnectTcpOnWorkerThread(int routing_id,
                                                    net::AddressList addresses) {
   IPC::PlatformFileForTransit socket_for_transit =
       IPC::InvalidPlatformFileForTransit();
-  PP_Flash_NetAddress local_addr = kInvalidNetAddress;
-  PP_Flash_NetAddress remote_addr = kInvalidNetAddress;
-  PP_Flash_NetAddress addr = kInvalidNetAddress;
+  PP_NetAddress_Private local_addr = kInvalidNetAddress;
+  PP_NetAddress_Private remote_addr = kInvalidNetAddress;
+  PP_NetAddress_Private addr = kInvalidNetAddress;
 
   for (const struct addrinfo* ai = addresses.head(); ai; ai = ai->ai_next) {
     if (SockaddrToNetAddress(ai->ai_addr, ai->ai_addrlen, &addr)) {
@@ -1159,11 +1160,11 @@ void PepperMessageFilter::ConnectTcpOnWorkerThread(int routing_id,
 void PepperMessageFilter::ConnectTcpAddressOnWorkerThread(
     int routing_id,
     int request_id,
-    PP_Flash_NetAddress addr) {
+    PP_NetAddress_Private addr) {
   IPC::PlatformFileForTransit socket_for_transit =
       IPC::InvalidPlatformFileForTransit();
-  PP_Flash_NetAddress local_addr = kInvalidNetAddress;
-  PP_Flash_NetAddress remote_addr = kInvalidNetAddress;
+  PP_NetAddress_Private local_addr = kInvalidNetAddress;
+  PP_NetAddress_Private remote_addr = kInvalidNetAddress;
 
   int fd = ConnectTcpSocket(addr, &local_addr, &remote_addr);
   if (fd != -1)
diff --git a/content/browser/renderer_host/pepper_message_filter.h b/content/browser/renderer_host/pepper_message_filter.h
index 6b15733..8aec438 100644
--- a/content/browser/renderer_host/pepper_message_filter.h
+++ b/content/browser/renderer_host/pepper_message_filter.h
@@ -13,7 +13,8 @@
 #include "base/time.h"
 #include "content/browser/browser_message_filter.h"
 #include "content/browser/font_list_async.h"
-#include "ppapi/c/private/ppb_flash_net_connector.h"
+
+struct PP_NetAddress_Private;
 
 namespace content {
 class ResourceContext;
@@ -55,7 +56,7 @@ class PepperMessageFilter : public BrowserMessageFilter {
                     uint16 port);
   void OnConnectTcpAddress(int routing_id,
                            int request_id,
-                           const PP_Flash_NetAddress& address);
+                           const PP_NetAddress_Private& address);
 
   // |Send()| a |PepperMsg_ConnectTcpACK|, which reports an error.
   bool SendConnectTcpACKError(int routing_id,
@@ -76,7 +77,7 @@ class PepperMessageFilter : public BrowserMessageFilter {
   // Continuation of |OnConnectTcpAddress()|.
   void ConnectTcpAddressOnWorkerThread(int routing_id,
                                        int request_id,
-                                       PP_Flash_NetAddress addr);
+                                       PP_NetAddress_Private addr);
 #endif  // ENABLE_FLAPPER_HACKS
 
   void OnGetLocalTimeZoneOffset(base::Time t, double* result);
diff --git a/content/common/pepper_messages.h b/content/common/pepper_messages.h
index f702ee6..bf86c4e 100644
--- a/content/common/pepper_messages.h
+++ b/content/common/pepper_messages.h
@@ -19,8 +19,8 @@
 IPC_MESSAGE_ROUTED4(PepperMsg_ConnectTcpACK,
                     int /* request_id */,
                     IPC::PlatformFileForTransit /* socket */,
-                    PP_Flash_NetAddress /* local_addr */,
-                    PP_Flash_NetAddress /* remote_addr */)
+                    PP_NetAddress_Private /* local_addr */,
+                    PP_NetAddress_Private /* remote_addr */)
 
 // Pepper (non-file-system) messages sent from the renderer to the browser.
 
@@ -33,7 +33,7 @@ IPC_MESSAGE_CONTROL4(PepperMsg_ConnectTcp,
 IPC_MESSAGE_CONTROL3(PepperMsg_ConnectTcpAddress,
                      int /* routing_id */,
                      int /* request_id */,
-                     PP_Flash_NetAddress /* addr */)
+                     PP_NetAddress_Private /* addr */)
 
 IPC_SYNC_MESSAGE_CONTROL1_1(PepperMsg_GetLocalTimeZoneOffset,
                             base::Time /* t */,
diff --git a/content/renderer/pepper_plugin_delegate_impl.cc b/content/renderer/pepper_plugin_delegate_impl.cc
index 56aa7b9..fed8063 100644
--- a/content/renderer/pepper_plugin_delegate_impl.cc
+++ b/content/renderer/pepper_plugin_delegate_impl.cc
@@ -1458,7 +1458,7 @@ int32_t PepperPluginDelegateImpl::ConnectTcp(
 
 int32_t PepperPluginDelegateImpl::ConnectTcpAddress(
     webkit::ppapi::PPB_Flash_NetConnector_Impl* connector,
-    const struct PP_Flash_NetAddress* addr) {
+    const struct PP_NetAddress_Private* addr) {
   int request_id = pending_connect_tcps_.Add(
       new scoped_refptr<webkit::ppapi::PPB_Flash_NetConnector_Impl>(connector));
   IPC::Message* msg =
@@ -1476,8 +1476,8 @@ int32_t PepperPluginDelegateImpl::ConnectTcpAddress(
 void PepperPluginDelegateImpl::OnConnectTcpACK(
     int request_id,
     base::PlatformFile socket,
-    const PP_Flash_NetAddress& local_addr,
-    const PP_Flash_NetAddress& remote_addr) {
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
   scoped_refptr<webkit::ppapi::PPB_Flash_NetConnector_Impl> connector =
       *pending_connect_tcps_.Lookup(request_id);
   pending_connect_tcps_.Remove(request_id);
diff --git a/content/renderer/pepper_plugin_delegate_impl.h b/content/renderer/pepper_plugin_delegate_impl.h
index e99e2e0..ca9cdda 100644
--- a/content/renderer/pepper_plugin_delegate_impl.h
+++ b/content/renderer/pepper_plugin_delegate_impl.h
@@ -299,13 +299,13 @@ class PepperPluginDelegateImpl
       uint16_t port) OVERRIDE;
   virtual int32_t ConnectTcpAddress(
       webkit::ppapi::PPB_Flash_NetConnector_Impl* connector,
-      const struct PP_Flash_NetAddress* addr) OVERRIDE;
+      const struct PP_NetAddress_Private* addr) OVERRIDE;
   // This is the completion for both |ConnectTcp()| and |ConnectTcpAddress()|.
   void OnConnectTcpACK(
       int request_id,
       base::PlatformFile socket,
-      const PP_Flash_NetAddress& local_addr,
-      const PP_Flash_NetAddress& remote_addr);
+      const PP_NetAddress_Private& local_addr,
+      const PP_NetAddress_Private& remote_addr);
   virtual int32_t ShowContextMenu(
       webkit::ppapi::PluginInstance* instance,
       webkit::ppapi::PPB_Flash_Menu_Impl* menu,
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index b5c40d8..5ebcd60 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -4656,8 +4656,8 @@ void RenderViewImpl::OnSelectPopupMenuItem(int selected_index) {
 void RenderViewImpl::OnConnectTcpACK(
     int request_id,
     IPC::PlatformFileForTransit socket_for_transit,
-    const PP_Flash_NetAddress& local_addr,
-    const PP_Flash_NetAddress& remote_addr) {
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
   pepper_delegate_.OnConnectTcpACK(
       request_id,
       IPC::PlatformFileForTransitToPlatformFile(socket_for_transit),
diff --git a/content/renderer/render_view_impl.h b/content/renderer/render_view_impl.h
index 54dbb1b..3f23318 100644
--- a/content/renderer/render_view_impl.h
+++ b/content/renderer/render_view_impl.h
@@ -74,7 +74,7 @@ class SpeechInputDispatcher;
 class WebPluginDelegateProxy;
 class WebUIBindings;
 struct ContextMenuMediaParams;
-struct PP_Flash_NetAddress;
+struct PP_NetAddress_Private;
 struct ViewHostMsg_RunFileChooser_Params;
 struct ViewMsg_SwapOut_Params;
 struct ViewMsg_Navigate_Params;
@@ -756,8 +756,8 @@ class RenderViewImpl : public RenderWidget,
 #if defined(ENABLE_FLAPPER_HACKS)
   void OnConnectTcpACK(int request_id,
                        IPC::PlatformFileForTransit socket_for_transit,
-                       const PP_Flash_NetAddress& local_addr,
-                       const PP_Flash_NetAddress& remote_addr);
+                       const PP_NetAddress_Private& local_addr,
+                       const PP_NetAddress_Private& remote_addr);
 #endif
   void OnContextMenuClosed(
       const webkit_glue::CustomContextMenuContext& custom_context);
diff --git a/ppapi/api/private/ppb_flash_net_connector.idl b/ppapi/api/private/ppb_flash_net_connector.idl
deleted file mode 100644
index 3886dad..0000000
--- a/ppapi/api/private/ppb_flash_net_connector.idl
+++ /dev/null
@@ -1,41 +0,0 @@
-/* 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.
- */
-
-/* This is an opaque type holding a network address. */
-struct PP_Flash_NetAddress {
-  uint32_t size;
-  [fixed=128] uint8_t data;
-};
-
-interface PPB_Flash_NetConnector_0_1 {
-  PP_Resource Create(
-      [in] PP_Instance instance_id);
-  PP_Bool IsFlashNetConnector(
-      [in] PP_Resource resource_id);
-
-  /* Connect to a TCP port given as a host-port pair. The local and remote
-   * addresses of the connection (if successful) are returned in
-   * |local_addr_out| and |remote_addr_out|, respectively, if non-null.
-   */
-  int32_t ConnectTcp(
-      [in] PP_Resource connector_id,
-      [in] str_t host,
-      [in] uint16_t port,
-      [out] PP_FileHandle socket_out,
-      [out] PP_Flash_NetAddress local_addr_out,
-      [out] PP_Flash_NetAddress remote_addr_out,
-      [in] PP_CompletionCallback callback);
-
-  /* Same as |ConnectTcp()|, but connecting to the address given by |addr|. A
-   * typical use-case would be for reconnections.
-   */
-  int32_t ConnectTcpAddress(
-      [in] PP_Resource connector_id,
-      [in] PP_Flash_NetAddress addr,
-      [out] PP_FileHandle socket_out,
-      [out] PP_Flash_NetAddress local_addr_out,
-      [out] PP_Flash_NetAddress remote_addr_out,
-      [in] PP_CompletionCallback callback);
-};
diff --git a/ppapi/api/private/ppb_flash_tcp_socket.idl b/ppapi/api/private/ppb_flash_tcp_socket.idl
index e832809..fae44e1 100644
--- a/ppapi/api/private/ppb_flash_tcp_socket.idl
+++ b/ppapi/api/private/ppb_flash_tcp_socket.idl
@@ -41,7 +41,7 @@ interface PPB_Flash_TCPSocket {
    * use-case would be for reconnections.
    */
   int32_t ConnectWithNetAddress([in] PP_Resource tcp_socket,
-                                [in] PP_Flash_NetAddress addr,
+                                [in] PP_NetAddress_Private addr,
                                 [in] PP_CompletionCallback callback);
 
   /**
@@ -49,14 +49,14 @@ interface PPB_Flash_TCPSocket {
    * Returns PP_TRUE on success.
    */
   PP_Bool GetLocalAddress([in] PP_Resource tcp_socket,
-                          [out] PP_Flash_NetAddress local_addr);
+                          [out] PP_NetAddress_Private local_addr);
 
   /**
    * Gets the remote address of the socket, if it has been connected.
    * Returns PP_TRUE on success.
    */
   PP_Bool GetRemoteAddress([in] PP_Resource tcp_socket,
-                           [out] PP_Flash_NetAddress remote_addr);
+                           [out] PP_NetAddress_Private remote_addr);
 
   /**
    * Does SSL handshake and moves to sending and receiving encrypted data. The
diff --git a/ppapi/api/private/ppb_flash_udp_socket.idl b/ppapi/api/private/ppb_flash_udp_socket.idl
index 7328db8..3fd5523 100644
--- a/ppapi/api/private/ppb_flash_udp_socket.idl
+++ b/ppapi/api/private/ppb_flash_udp_socket.idl
@@ -24,7 +24,7 @@ interface PPB_Flash_UDPSocket {
 
   /* Creates a socket and binds to the address given by |addr|. */
   int32_t Bind([in] PP_Resource udp_socket,
-               [in] PP_Flash_NetAddress addr,
+               [in] PP_NetAddress_Private addr,
                [in] PP_CompletionCallback callback);
 
   /* Performs a non-blocking recvfrom call on socket.
@@ -41,7 +41,7 @@ interface PPB_Flash_UDPSocket {
    * was received from is stored in |addr|.
    */
   PP_Bool GetRecvFromAddress([in] PP_Resource udp_socket,
-                             [out] PP_Flash_NetAddress addr);
+                             [out] PP_NetAddress_Private addr);
 
   /* Performs a non-blocking sendto call on the socket created and
    * bound(has already called Bind).  The callback |callback| is
@@ -50,10 +50,9 @@ interface PPB_Flash_UDPSocket {
   int32_t SendTo([in] PP_Resource udp_socket,
                  [in] str_t buffer,
                  [in] int32_t num_bytes,
-                 [in] PP_Flash_NetAddress addr,
+                 [in] PP_NetAddress_Private addr,
                  [in] PP_CompletionCallback callback);
 
   /* Cancels all pending reads and writes, and closes the socket. */
   void Close([in] PP_Resource udp_socket);
 };
-
diff --git a/ppapi/api/private/ppb_flash_net_address.idl b/ppapi/api/private/ppb_net_address_private.idl
index 012c024..a086d7f 100644
--- a/ppapi/api/private/ppb_flash_net_address.idl
+++ b/ppapi/api/private/ppb_net_address_private.idl
@@ -4,7 +4,7 @@
  */
 
 /**
- * This file defines the <code>PPB_Flash_NetAddress</code> interface.
+ * This file defines the <code>PPB_NetAddress_Private</code> interface.
  */
 
 label Chrome {
@@ -15,27 +15,27 @@ label Chrome {
  * This is an opaque type holding a network address.
  */
 [assert_size(132)]
-struct PP_Flash_NetAddress {
+struct PP_NetAddress_Private {
   uint32_t size;
   char[128] data;
 };
 
 /**
- * The <code>PPB_Flash_NetAddress</code> interface provides operations on
+ * The <code>PPB_NetAddress_Private</code> interface provides operations on
  * network addresses.
  */
-interface PPB_Flash_NetAddress {
+interface PPB_NetAddress_Private {
   /**
     * Returns PP_TRUE if the two addresses are equal (host and port).
     */
-  PP_Bool AreEqual([in] PP_Flash_NetAddress addr1,
-                   [in] PP_Flash_NetAddress addr2);
+  PP_Bool AreEqual([in] PP_NetAddress_Private addr1,
+                   [in] PP_NetAddress_Private addr2);
 
   /**
     * Returns PP_TRUE if the two addresses refer to the same host.
     */
-  PP_Bool AreHostsEqual([in] PP_Flash_NetAddress addr1,
-                        [in] PP_Flash_NetAddress addr2);
+  PP_Bool AreHostsEqual([in] PP_NetAddress_Private addr1,
+                        [in] PP_NetAddress_Private addr2);
 
   /**
     * Returns a human-readable description of the network address, optionally
@@ -43,19 +43,19 @@ interface PPB_Flash_NetAddress {
     * or an undefined var on failure.
     */
   PP_Var Describe([in] PP_Module module,
-                  [in] PP_Flash_NetAddress addr,
+                  [in] PP_NetAddress_Private addr,
                   [in] PP_Bool include_port);
 
   /**
     * Replaces the port in the given source address. Returns PP_TRUE on success.
     */
-  PP_Bool ReplacePort([in] PP_Flash_NetAddress src_addr,
+  PP_Bool ReplacePort([in] PP_NetAddress_Private src_addr,
                       [in] uint16_t port,
-                      [out] PP_Flash_NetAddress dest_addr);
+                      [out] PP_NetAddress_Private dest_addr);
 
   /**
     * Gets the "any" address (for IPv4 or IPv6); for use with UDP Bind.
     */
   void GetAnyAddress([in] PP_Bool is_ipv6,
-                     [out] PP_Flash_NetAddress addr);
+                     [out] PP_NetAddress_Private addr);
 };
diff --git a/ppapi/c/private/ppb_flash_net_connector.h b/ppapi/c/private/ppb_flash_net_connector.h
index bfe6981..675f5be 100644
--- a/ppapi/c/private/ppb_flash_net_connector.h
+++ b/ppapi/c/private/ppb_flash_net_connector.h
@@ -5,11 +5,13 @@
 #ifndef PPAPI_C_PRIVATE_PPB_FLASH_NET_CONNECTOR_H_
 #define PPAPI_C_PRIVATE_PPB_FLASH_NET_CONNECTOR_H_
 
+// TODO(viettrungluu): Remove this interface; it's on life-support right now.
+
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/private/ppb_flash_file.h"  // For |PP_FileHandle|.
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
 
 #define PPB_FLASH_NETCONNECTOR_INTERFACE "PPB_Flash_NetConnector;0.2"
 
@@ -24,17 +26,17 @@ struct PPB_Flash_NetConnector {
                         const char* host,
                         uint16_t port,
                         PP_FileHandle* socket_out,
-                        struct PP_Flash_NetAddress* local_addr_out,
-                        struct PP_Flash_NetAddress* remote_addr_out,
+                        struct PP_NetAddress_Private* local_addr_out,
+                        struct PP_NetAddress_Private* remote_addr_out,
                         struct PP_CompletionCallback callback);
 
   // Same as |ConnectTcp()|, but connecting to the address given by |addr|. A
   // typical use-case would be for reconnections.
   int32_t (*ConnectTcpAddress)(PP_Resource connector_id,
-                               const struct PP_Flash_NetAddress* addr,
+                               const struct PP_NetAddress_Private* addr,
                                PP_FileHandle* socket_out,
-                               struct PP_Flash_NetAddress* local_addr_out,
-                               struct PP_Flash_NetAddress* remote_addr_out,
+                               struct PP_NetAddress_Private* local_addr_out,
+                               struct PP_NetAddress_Private* remote_addr_out,
                                struct PP_CompletionCallback callback);
 };
 
diff --git a/ppapi/c/private/ppb_flash_tcp_socket.h b/ppapi/c/private/ppb_flash_tcp_socket.h
index cf75df9..2a6bc19 100644
--- a/ppapi/c/private/ppb_flash_tcp_socket.h
+++ b/ppapi/c/private/ppb_flash_tcp_socket.h
@@ -3,7 +3,7 @@
  * found in the LICENSE file.
  */
 
-/* From private/ppb_flash_tcp_socket.idl modified Mon Oct 17 16:09:17 2011. */
+/* From private/ppb_flash_tcp_socket.idl modified Wed Nov  9 12:53:35 2011. */
 
 #ifndef PPAPI_C_PRIVATE_PPB_FLASH_TCP_SOCKET_H_
 #define PPAPI_C_PRIVATE_PPB_FLASH_TCP_SOCKET_H_
@@ -14,7 +14,7 @@
 #include "ppapi/c/pp_macros.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_stdint.h"
-#include "ppapi/c/private/ppb_flash_net_address.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
 
 #define PPB_FLASH_TCPSOCKET_INTERFACE_0_2 "PPB_Flash_TCPSocket;0.2"
 #define PPB_FLASH_TCPSOCKET_INTERFACE PPB_FLASH_TCPSOCKET_INTERFACE_0_2
@@ -56,20 +56,20 @@ struct PPB_Flash_TCPSocket {
    * use-case would be for reconnections.
    */
   int32_t (*ConnectWithNetAddress)(PP_Resource tcp_socket,
-                                   const struct PP_Flash_NetAddress* addr,
+                                   const struct PP_NetAddress_Private* addr,
                                    struct PP_CompletionCallback callback);
   /**
    * Gets the local address of the socket, if it has been connected.
    * Returns PP_TRUE on success.
    */
   PP_Bool (*GetLocalAddress)(PP_Resource tcp_socket,
-                             struct PP_Flash_NetAddress* local_addr);
+                             struct PP_NetAddress_Private* local_addr);
   /**
    * Gets the remote address of the socket, if it has been connected.
    * Returns PP_TRUE on success.
    */
   PP_Bool (*GetRemoteAddress)(PP_Resource tcp_socket,
-                              struct PP_Flash_NetAddress* remote_addr);
+                              struct PP_NetAddress_Private* remote_addr);
   /**
    * Does SSL handshake and moves to sending and receiving encrypted data. The
    * socket must have been successfully connected. |server_name| will be
diff --git a/ppapi/c/private/ppb_flash_udp_socket.h b/ppapi/c/private/ppb_flash_udp_socket.h
index b7fc66e..504e1b6 100644
--- a/ppapi/c/private/ppb_flash_udp_socket.h
+++ b/ppapi/c/private/ppb_flash_udp_socket.h
@@ -3,7 +3,7 @@
  * found in the LICENSE file.
  */
 
-/* From private/ppb_flash_udp_socket.idl modified Mon Oct 17 15:55:01 2011. */
+/* From private/ppb_flash_udp_socket.idl modified Wed Nov  9 12:53:35 2011. */
 
 #ifndef PPAPI_C_PRIVATE_PPB_FLASH_UDP_SOCKET_H_
 #define PPAPI_C_PRIVATE_PPB_FLASH_UDP_SOCKET_H_
@@ -14,7 +14,7 @@
 #include "ppapi/c/pp_macros.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_stdint.h"
-#include "ppapi/c/private/ppb_flash_net_address.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
 
 #define PPB_FLASH_UDPSOCKET_INTERFACE_0_1 "PPB_Flash_UDPSocket;0.1"
 #define PPB_FLASH_UDPSOCKET_INTERFACE PPB_FLASH_UDPSOCKET_INTERFACE_0_1
@@ -40,7 +40,7 @@ struct PPB_Flash_UDPSocket {
   PP_Bool (*IsFlashUDPSocket)(PP_Resource resource_id);
   /* Creates a socket and binds to the address given by |addr|. */
   int32_t (*Bind)(PP_Resource udp_socket,
-                  const struct PP_Flash_NetAddress* addr,
+                  const struct PP_NetAddress_Private* addr,
                   struct PP_CompletionCallback callback);
   /* Performs a non-blocking recvfrom call on socket.
    * Bind must be called first. |callback| is invoked when recvfrom
@@ -55,7 +55,7 @@ struct PPB_Flash_UDPSocket {
    * was received from is stored in |addr|.
    */
   PP_Bool (*GetRecvFromAddress)(PP_Resource udp_socket,
-                                struct PP_Flash_NetAddress* addr);
+                                struct PP_NetAddress_Private* addr);
   /* Performs a non-blocking sendto call on the socket created and
    * bound(has already called Bind).  The callback |callback| is
    * invoked when sendto completes.
@@ -63,7 +63,7 @@ struct PPB_Flash_UDPSocket {
   int32_t (*SendTo)(PP_Resource udp_socket,
                     const char* buffer,
                     int32_t num_bytes,
-                    const struct PP_Flash_NetAddress* addr,
+                    const struct PP_NetAddress_Private* addr,
                     struct PP_CompletionCallback callback);
   /* Cancels all pending reads and writes, and closes the socket. */
   void (*Close)(PP_Resource udp_socket);
diff --git a/ppapi/c/private/ppb_flash_net_address.h b/ppapi/c/private/ppb_net_address_private.h
index 20b2ac9..68fbaae 100644
--- a/ppapi/c/private/ppb_flash_net_address.h
+++ b/ppapi/c/private/ppb_net_address_private.h
@@ -3,10 +3,10 @@
  * found in the LICENSE file.
  */
 
-/* From private/ppb_flash_net_address.idl modified Fri Nov  4 12:47:53 2011. */
+/* From private/ppb_net_address_private.idl modified Wed Nov  9 12:53:35 2011. */
 
-#ifndef PPAPI_C_PRIVATE_PPB_FLASH_NET_ADDRESS_H_
-#define PPAPI_C_PRIVATE_PPB_FLASH_NET_ADDRESS_H_
+#ifndef PPAPI_C_PRIVATE_PPB_NET_ADDRESS_PRIVATE_H_
+#define PPAPI_C_PRIVATE_PPB_NET_ADDRESS_PRIVATE_H_
 
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_macros.h"
@@ -14,12 +14,12 @@
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/c/pp_var.h"
 
-#define PPB_FLASH_NETADDRESS_INTERFACE_0_1 "PPB_Flash_NetAddress;0.1"
-#define PPB_FLASH_NETADDRESS_INTERFACE PPB_FLASH_NETADDRESS_INTERFACE_0_1
+#define PPB_NETADDRESS_PRIVATE_INTERFACE_0_1 "PPB_NetAddress_Private;0.1"
+#define PPB_NETADDRESS_PRIVATE_INTERFACE PPB_NETADDRESS_PRIVATE_INTERFACE_0_1
 
 /**
  * @file
- * This file defines the <code>PPB_Flash_NetAddress</code> interface.
+ * This file defines the <code>PPB_NetAddress_Private</code> interface.
  */
 
 
@@ -30,11 +30,11 @@
 /**
  * This is an opaque type holding a network address.
  */
-struct PP_Flash_NetAddress {
+struct PP_NetAddress_Private {
   uint32_t size;
   char data[128];
 };
-PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_Flash_NetAddress, 132);
+PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_NetAddress_Private, 132);
 /**
  * @}
  */
@@ -44,42 +44,42 @@ PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_Flash_NetAddress, 132);
  * @{
  */
 /**
- * The <code>PPB_Flash_NetAddress</code> interface provides operations on
+ * The <code>PPB_NetAddress_Private</code> interface provides operations on
  * network addresses.
  */
-struct PPB_Flash_NetAddress {
+struct PPB_NetAddress_Private {
   /**
    * Returns PP_TRUE if the two addresses are equal (host and port).
    */
-  PP_Bool (*AreEqual)(const struct PP_Flash_NetAddress* addr1,
-                      const struct PP_Flash_NetAddress* addr2);
+  PP_Bool (*AreEqual)(const struct PP_NetAddress_Private* addr1,
+                      const struct PP_NetAddress_Private* addr2);
   /**
    * Returns PP_TRUE if the two addresses refer to the same host.
    */
-  PP_Bool (*AreHostsEqual)(const struct PP_Flash_NetAddress* addr1,
-                           const struct PP_Flash_NetAddress* addr2);
+  PP_Bool (*AreHostsEqual)(const struct PP_NetAddress_Private* addr1,
+                           const struct PP_NetAddress_Private* addr2);
   /**
    * Returns a human-readable description of the network address, optionally
    * including the port (e.g., "192.168.0.1", "192.168.0.1:99", or "[::1]:80"),
    * or an undefined var on failure.
    */
   struct PP_Var (*Describe)(PP_Module module,
-                            const struct PP_Flash_NetAddress* addr,
+                            const struct PP_NetAddress_Private* addr,
                             PP_Bool include_port);
   /**
    * Replaces the port in the given source address. Returns PP_TRUE on success.
    */
-  PP_Bool (*ReplacePort)(const struct PP_Flash_NetAddress* src_addr,
+  PP_Bool (*ReplacePort)(const struct PP_NetAddress_Private* src_addr,
                          uint16_t port,
-                         struct PP_Flash_NetAddress* dest_addr);
+                         struct PP_NetAddress_Private* dest_addr);
   /**
    * Gets the "any" address (for IPv4 or IPv6); for use with UDP Bind.
    */
-  void (*GetAnyAddress)(PP_Bool is_ipv6, struct PP_Flash_NetAddress* addr);
+  void (*GetAnyAddress)(PP_Bool is_ipv6, struct PP_NetAddress_Private* addr);
 };
 /**
  * @}
  */
 
-#endif  /* PPAPI_C_PRIVATE_PPB_FLASH_NET_ADDRESS_H_ */
+#endif  /* PPAPI_C_PRIVATE_PPB_NET_ADDRESS_PRIVATE_H_ */
 
diff --git a/ppapi/cpp/private/flash_net_address.cc b/ppapi/cpp/private/flash_net_address.cc
deleted file mode 100644
index 93984d7..0000000
--- a/ppapi/cpp/private/flash_net_address.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-// 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.
-
-// TODO(viettrungluu): See the comment in corresponding .h file.
-
-#include "ppapi/cpp/private/flash_net_address.h"
-
-#include "ppapi/c/pp_bool.h"
-#include "ppapi/cpp/module.h"
-#include "ppapi/cpp/module_impl.h"
-#include "ppapi/cpp/var.h"
-#include "ppapi/c/private/ppb_flash_net_address.h"
-
-namespace pp {
-
-namespace {
-
-template <> const char* interface_name<PPB_Flash_NetAddress>() {
-  return PPB_FLASH_NETADDRESS_INTERFACE;
-}
-
-}  // namespace
-
-namespace flash {
-
-// static
-bool NetAddress::AreEqual(const PP_Flash_NetAddress& addr1,
-                          const PP_Flash_NetAddress& addr2) {
-  if (!has_interface<PPB_Flash_NetAddress>())
-    return false;
-  return !!get_interface<PPB_Flash_NetAddress>()->AreEqual(&addr1, &addr2);
-}
-
-// static
-bool NetAddress::AreHostsEqual(const PP_Flash_NetAddress& addr1,
-                               const PP_Flash_NetAddress& addr2) {
-  if (!has_interface<PPB_Flash_NetAddress>())
-    return false;
-  return !!get_interface<PPB_Flash_NetAddress>()->AreHostsEqual(&addr1, &addr2);
-}
-
-// static
-std::string NetAddress::Describe(const PP_Flash_NetAddress& addr,
-                                 bool include_port) {
-  if (!has_interface<PPB_Flash_NetAddress>())
-    return std::string();
-
-  Module* module = Module::Get();
-  if (!module)
-    return std::string();
-
-  Var result(Var::PassRef(),
-             get_interface<PPB_Flash_NetAddress>()->Describe(
-                 module->pp_module(),
-                 &addr,
-                 PP_FromBool(include_port)));
-  return result.is_string() ? result.AsString() : std::string();
-}
-
-// static
-bool NetAddress::ReplacePort(const PP_Flash_NetAddress& addr_in,
-                             uint16_t port,
-                             PP_Flash_NetAddress* addr_out) {
-  if (!has_interface<PPB_Flash_NetAddress>())
-    return false;
-  return !!get_interface<PPB_Flash_NetAddress>()->ReplacePort(&addr_in,
-                                                              port,
-                                                              addr_out);
-}
-
-// static
-void NetAddress::GetAnyAddress(bool is_ipv6, PP_Flash_NetAddress* addr) {
-  if (!has_interface<PPB_Flash_NetAddress>())
-    return;
-  get_interface<PPB_Flash_NetAddress>()->GetAnyAddress(PP_FromBool(is_ipv6),
-                                                       addr);
-}
-
-}  // namespace flash
-}  // namespace pp
diff --git a/ppapi/cpp/private/flash_net_address.h b/ppapi/cpp/private/flash_net_address.h
deleted file mode 100644
index f08cb52..0000000
--- a/ppapi/cpp/private/flash_net_address.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// 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.
-
-// TODO(viettrungluu): This (and the .cc file) contain C++ wrappers for things
-// in ppapi/c/private/ppb_flash_net_address.h. This is currently not used in
-// (or even compiled with) Chromium.
-
-#ifndef PPAPI_CPP_PRIVATE_FLASH_NET_ADDRESS_H_
-#define PPAPI_CPP_PRIVATE_FLASH_NET_ADDRESS_H_
-
-#include <string>
-
-#include "ppapi/c/pp_stdint.h"
-
-struct PP_Flash_NetAddress;
-
-namespace pp {
-namespace flash {
-
-class NetAddress {
- public:
-  static bool AreEqual(const PP_Flash_NetAddress& addr1,
-                       const PP_Flash_NetAddress& addr2);
-  static bool AreHostsEqual(const PP_Flash_NetAddress& addr1,
-                            const PP_Flash_NetAddress& addr2);
-  static std::string Describe(const PP_Flash_NetAddress& addr,
-                              bool include_port);
-  static bool ReplacePort(const PP_Flash_NetAddress& addr_in,
-                          uint16_t port,
-                          PP_Flash_NetAddress* addr_out);
-  static void GetAnyAddress(bool is_ipv6, PP_Flash_NetAddress* addr);
-};
-
-}  // namespace flash
-}  // namespace pp
-
-#endif  // PPAPI_CPP_PRIVATE_FLASH_NET_ADDRESS_H_
diff --git a/ppapi/cpp/private/flash_net_connector.cc b/ppapi/cpp/private/flash_net_connector.cc
index 05b26f2..faa6c9b3a 100644
--- a/ppapi/cpp/private/flash_net_connector.cc
+++ b/ppapi/cpp/private/flash_net_connector.cc
@@ -34,8 +34,8 @@ NetConnector::NetConnector(const Instance& instance) {
 int32_t NetConnector::ConnectTcp(const char* host,
                                  uint16_t port,
                                  PP_FileHandle* socket_out,
-                                 PP_Flash_NetAddress* local_addr_out,
-                                 PP_Flash_NetAddress* remote_addr_out,
+                                 PP_NetAddress_Private* local_addr_out,
+                                 PP_NetAddress_Private* remote_addr_out,
                                  const CompletionCallback& cc) {
   if (!has_interface<PPB_Flash_NetConnector>())
     return cc.MayForce(PP_ERROR_NOINTERFACE);
@@ -46,10 +46,10 @@ int32_t NetConnector::ConnectTcp(const char* host,
       cc.pp_completion_callback());
 }
 
-int32_t NetConnector::ConnectTcpAddress(const PP_Flash_NetAddress* addr,
+int32_t NetConnector::ConnectTcpAddress(const PP_NetAddress_Private* addr,
                                         PP_FileHandle* socket_out,
-                                        PP_Flash_NetAddress* local_addr_out,
-                                        PP_Flash_NetAddress* remote_addr_out,
+                                        PP_NetAddress_Private* local_addr_out,
+                                        PP_NetAddress_Private* remote_addr_out,
                                         const CompletionCallback& cc) {
   if (!has_interface<PPB_Flash_NetConnector>())
     return cc.MayForce(PP_ERROR_NOINTERFACE);
diff --git a/ppapi/cpp/private/flash_net_connector.h b/ppapi/cpp/private/flash_net_connector.h
index 56df193..b855250 100644
--- a/ppapi/cpp/private/flash_net_connector.h
+++ b/ppapi/cpp/private/flash_net_connector.h
@@ -26,13 +26,13 @@ class NetConnector : public Resource {
   int32_t ConnectTcp(const char* host,
                      uint16_t port,
                      PP_FileHandle* socket_out,
-                     PP_Flash_NetAddress* local_addr_out,
-                     PP_Flash_NetAddress* remote_addr_out,
+                     PP_NetAddress_Private* local_addr_out,
+                     PP_NetAddress_Private* remote_addr_out,
                      const CompletionCallback& cc);
-  int32_t ConnectTcpAddress(const PP_Flash_NetAddress* addr,
+  int32_t ConnectTcpAddress(const PP_NetAddress_Private* addr,
                             PP_FileHandle* socket_out,
-                            PP_Flash_NetAddress* local_addr_out,
-                            PP_Flash_NetAddress* remote_addr_out,
+                            PP_NetAddress_Private* local_addr_out,
+                            PP_NetAddress_Private* remote_addr_out,
                             const CompletionCallback& cc);
 };
 
diff --git a/ppapi/cpp/private/flash_tcp_socket.cc b/ppapi/cpp/private/flash_tcp_socket.cc
index 98e9906..0dec218 100644
--- a/ppapi/cpp/private/flash_tcp_socket.cc
+++ b/ppapi/cpp/private/flash_tcp_socket.cc
@@ -41,7 +41,7 @@ int32_t TCPSocket::Connect(const char* host,
       pp_resource(), host, port, callback.pp_completion_callback());
 }
 
-int32_t TCPSocket::ConnectWithNetAddress(const PP_Flash_NetAddress* addr,
+int32_t TCPSocket::ConnectWithNetAddress(const PP_NetAddress_Private* addr,
                                          const CompletionCallback& callback) {
   if (!has_interface<PPB_Flash_TCPSocket>())
     return callback.MayForce(PP_ERROR_NOINTERFACE);
@@ -49,7 +49,7 @@ int32_t TCPSocket::ConnectWithNetAddress(const PP_Flash_NetAddress* addr,
       pp_resource(), addr, callback.pp_completion_callback());
 }
 
-bool TCPSocket::GetLocalAddress(PP_Flash_NetAddress* local_addr) {
+bool TCPSocket::GetLocalAddress(PP_NetAddress_Private* local_addr) {
   if (!has_interface<PPB_Flash_TCPSocket>())
     return false;
 
@@ -58,7 +58,7 @@ bool TCPSocket::GetLocalAddress(PP_Flash_NetAddress* local_addr) {
   return PP_ToBool(result);
 }
 
-bool TCPSocket::GetRemoteAddress(PP_Flash_NetAddress* remote_addr) {
+bool TCPSocket::GetRemoteAddress(PP_NetAddress_Private* remote_addr) {
   if (!has_interface<PPB_Flash_TCPSocket>())
     return false;
   PP_Bool result = get_interface<PPB_Flash_TCPSocket>()->GetRemoteAddress(
diff --git a/ppapi/cpp/private/flash_tcp_socket.h b/ppapi/cpp/private/flash_tcp_socket.h
index b7ead00..41d21c0 100644
--- a/ppapi/cpp/private/flash_tcp_socket.h
+++ b/ppapi/cpp/private/flash_tcp_socket.h
@@ -27,10 +27,10 @@ class TCPSocket : public Resource {
   int32_t Connect(const char* host,
                   uint16_t port,
                   const CompletionCallback& callback);
-  int32_t ConnectWithNetAddress(const PP_Flash_NetAddress* addr,
+  int32_t ConnectWithNetAddress(const PP_NetAddress_Private* addr,
                                 const CompletionCallback& callback);
-  bool GetLocalAddress(PP_Flash_NetAddress* local_addr);
-  bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr);
+  bool GetLocalAddress(PP_NetAddress_Private* local_addr);
+  bool GetRemoteAddress(PP_NetAddress_Private* remote_addr);
   int32_t SSLHandshake(const char* server_name,
                        uint16_t server_port,
                        const CompletionCallback& callback);
diff --git a/ppapi/cpp/private/flash_udp_socket.cc b/ppapi/cpp/private/flash_udp_socket.cc
index 1ac36a3..797f3ea 100644
--- a/ppapi/cpp/private/flash_udp_socket.cc
+++ b/ppapi/cpp/private/flash_udp_socket.cc
@@ -30,7 +30,7 @@ UDPSocket::UDPSocket(Instance* instance) {
   }
 }
 
-int32_t UDPSocket::Bind(const PP_Flash_NetAddress* addr,
+int32_t UDPSocket::Bind(const PP_NetAddress_Private* addr,
                         const CompletionCallback& callback) {
   if (!has_interface<PPB_Flash_UDPSocket>())
     return PP_ERROR_NOINTERFACE;
@@ -47,7 +47,7 @@ int32_t UDPSocket::RecvFrom(char* buffer,
       pp_resource(), buffer, num_bytes, callback.pp_completion_callback());
 }
 
-bool UDPSocket::GetRecvFromAddress(PP_Flash_NetAddress* addr) {
+bool UDPSocket::GetRecvFromAddress(PP_NetAddress_Private* addr) {
   if (!has_interface<PPB_Flash_UDPSocket>())
     return false;
 
@@ -58,7 +58,7 @@ bool UDPSocket::GetRecvFromAddress(PP_Flash_NetAddress* addr) {
 
 int32_t UDPSocket::SendTo(const char* buffer,
                           int32_t num_bytes,
-                          const struct PP_Flash_NetAddress* addr,
+                          const PP_NetAddress_Private* addr,
                           const CompletionCallback& callback) {
   if (!has_interface<PPB_Flash_UDPSocket>())
     return PP_ERROR_NOINTERFACE;
diff --git a/ppapi/cpp/private/flash_udp_socket.h b/ppapi/cpp/private/flash_udp_socket.h
index e472c00..b4b223e 100644
--- a/ppapi/cpp/private/flash_udp_socket.h
+++ b/ppapi/cpp/private/flash_udp_socket.h
@@ -20,15 +20,15 @@ class UDPSocket : public Resource {
  public:
   explicit UDPSocket(Instance* instance);
 
-  int32_t Bind(const PP_Flash_NetAddress* addr,
+  int32_t Bind(const PP_NetAddress_Private* addr,
                const CompletionCallback& callback);
   int32_t RecvFrom(char* buffer,
                    int32_t num_bytes,
                    const CompletionCallback& callback);
-  bool GetRecvFromAddress(PP_Flash_NetAddress* addr);
+  bool GetRecvFromAddress(PP_NetAddress_Private* addr);
   int32_t SendTo(const char* buffer,
                  int32_t num_bytes,
-                 const PP_Flash_NetAddress* addr,
+                 const PP_NetAddress_Private* addr,
                  const CompletionCallback& callback);
   void Close();
 };
diff --git a/ppapi/cpp/private/net_address_private.cc b/ppapi/cpp/private/net_address_private.cc
new file mode 100644
index 0000000..6b844da
--- /dev/null
+++ b/ppapi/cpp/private/net_address_private.cc
@@ -0,0 +1,77 @@
+// 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 "ppapi/cpp/private/net_address_private.h"
+
+#include "ppapi/c/pp_bool.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/cpp/module_impl.h"
+#include "ppapi/cpp/var.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
+
+namespace pp {
+
+namespace {
+
+template <> const char* interface_name<PPB_NetAddress_Private>() {
+  return PPB_NETADDRESS_PRIVATE_INTERFACE;
+}
+
+}  // namespace
+
+// static
+bool NetAddress::AreEqual(const PP_NetAddress_Private& addr1,
+                          const PP_NetAddress_Private& addr2) {
+  if (!has_interface<PPB_NetAddress_Private>())
+    return false;
+  return !!get_interface<PPB_NetAddress_Private>()->AreEqual(&addr1, &addr2);
+}
+
+// static
+bool NetAddress::AreHostsEqual(const PP_NetAddress_Private& addr1,
+                               const PP_NetAddress_Private& addr2) {
+  if (!has_interface<PPB_NetAddress_Private>())
+    return false;
+  return !!get_interface<PPB_NetAddress_Private>()->AreHostsEqual(&addr1,
+                                                                  &addr2);
+}
+
+// static
+std::string NetAddress::Describe(const PP_NetAddress_Private& addr,
+                                 bool include_port) {
+  if (!has_interface<PPB_NetAddress_Private>())
+    return std::string();
+
+  Module* module = Module::Get();
+  if (!module)
+    return std::string();
+
+  Var result(Var::PassRef(),
+             get_interface<PPB_NetAddress_Private>()->Describe(
+                 module->pp_module(),
+                 &addr,
+                 PP_FromBool(include_port)));
+  return result.is_string() ? result.AsString() : std::string();
+}
+
+// static
+bool NetAddress::ReplacePort(const PP_NetAddress_Private& addr_in,
+                             uint16_t port,
+                             PP_NetAddress_Private* addr_out) {
+  if (!has_interface<PPB_NetAddress_Private>())
+    return false;
+  return !!get_interface<PPB_NetAddress_Private>()->ReplacePort(&addr_in,
+                                                                port,
+                                                                addr_out);
+}
+
+// static
+void NetAddress::GetAnyAddress(bool is_ipv6, PP_NetAddress_Private* addr) {
+  if (!has_interface<PPB_NetAddress_Private>())
+    return;
+  get_interface<PPB_NetAddress_Private>()->GetAnyAddress(PP_FromBool(is_ipv6),
+                                                         addr);
+}
+
+}  // namespace pp
diff --git a/ppapi/cpp/private/net_address_private.h b/ppapi/cpp/private/net_address_private.h
new file mode 100644
index 0000000..cc60a1b
--- /dev/null
+++ b/ppapi/cpp/private/net_address_private.h
@@ -0,0 +1,32 @@
+// 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 PPAPI_CPP_PRIVATE_NET_ADDRESS_PRIVATE_H_
+#define PPAPI_CPP_PRIVATE_NET_ADDRESS_PRIVATE_H_
+
+#include <string>
+
+#include "ppapi/c/pp_stdint.h"
+
+struct PP_NetAddress_Private;
+
+namespace pp {
+
+class NetAddress {
+ public:
+  static bool AreEqual(const PP_NetAddress_Private& addr1,
+                       const PP_NetAddress_Private& addr2);
+  static bool AreHostsEqual(const PP_NetAddress_Private& addr1,
+                            const PP_NetAddress_Private& addr2);
+  static std::string Describe(const PP_NetAddress_Private& addr,
+                              bool include_port);
+  static bool ReplacePort(const PP_NetAddress_Private& addr_in,
+                          uint16_t port,
+                          PP_NetAddress_Private* addr_out);
+  static void GetAnyAddress(bool is_ipv6, PP_NetAddress_Private* addr);
+};
+
+}  // namespace pp
+
+#endif  // PPAPI_CPP_PRIVATE_NET_ADDRESS_PRIVATE_H_
diff --git a/ppapi/ppapi_cpp.gypi b/ppapi/ppapi_cpp.gypi
index 923e890..7d18b3d 100644
--- a/ppapi/ppapi_cpp.gypi
+++ b/ppapi/ppapi_cpp.gypi
@@ -250,6 +250,8 @@
         'cpp/private/flash_fullscreen.h',
         'cpp/private/instance_private.cc',
         'cpp/private/instance_private.h',
+        'cpp/private/net_address_private.cc',
+        'cpp/private/net_address_private.h',
         'cpp/private/var_private.cc',
         'cpp/private/var_private.h',
 
diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi
index f74c886..9684560 100644
--- a/ppapi/ppapi_shared.gypi
+++ b/ppapi/ppapi_shared.gypi
@@ -63,8 +63,6 @@
         'shared_impl/ppapi_preferences.h',
         'shared_impl/ppp_instance_combined.cc',
         'shared_impl/ppp_instance_combined.h',
-        # TODO(viettrungluu): Split this out; it won't be used in NaCl.
-        'shared_impl/private/flash_net_address_impl.cc',
         'shared_impl/proxy_lock.cc',
         'shared_impl/proxy_lock.h',
         'shared_impl/resource.cc',
@@ -88,6 +86,10 @@
         'shared_impl/webkit_forwarding.cc',
         'shared_impl/webkit_forwarding.h',
 
+        # TODO(viettrungluu): Split these out; it won't be used in NaCl.
+        'shared_impl/private/net_address_private_impl.cc',
+        'shared_impl/private/net_address_private_impl.h',
+
         'thunk/common.h',
         'thunk/common.cc',
         'thunk/enter.cc',
diff --git a/ppapi/proxy/interface_list.cc b/ppapi/proxy/interface_list.cc
index 269aa6e..c1f1b9f 100644
--- a/ppapi/proxy/interface_list.cc
+++ b/ppapi/proxy/interface_list.cc
@@ -11,9 +11,9 @@
 #include "ppapi/c/dev/ppb_context_3d_dev.h"
 #include "ppapi/c/dev/ppb_crypto_dev.h"
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
-#include "ppapi/c/dev/ppb_gles_chromium_texture_mapping_dev.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
+#include "ppapi/c/dev/ppb_gles_chromium_texture_mapping_dev.h"
 #include "ppapi/c/dev/ppb_ime_input_event_dev.h"
 #include "ppapi/c/dev/ppb_memory_dev.h"
 #include "ppapi/c/dev/ppb_surface_3d_dev.h"
@@ -22,9 +22,8 @@
 #include "ppapi/c/dev/ppb_url_util_dev.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/dev/ppb_video_capture_dev.h"
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/ppb_audio_config.h"
+#include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_file_ref.h"
 #include "ppapi/c/ppb_file_system.h"
@@ -40,16 +39,17 @@
 #include "ppapi/c/ppb_url_request_info.h"
 #include "ppapi/c/ppb_url_response_info.h"
 #include "ppapi/c/ppb_var.h"
+#include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppp_instance.h"
-#include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/c/private/ppb_flash_clipboard.h"
 #include "ppapi/c/private/ppb_flash_file.h"
 #include "ppapi/c/private/ppb_flash_fullscreen.h"
+#include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/c/private/ppb_flash_menu.h"
-#include "ppapi/c/private/ppb_flash_net_address.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/trusted/ppb_broker_trusted.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
@@ -65,9 +65,9 @@
 #include "ppapi/proxy/ppb_file_system_proxy.h"
 #include "ppapi/proxy/ppb_flash_clipboard_proxy.h"
 #include "ppapi/proxy/ppb_flash_file_proxy.h"
-#include "ppapi/proxy/ppb_flash_proxy.h"
 #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"
@@ -75,7 +75,6 @@
 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
 #include "ppapi/proxy/ppb_image_data_proxy.h"
 #include "ppapi/proxy/ppb_instance_proxy.h"
-#include "ppapi/proxy/ppp_mouse_lock_proxy.h"
 #include "ppapi/proxy/ppb_pdf_proxy.h"
 #include "ppapi/proxy/ppb_surface_3d_proxy.h"
 #include "ppapi/proxy/ppb_testing_proxy.h"
@@ -92,6 +91,7 @@
 #include "ppapi/proxy/ppp_instance_private_proxy.h"
 #include "ppapi/proxy/ppp_instance_proxy.h"
 #include "ppapi/proxy/ppp_messaging_proxy.h"
+#include "ppapi/proxy/ppp_mouse_lock_proxy.h"
 #include "ppapi/proxy/ppp_video_decoder_proxy.h"
 #include "ppapi/proxy/resource_creation_proxy.h"
 #include "ppapi/shared_impl/opengles2_impl.h"
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index 11ca77a..a66b2b2 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -256,8 +256,8 @@ IPC_MESSAGE_ROUTED5(PpapiMsg_PPBFlashTCPSocket_ConnectACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
                     bool /* succeeded */,
-                    PP_Flash_NetAddress /* local_addr */,
-                    PP_Flash_NetAddress /* remote_addr */)
+                    PP_NetAddress_Private /* local_addr */,
+                    PP_NetAddress_Private /* remote_addr */)
 IPC_MESSAGE_ROUTED3(PpapiMsg_PPBFlashTCPSocket_SSLHandshakeACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
@@ -283,7 +283,7 @@ IPC_MESSAGE_ROUTED5(PpapiMsg_PPBFlashUDPSocket_RecvFromACK,
                     uint32 /* socket_id */,
                     bool /* succeeded */,
                     std::string /* data */,
-                    PP_Flash_NetAddress /* remote_addr */)
+                    PP_NetAddress_Private /* remote_addr */)
 IPC_MESSAGE_ROUTED4(PpapiMsg_PPBFlashUDPSocket_SendToACK,
                     uint32 /* plugin_dispatcher_id */,
                     uint32 /* socket_id */,
@@ -748,7 +748,7 @@ IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashTCPSocket_Connect,
                      uint16_t /* port */)
 IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress,
                      uint32 /* socket_id */,
-                     PP_Flash_NetAddress /* net_addr */)
+                     PP_NetAddress_Private /* net_addr */)
 IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashTCPSocket_SSLHandshake,
                      uint32 /* socket_id */,
                      std::string /* server_name */,
@@ -769,14 +769,14 @@ IPC_SYNC_MESSAGE_CONTROL2_1(PpapiHostMsg_PPBFlashUDPSocket_Create,
                             uint32 /* socket_id */)
 IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashUDPSocket_Bind,
                      uint32 /* socket_id */,
-                     PP_Flash_NetAddress /* net_addr */)
+                     PP_NetAddress_Private /* net_addr */)
 IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashUDPSocket_RecvFrom,
                      uint32 /* socket_id */,
                      int32_t /* num_bytes */)
 IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashUDPSocket_SendTo,
                      uint32 /* socket_id */,
                      std::string /* data */,
-                     PP_Flash_NetAddress /* net_addr */)
+                     PP_NetAddress_Private /* net_addr */)
 IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBFlashUDPSocket_Close,
                      uint32 /* socket_id */)
 
diff --git a/ppapi/proxy/ppapi_param_traits.cc b/ppapi/proxy/ppapi_param_traits.cc
index acd1fdd..ac66648 100644
--- a/ppapi/proxy/ppapi_param_traits.cc
+++ b/ppapi/proxy/ppapi_param_traits.cc
@@ -136,18 +136,19 @@ bool ParamTraits<PP_FileInfo>::Read(const Message* m, void** iter,
 void ParamTraits<PP_FileInfo>::Log(const param_type& p, std::string* l) {
 }
 
-// PP_Flash_NetAddress ---------------------------------------------------------
+// PP_NetAddress_Private -------------------------------------------------------
 
 // static
-void ParamTraits<PP_Flash_NetAddress>::Write(Message* m, const param_type& p) {
+void ParamTraits<PP_NetAddress_Private>::Write(Message* m,
+                                               const param_type& p) {
   WriteParam(m, p.size);
   m->WriteBytes(p.data, static_cast<int>(p.size));
 }
 
 // static
-bool ParamTraits<PP_Flash_NetAddress>::Read(const Message* m,
-                                            void** iter,
-                                            param_type* p) {
+bool ParamTraits<PP_NetAddress_Private>::Read(const Message* m,
+                                              void** iter,
+                                              param_type* p) {
   uint16 size;
   if (!ReadParam(m, iter, &size))
     return false;
@@ -163,9 +164,9 @@ bool ParamTraits<PP_Flash_NetAddress>::Read(const Message* m,
 }
 
 // static
-void ParamTraits<PP_Flash_NetAddress>::Log(const param_type& p,
-                                           std::string* l) {
-  l->append("<PP_Flash_NetAddress (");
+void ParamTraits<PP_NetAddress_Private>::Log(const param_type& p,
+                                             std::string* l) {
+  l->append("<PP_NetAddress_Private (");
   LogParam(p.size, l);
   l->append(" bytes)>");
 }
diff --git a/ppapi/proxy/ppapi_param_traits.h b/ppapi/proxy/ppapi_param_traits.h
index 0c2ab5b..83d2988 100644
--- a/ppapi/proxy/ppapi_param_traits.h
+++ b/ppapi/proxy/ppapi_param_traits.h
@@ -19,7 +19,7 @@
 struct PP_FileInfo;
 struct PP_ObjectProperty;
 struct PP_Flash_Menu;
-struct PP_Flash_NetAddress;
+struct PP_NetAddress_Private;
 
 namespace ppapi {
 
@@ -57,8 +57,8 @@ struct ParamTraits<PP_FileInfo> {
 };
 
 template <>
-struct PPAPI_PROXY_EXPORT ParamTraits<PP_Flash_NetAddress> {
-  typedef PP_Flash_NetAddress param_type;
+struct PPAPI_PROXY_EXPORT ParamTraits<PP_NetAddress_Private> {
+  typedef PP_NetAddress_Private param_type;
   static void Write(Message* m, const param_type& p);
   static bool Read(const Message* m, void** iter, param_type* p);
   static void Log(const param_type& p, std::string* l);
diff --git a/ppapi/proxy/ppb_flash_net_connector_proxy.cc b/ppapi/proxy/ppb_flash_net_connector_proxy.cc
index 2731cfb..50b205b 100644
--- a/ppapi/proxy/ppb_flash_net_connector_proxy.cc
+++ b/ppapi/proxy/ppb_flash_net_connector_proxy.cc
@@ -24,12 +24,12 @@ using ppapi::thunk::ResourceCreationAPI;
 namespace ppapi {
 namespace proxy {
 
-std::string NetAddressToString(const PP_Flash_NetAddress& addr) {
+std::string NetAddressToString(const PP_NetAddress_Private& addr) {
   return std::string(addr.data, std::min(static_cast<size_t>(addr.size),
                                          sizeof(addr.data)));
 }
 
-void StringToNetAddress(const std::string& str, PP_Flash_NetAddress* addr) {
+void StringToNetAddress(const std::string& str, PP_NetAddress_Private* addr) {
   addr->size = std::min(str.size(), sizeof(addr->data));
   memcpy(addr->data, str.data(), addr->size);
 }
@@ -60,13 +60,13 @@ class FlashNetConnector : public PPB_Flash_NetConnector_API,
   virtual int32_t ConnectTcp(const char* host,
                              uint16_t port,
                              PP_FileHandle* socket_out,
-                             PP_Flash_NetAddress* local_addr_out,
-                             PP_Flash_NetAddress* remote_addr_out,
+                             PP_NetAddress_Private* local_addr_out,
+                             PP_NetAddress_Private* remote_addr_out,
                              PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t ConnectTcpAddress(const PP_Flash_NetAddress* addr,
+  virtual int32_t ConnectTcpAddress(const PP_NetAddress_Private* addr,
                                     PP_FileHandle* socket_out,
-                                    PP_Flash_NetAddress* local_addr_out,
-                                    PP_Flash_NetAddress* remote_addr_out,
+                                    PP_NetAddress_Private* local_addr_out,
+                                    PP_NetAddress_Private* remote_addr_out,
                                     PP_CompletionCallback callback) OVERRIDE;
 
   void ConnectComplete(int32_t result,
@@ -79,14 +79,14 @@ class FlashNetConnector : public PPB_Flash_NetConnector_API,
   // the message is passed in (on error, it's deleted).
   int32_t ConnectWithMessage(IPC::Message* msg,
                              PP_FileHandle* socket_out,
-                             PP_Flash_NetAddress* local_addr_out,
-                             PP_Flash_NetAddress* remote_addr_out,
+                             PP_NetAddress_Private* local_addr_out,
+                             PP_NetAddress_Private* remote_addr_out,
                              PP_CompletionCallback callback);
 
   PP_CompletionCallback callback_;
   PP_FileHandle* socket_out_;
-  PP_Flash_NetAddress* local_addr_out_;
-  PP_Flash_NetAddress* remote_addr_out_;
+  PP_NetAddress_Private* local_addr_out_;
+  PP_NetAddress_Private* remote_addr_out_;
 };
 
 FlashNetConnector::FlashNetConnector(const HostResource& resource)
@@ -112,8 +112,8 @@ int32_t FlashNetConnector::ConnectTcp(
     const char* host,
     uint16_t port,
     PP_FileHandle* socket_out,
-    PP_Flash_NetAddress* local_addr_out,
-    PP_Flash_NetAddress* remote_addr_out,
+    PP_NetAddress_Private* local_addr_out,
+    PP_NetAddress_Private* remote_addr_out,
     PP_CompletionCallback callback) {
   return ConnectWithMessage(
       new PpapiHostMsg_PPBFlashNetConnector_ConnectTcp(
@@ -122,10 +122,10 @@ int32_t FlashNetConnector::ConnectTcp(
 }
 
 int32_t FlashNetConnector::ConnectTcpAddress(
-    const PP_Flash_NetAddress* addr,
+    const PP_NetAddress_Private* addr,
     PP_FileHandle* socket_out,
-    PP_Flash_NetAddress* local_addr_out,
-    PP_Flash_NetAddress* remote_addr_out,
+    PP_NetAddress_Private* local_addr_out,
+    PP_NetAddress_Private* remote_addr_out,
     PP_CompletionCallback callback) {
   return ConnectWithMessage(
       new PpapiHostMsg_PPBFlashNetConnector_ConnectTcpAddress(
@@ -154,8 +154,8 @@ void FlashNetConnector::ConnectComplete(
 int32_t FlashNetConnector::ConnectWithMessage(
     IPC::Message* msg,
     PP_FileHandle* socket_out,
-    PP_Flash_NetAddress* local_addr_out,
-    PP_Flash_NetAddress* remote_addr_out,
+    PP_NetAddress_Private* local_addr_out,
+    PP_NetAddress_Private* remote_addr_out,
     PP_CompletionCallback callback) {
   scoped_ptr<IPC::Message> msg_deletor(msg);
   if (callback_.func != NULL)
@@ -183,8 +183,8 @@ struct PPB_Flash_NetConnector_Proxy::ConnectCallbackInfo {
   HostResource resource;
 
   PP_FileHandle handle;
-  PP_Flash_NetAddress local_addr;
-  PP_Flash_NetAddress remote_addr;
+  PP_NetAddress_Private local_addr;
+  PP_NetAddress_Private remote_addr;
 };
 
 PPB_Flash_NetConnector_Proxy::PPB_Flash_NetConnector_Proxy(
@@ -263,7 +263,7 @@ void PPB_Flash_NetConnector_Proxy::OnMsgConnectTcpAddress(
   pp::CompletionCallback callback = callback_factory_.NewOptionalCallback(
       &PPB_Flash_NetConnector_Proxy::OnCompleteCallbackInHost, info);
 
-  PP_Flash_NetAddress net_address;
+  PP_NetAddress_Private net_address;
   StringToNetAddress(net_address_as_string, &net_address);
 
   EnterHostFromHostResource<PPB_Flash_NetConnector_API> enter(resource);
diff --git a/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc b/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc
index 0d5d6a5..dc1bd9a 100644
--- a/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc
+++ b/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc
@@ -65,10 +65,10 @@ class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
                           uint16_t port,
                           PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t ConnectWithNetAddress(
-      const PP_Flash_NetAddress* addr,
+      const PP_NetAddress_Private* addr,
       PP_CompletionCallback callback) OVERRIDE;
-  virtual PP_Bool GetLocalAddress(PP_Flash_NetAddress* local_addr) OVERRIDE;
-  virtual PP_Bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr) OVERRIDE;
+  virtual PP_Bool GetLocalAddress(PP_NetAddress_Private* local_addr) OVERRIDE;
+  virtual PP_Bool GetRemoteAddress(PP_NetAddress_Private* remote_addr) OVERRIDE;
   virtual int32_t SSLHandshake(const char* server_name,
                                uint16_t server_port,
                                PP_CompletionCallback callback) OVERRIDE;
@@ -82,8 +82,8 @@ class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
 
   // Notifications from the proxy.
   void OnConnectCompleted(bool succeeded,
-                          const PP_Flash_NetAddress& local_addr,
-                          const PP_Flash_NetAddress& remote_addr);
+                          const PP_NetAddress_Private& local_addr,
+                          const PP_NetAddress_Private& remote_addr);
   void OnSSLHandshakeCompleted(bool succeeded);
   void OnReadCompleted(bool succeeded, const std::string& data);
   void OnWriteCompleted(bool succeeded, int32_t bytes_written);
@@ -126,8 +126,8 @@ class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
   char* read_buffer_;
   int32_t bytes_to_read_;
 
-  PP_Flash_NetAddress local_addr_;
-  PP_Flash_NetAddress remote_addr_;
+  PP_NetAddress_Private local_addr_;
+  PP_NetAddress_Private remote_addr_;
 
   DISALLOW_COPY_AND_ASSIGN(FlashTCPSocket);
 };
@@ -175,7 +175,7 @@ int32_t FlashTCPSocket::Connect(const char* host,
 }
 
 int32_t FlashTCPSocket::ConnectWithNetAddress(
-    const PP_Flash_NetAddress* addr,
+    const PP_NetAddress_Private* addr,
     PP_CompletionCallback callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
@@ -186,7 +186,7 @@ int32_t FlashTCPSocket::ConnectWithNetAddress(
       callback);
 }
 
-PP_Bool FlashTCPSocket::GetLocalAddress(PP_Flash_NetAddress* local_addr) {
+PP_Bool FlashTCPSocket::GetLocalAddress(PP_NetAddress_Private* local_addr) {
   if (!IsConnected() || !local_addr)
     return PP_FALSE;
 
@@ -194,7 +194,7 @@ PP_Bool FlashTCPSocket::GetLocalAddress(PP_Flash_NetAddress* local_addr) {
   return PP_TRUE;
 }
 
-PP_Bool FlashTCPSocket::GetRemoteAddress(PP_Flash_NetAddress* remote_addr) {
+PP_Bool FlashTCPSocket::GetRemoteAddress(PP_NetAddress_Private* remote_addr) {
   if (!IsConnected() || !remote_addr)
     return PP_FALSE;
 
@@ -297,8 +297,8 @@ void FlashTCPSocket::Disconnect() {
 
 void FlashTCPSocket::OnConnectCompleted(
     bool succeeded,
-    const PP_Flash_NetAddress& local_addr,
-    const PP_Flash_NetAddress& remote_addr) {
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
   if (connection_state_ != BEFORE_CONNECT || !connect_callback_.func) {
     NOTREACHED();
     return;
@@ -431,8 +431,8 @@ void PPB_Flash_TCPSocket_Proxy::OnMsgConnectACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
-    const PP_Flash_NetAddress& local_addr,
-    const PP_Flash_NetAddress& remote_addr) {
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
diff --git a/ppapi/proxy/ppb_flash_tcp_socket_proxy.h b/ppapi/proxy/ppb_flash_tcp_socket_proxy.h
index 3344f2c..f20f15e 100644
--- a/ppapi/proxy/ppb_flash_tcp_socket_proxy.h
+++ b/ppapi/proxy/ppb_flash_tcp_socket_proxy.h
@@ -39,8 +39,8 @@ class PPB_Flash_TCPSocket_Proxy : public InterfaceProxy {
   void OnMsgConnectACK(uint32 plugin_dispatcher_id,
                        uint32 socket_id,
                        bool succeeded,
-                       const PP_Flash_NetAddress& local_addr,
-                       const PP_Flash_NetAddress& remote_addr);
+                       const PP_NetAddress_Private& local_addr,
+                       const PP_NetAddress_Private& remote_addr);
   void OnMsgSSLHandshakeACK(uint32 plugin_dispatcher_id,
                             uint32 socket_id,
                             bool succeeded);
diff --git a/ppapi/proxy/ppb_flash_udp_socket_proxy.cc b/ppapi/proxy/ppb_flash_udp_socket_proxy.cc
index 43a607c..8988e87 100644
--- a/ppapi/proxy/ppb_flash_udp_socket_proxy.cc
+++ b/ppapi/proxy/ppb_flash_udp_socket_proxy.cc
@@ -59,16 +59,16 @@ class FlashUDPSocket : public PPB_Flash_UDPSocket_API,
   virtual PPB_Flash_UDPSocket_API* AsPPB_Flash_UDPSocket_API() OVERRIDE;
 
   // PPB_Flash_UDPSocket_API implementation.
-  virtual int32_t Bind(const PP_Flash_NetAddress* addr,
+  virtual int32_t Bind(const PP_NetAddress_Private* addr,
                        PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t RecvFrom(char* buffer,
                            int32_t num_bytes,
                            PP_CompletionCallback callback) OVERRIDE;
-  virtual PP_Bool GetRecvFromAddress(PP_Flash_NetAddress* addr) OVERRIDE;
+  virtual PP_Bool GetRecvFromAddress(PP_NetAddress_Private* addr) OVERRIDE;
 
   virtual int32_t SendTo(const char* buffer,
                          int32_t num_bytes,
-                         const PP_Flash_NetAddress* addr,
+                         const PP_NetAddress_Private* addr,
                          PP_CompletionCallback callback) OVERRIDE;
   virtual void Close() OVERRIDE;
 
@@ -76,7 +76,7 @@ class FlashUDPSocket : public PPB_Flash_UDPSocket_API,
   void OnBindCompleted(bool succeeded);
   void OnRecvFromCompleted(bool succeeded,
                            const std::string& data,
-                           const PP_Flash_NetAddress& addr);
+                           const PP_NetAddress_Private& addr);
   void OnSendToCompleted(bool succeeded,
                          int32_t bytes_written);
 
@@ -99,7 +99,7 @@ class FlashUDPSocket : public PPB_Flash_UDPSocket_API,
   char* read_buffer_;
   int32_t bytes_to_read_;
 
-  PP_Flash_NetAddress recvfrom_addr_;
+  PP_NetAddress_Private recvfrom_addr_;
 
   DISALLOW_COPY_AND_ASSIGN(FlashUDPSocket);
 };
@@ -134,7 +134,7 @@ PPB_Flash_UDPSocket_API* FlashUDPSocket::AsPPB_Flash_UDPSocket_API() {
   return this;
 }
 
-int32_t FlashUDPSocket::Bind(const PP_Flash_NetAddress* addr,
+int32_t FlashUDPSocket::Bind(const PP_NetAddress_Private* addr,
                              PP_CompletionCallback callback) {
   if (!addr || !callback.func)
     return PP_ERROR_BADARGUMENT;
@@ -172,7 +172,7 @@ int32_t FlashUDPSocket::RecvFrom(char* buffer,
   return PP_OK_COMPLETIONPENDING;
 }
 
-PP_Bool FlashUDPSocket::GetRecvFromAddress(PP_Flash_NetAddress* addr) {
+PP_Bool FlashUDPSocket::GetRecvFromAddress(PP_NetAddress_Private* addr) {
   if (!addr)
     return PP_FALSE;
 
@@ -182,7 +182,7 @@ PP_Bool FlashUDPSocket::GetRecvFromAddress(PP_Flash_NetAddress* addr) {
 
 int32_t FlashUDPSocket::SendTo(const char* buffer,
                                int32_t num_bytes,
-                               const PP_Flash_NetAddress* addr,
+                               const PP_NetAddress_Private* addr,
                                PP_CompletionCallback callback) {
   if (!buffer || num_bytes <= 0 || !addr || !callback.func)
     return PP_ERROR_BADARGUMENT;
@@ -240,7 +240,7 @@ void FlashUDPSocket::OnBindCompleted(bool succeeded) {
 
 void FlashUDPSocket::OnRecvFromCompleted(bool succeeded,
                                          const std::string& data,
-                                         const PP_Flash_NetAddress& addr) {
+                                         const PP_NetAddress_Private& addr) {
   if (!recvfrom_callback_.func || !read_buffer_) {
     NOTREACHED();
     return;
@@ -343,7 +343,7 @@ void PPB_Flash_UDPSocket_Proxy::OnMsgRecvFromACK(
     uint32 socket_id,
     bool succeeded,
     const std::string& data,
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress_Private& addr) {
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
@@ -371,4 +371,3 @@ void PPB_Flash_UDPSocket_Proxy::OnMsgSendToACK(
 
 }  // namespace proxy
 }  // namespace ppapi
-
diff --git a/ppapi/proxy/ppb_flash_udp_socket_proxy.h b/ppapi/proxy/ppb_flash_udp_socket_proxy.h
index cea4dbf..ab5f84d 100644
--- a/ppapi/proxy/ppb_flash_udp_socket_proxy.h
+++ b/ppapi/proxy/ppb_flash_udp_socket_proxy.h
@@ -42,7 +42,7 @@ class PPB_Flash_UDPSocket_Proxy : public InterfaceProxy {
                         uint32 socket_id,
                         bool succeeded,
                         const std::string& data,
-                        const PP_Flash_NetAddress& addr);
+                        const PP_NetAddress_Private& addr);
   void OnMsgSendToACK(uint32 plugin_dispatcher_id,
                       uint32 socket_id,
                       bool succeeded,
diff --git a/ppapi/shared_impl/private/flash_net_address_impl.h b/ppapi/shared_impl/private/flash_net_address_impl.h
deleted file mode 100644
index 6c070af..0000000
--- a/ppapi/shared_impl/private/flash_net_address_impl.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// 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 PPAPI_SHARED_IMPL_PRIVATE_FLASH_NET_ADDRESS_IMPL_H_
-#define PPAPI_SHARED_IMPL_PRIVATE_FLASH_NET_ADDRESS_IMPL_H_
-
-#include "base/basictypes.h"
-#include "ppapi/shared_impl/ppapi_shared_export.h"
-
-struct PP_Flash_NetAddress;
-
-namespace ppapi {
-
-class PPAPI_SHARED_EXPORT FlashNetAddressImpl {
- public:
-  static bool ValidateNetAddress(const PP_Flash_NetAddress& addr);
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(FlashNetAddressImpl);
-};
-
-}  // namespace ppapi
-
-#endif  // PPAPI_SHARED_IMPL_PRIVATE_FLASH_NET_ADDRESS_IMPL_H_
diff --git a/ppapi/shared_impl/private/flash_net_address_impl.cc b/ppapi/shared_impl/private/net_address_private_impl.cc
index 0fd0d0fb..fe55b2c 100644
--- a/ppapi/shared_impl/private/flash_net_address_impl.cc
+++ b/ppapi/shared_impl/private/net_address_private_impl.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/shared_impl/private/flash_net_address_impl.h"
+#include "ppapi/shared_impl/private/net_address_private_impl.h"
 
 #include <string.h>
 
@@ -14,11 +14,11 @@
 #include "net/base/sys_addrinfo.h"
 #include "net/base/sys_byteorder.h"
 #include "ppapi/c/pp_var.h"
-#include "ppapi/c/private/ppb_flash_net_address.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/thunk.h"
 
-// The Flash net address interface doesn't have a normal C -> C++ thunk since it
+// The net address interface doesn't have a normal C -> C++ thunk since it
 // doesn't actually have any proxy wrapping or associated objects; it's just a
 // call into base. So we implement the entire interface here, using the thunk
 // namespace so it magically gets hooked up in the proper places.
@@ -32,14 +32,14 @@ namespace {
 typedef ADDRESS_FAMILY sa_family_t;
 #endif
 
-inline sa_family_t GetFamily(const PP_Flash_NetAddress& addr) {
+inline sa_family_t GetFamily(const PP_NetAddress_Private& addr) {
   return reinterpret_cast<const sockaddr*>(addr.data)->sa_family;
 }
 
-PP_Bool AreHostsEqual(const PP_Flash_NetAddress* addr1,
-                      const PP_Flash_NetAddress* addr2) {
-  if (!FlashNetAddressImpl::ValidateNetAddress(*addr1) ||
-      !FlashNetAddressImpl::ValidateNetAddress(*addr2))
+PP_Bool AreHostsEqual(const PP_NetAddress_Private* addr1,
+                      const PP_NetAddress_Private* addr2) {
+  if (!NetAddressPrivateImpl::ValidateNetAddress(*addr1) ||
+      !NetAddressPrivateImpl::ValidateNetAddress(*addr2))
     return PP_FALSE;
 
   if (GetFamily(*addr1) != GetFamily(*addr2))
@@ -63,8 +63,8 @@ PP_Bool AreHostsEqual(const PP_Flash_NetAddress* addr1,
   return PP_FALSE;
 }
 
-PP_Bool AreEqual(const PP_Flash_NetAddress* addr1,
-                 const PP_Flash_NetAddress* addr2) {
+PP_Bool AreEqual(const PP_NetAddress_Private* addr1,
+                 const PP_NetAddress_Private* addr2) {
   // |AreHostsEqual()| will also validate the addresses and return false if
   // either is invalid.
   if (!AreHostsEqual(addr1, addr2))
@@ -87,9 +87,9 @@ PP_Bool AreEqual(const PP_Flash_NetAddress* addr1,
 }
 
 PP_Var Describe(PP_Module module,
-                const struct PP_Flash_NetAddress* addr,
+                const struct PP_NetAddress_Private* addr,
                 PP_Bool include_port) {
-  if (!FlashNetAddressImpl::ValidateNetAddress(*addr))
+  if (!NetAddressPrivateImpl::ValidateNetAddress(*addr))
     return PP_MakeUndefined();
 
   const sockaddr* a = reinterpret_cast<const sockaddr*>(addr->data);
@@ -100,10 +100,10 @@ PP_Var Describe(PP_Module module,
   return StringVar::StringToPPVar(module, description);
 }
 
-PP_Bool ReplacePort(const struct PP_Flash_NetAddress* src_addr,
+PP_Bool ReplacePort(const struct PP_NetAddress_Private* src_addr,
                     uint16_t port,
-                    struct PP_Flash_NetAddress* dest_addr) {
-  if (!FlashNetAddressImpl::ValidateNetAddress(*src_addr))
+                    struct PP_NetAddress_Private* dest_addr) {
+  if (!NetAddressPrivateImpl::ValidateNetAddress(*src_addr))
     return PP_FALSE;
 
   if (GetFamily(*src_addr) == AF_INET) {
@@ -121,7 +121,7 @@ PP_Bool ReplacePort(const struct PP_Flash_NetAddress* src_addr,
   return PP_FALSE;
 }
 
-void GetAnyAddress(PP_Bool is_ipv6, struct PP_Flash_NetAddress* addr) {
+void GetAnyAddress(PP_Bool is_ipv6, PP_NetAddress_Private* addr) {
   memset(addr->data, 0, arraysize(addr->data) * sizeof(addr->data[0]));
   if (is_ipv6) {
     sockaddr_in6* a = reinterpret_cast<sockaddr_in6*>(addr->data);
@@ -136,7 +136,7 @@ void GetAnyAddress(PP_Bool is_ipv6, struct PP_Flash_NetAddress* addr) {
   }
 }
 
-const PPB_Flash_NetAddress flash_net_address_interface = {
+const PPB_NetAddress_Private net_address_private_interface = {
   &AreEqual,
   &AreHostsEqual,
   &Describe,
@@ -148,14 +148,16 @@ const PPB_Flash_NetAddress flash_net_address_interface = {
 
 namespace thunk {
 
-PPAPI_THUNK_EXPORT const PPB_Flash_NetAddress* GetPPB_Flash_NetAddress_Thunk() {
-  return &flash_net_address_interface;
+PPAPI_THUNK_EXPORT const PPB_NetAddress_Private*
+GetPPB_NetAddress_Private_Thunk() {
+  return &net_address_private_interface;
 }
 
 }  // namespace thunk
 
 // static
-bool FlashNetAddressImpl::ValidateNetAddress(const PP_Flash_NetAddress& addr) {
+bool NetAddressPrivateImpl::ValidateNetAddress(
+    const PP_NetAddress_Private& addr) {
   if (addr.size < sizeof(reinterpret_cast<sockaddr*>(0)->sa_family))
     return false;
 
diff --git a/ppapi/shared_impl/private/net_address_private_impl.h b/ppapi/shared_impl/private/net_address_private_impl.h
new file mode 100644
index 0000000..e5ae6fa
--- /dev/null
+++ b/ppapi/shared_impl/private/net_address_private_impl.h
@@ -0,0 +1,25 @@
+// 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 PPAPI_SHARED_IMPL_PRIVATE_NET_ADDRESS_PRIVATE_IMPL_H_
+#define PPAPI_SHARED_IMPL_PRIVATE_NET_ADDRESS_PRIVATE_IMPL_H_
+
+#include "base/basictypes.h"
+#include "ppapi/shared_impl/ppapi_shared_export.h"
+
+struct PP_NetAddress_Private;
+
+namespace ppapi {
+
+class PPAPI_SHARED_EXPORT NetAddressPrivateImpl {
+ public:
+  static bool ValidateNetAddress(const PP_NetAddress_Private& addr);
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(NetAddressPrivateImpl);
+};
+
+}  // namespace ppapi
+
+#endif  // PPAPI_SHARED_IMPL_PRIVATE_NET_ADDRESS_PRIVATE_IMPL_H_
diff --git a/ppapi/thunk/interfaces_ppb_private.h b/ppapi/thunk/interfaces_ppb_private.h
index f6d5397..6183ee4 100644
--- a/ppapi/thunk/interfaces_ppb_private.h
+++ b/ppapi/thunk/interfaces_ppb_private.h
@@ -11,7 +11,8 @@ PROXIED_API(PPB_Broker)
 
 PROXIED_IFACE(PPB_Broker, PPB_BROKER_TRUSTED_INTERFACE_0_2, PPB_BrokerTrusted)
 PROXIED_IFACE(PPB_Instance, PPB_FLASHFULLSCREEN_INTERFACE, PPB_FlashFullscreen)
-PROXIED_IFACE(NoAPIName, PPB_FLASH_NETADDRESS_INTERFACE, PPB_Flash_NetAddress)
+PROXIED_IFACE(NoAPIName, PPB_NETADDRESS_PRIVATE_INTERFACE,
+              PPB_NetAddress_Private)
 // Map the old fullscreen interface string to the Flash one, which is the same
 // at the ABI level. TODO(polina): remove this when Flash is updated.
 PROXIED_IFACE(PPB_Instance, PPB_FULLSCREEN_DEV_INTERFACE_0_4,
diff --git a/ppapi/thunk/ppb_flash_net_connector_api.h b/ppapi/thunk/ppb_flash_net_connector_api.h
index 5cc2cac..5bf0198 100644
--- a/ppapi/thunk/ppb_flash_net_connector_api.h
+++ b/ppapi/thunk/ppb_flash_net_connector_api.h
@@ -17,13 +17,13 @@ class PPB_Flash_NetConnector_API {
   virtual int32_t ConnectTcp(const char* host,
                              uint16_t port,
                              PP_FileHandle* socket_out,
-                             PP_Flash_NetAddress* local_addr_out,
-                             PP_Flash_NetAddress* remote_addr_out,
+                             PP_NetAddress_Private* local_addr_out,
+                             PP_NetAddress_Private* remote_addr_out,
                              PP_CompletionCallback callback) = 0;
-  virtual int32_t ConnectTcpAddress(const PP_Flash_NetAddress* addr,
+  virtual int32_t ConnectTcpAddress(const PP_NetAddress_Private* addr,
                                     PP_FileHandle* socket_out,
-                                    PP_Flash_NetAddress* local_addr_out,
-                                    PP_Flash_NetAddress* remote_addr_out,
+                                    PP_NetAddress_Private* local_addr_out,
+                                    PP_NetAddress_Private* remote_addr_out,
                                     PP_CompletionCallback callback) = 0;
 };
 
diff --git a/ppapi/thunk/ppb_flash_net_connector_thunk.cc b/ppapi/thunk/ppb_flash_net_connector_thunk.cc
index 14cf751..9544970 100644
--- a/ppapi/thunk/ppb_flash_net_connector_thunk.cc
+++ b/ppapi/thunk/ppb_flash_net_connector_thunk.cc
@@ -32,8 +32,8 @@ int32_t ConnectTcp(PP_Resource resource,
                    const char* host,
                    uint16_t port,
                    PP_FileHandle* socket_out,
-                   PP_Flash_NetAddress* local_addr_out,
-                   PP_Flash_NetAddress* remote_addr_out,
+                   PP_NetAddress_Private* local_addr_out,
+                   PP_NetAddress_Private* remote_addr_out,
                    PP_CompletionCallback callback) {
   EnterResource<PPB_Flash_NetConnector_API> enter(resource, true);
   if (enter.failed())
@@ -45,10 +45,10 @@ int32_t ConnectTcp(PP_Resource resource,
 }
 
 int32_t ConnectTcpAddress(PP_Resource resource,
-                          const PP_Flash_NetAddress* addr,
+                          const PP_NetAddress_Private* addr,
                           PP_FileHandle* socket_out,
-                          PP_Flash_NetAddress* local_addr_out,
-                          PP_Flash_NetAddress* remote_addr_out,
+                          PP_NetAddress_Private* local_addr_out,
+                          PP_NetAddress_Private* remote_addr_out,
                           PP_CompletionCallback callback) {
   EnterResource<PPB_Flash_NetConnector_API> enter(resource, true);
   if (enter.failed())
diff --git a/ppapi/thunk/ppb_flash_tcp_socket_api.h b/ppapi/thunk/ppb_flash_tcp_socket_api.h
index 3ded5c1..7aefcae 100644
--- a/ppapi/thunk/ppb_flash_tcp_socket_api.h
+++ b/ppapi/thunk/ppb_flash_tcp_socket_api.h
@@ -17,10 +17,10 @@ class PPB_Flash_TCPSocket_API {
   virtual int32_t Connect(const char* host,
                           uint16_t port,
                           PP_CompletionCallback callback) = 0;
-  virtual int32_t ConnectWithNetAddress(const PP_Flash_NetAddress* addr,
+  virtual int32_t ConnectWithNetAddress(const PP_NetAddress_Private* addr,
                                         PP_CompletionCallback callback) = 0;
-  virtual PP_Bool GetLocalAddress(PP_Flash_NetAddress* local_addr) = 0;
-  virtual PP_Bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr) = 0;
+  virtual PP_Bool GetLocalAddress(PP_NetAddress_Private* local_addr) = 0;
+  virtual PP_Bool GetRemoteAddress(PP_NetAddress_Private* remote_addr) = 0;
   virtual int32_t SSLHandshake(const char* server_name,
                                uint16_t server_port,
                                PP_CompletionCallback callback) = 0;
diff --git a/ppapi/thunk/ppb_flash_tcp_socket_thunk.cc b/ppapi/thunk/ppb_flash_tcp_socket_thunk.cc
index a1ce67e..de21042 100644
--- a/ppapi/thunk/ppb_flash_tcp_socket_thunk.cc
+++ b/ppapi/thunk/ppb_flash_tcp_socket_thunk.cc
@@ -40,7 +40,7 @@ int32_t Connect(PP_Resource tcp_socket,
 }
 
 int32_t ConnectWithNetAddress(PP_Resource tcp_socket,
-                              const PP_Flash_NetAddress* addr,
+                              const PP_NetAddress_Private* addr,
                               PP_CompletionCallback callback) {
   EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
   if (enter.failed())
@@ -50,7 +50,7 @@ int32_t ConnectWithNetAddress(PP_Resource tcp_socket,
 }
 
 PP_Bool GetLocalAddress(PP_Resource tcp_socket,
-                        PP_Flash_NetAddress* local_addr) {
+                        PP_NetAddress_Private* local_addr) {
   EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
   if (enter.failed())
     return PP_FALSE;
@@ -58,7 +58,7 @@ PP_Bool GetLocalAddress(PP_Resource tcp_socket,
 }
 
 PP_Bool GetRemoteAddress(PP_Resource tcp_socket,
-                         PP_Flash_NetAddress* remote_addr) {
+                         PP_NetAddress_Private* remote_addr) {
   EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
   if (enter.failed())
     return PP_FALSE;
diff --git a/ppapi/thunk/ppb_flash_udp_socket_api.h b/ppapi/thunk/ppb_flash_udp_socket_api.h
index afc7738..9a30aef 100644
--- a/ppapi/thunk/ppb_flash_udp_socket_api.h
+++ b/ppapi/thunk/ppb_flash_udp_socket_api.h
@@ -14,15 +14,15 @@ class PPB_Flash_UDPSocket_API {
  public:
   virtual ~PPB_Flash_UDPSocket_API() {}
 
-  virtual int32_t Bind(const PP_Flash_NetAddress* addr,
+  virtual int32_t Bind(const PP_NetAddress_Private* addr,
                        PP_CompletionCallback callback) = 0;
   virtual int32_t RecvFrom(char* buffer,
                            int32_t num_bytes,
                            PP_CompletionCallback callback) = 0;
-  virtual PP_Bool GetRecvFromAddress(PP_Flash_NetAddress* addr) = 0;
+  virtual PP_Bool GetRecvFromAddress(PP_NetAddress_Private* addr) = 0;
   virtual int32_t SendTo(const char* buffer,
                          int32_t num_bytes,
-                         const PP_Flash_NetAddress* addr,
+                         const PP_NetAddress_Private* addr,
                          PP_CompletionCallback callback) = 0;
   virtual void Close() = 0;
 };
diff --git a/ppapi/thunk/ppb_flash_udp_socket_thunk.cc b/ppapi/thunk/ppb_flash_udp_socket_thunk.cc
index ee2e13c..7618008 100644
--- a/ppapi/thunk/ppb_flash_udp_socket_thunk.cc
+++ b/ppapi/thunk/ppb_flash_udp_socket_thunk.cc
@@ -29,7 +29,7 @@ PP_Bool IsFlashUDPSocket(PP_Resource resource) {
 }
 
 int32_t Bind(PP_Resource udp_socket,
-             const PP_Flash_NetAddress *addr,
+             const PP_NetAddress_Private *addr,
              PP_CompletionCallback callback) {
   EnterResource<PPB_Flash_UDPSocket_API> enter(udp_socket, true);
   if (enter.failed())
@@ -52,7 +52,7 @@ int32_t RecvFrom(PP_Resource udp_socket,
 }
 
 PP_Bool GetRecvFromAddress(PP_Resource udp_socket,
-                           PP_Flash_NetAddress* addr) {
+                           PP_NetAddress_Private* addr) {
   EnterResource<PPB_Flash_UDPSocket_API> enter(udp_socket, true);
   if (enter.failed())
     return PP_FALSE;
@@ -62,7 +62,7 @@ PP_Bool GetRecvFromAddress(PP_Resource udp_socket,
 int32_t SendTo(PP_Resource udp_socket,
                const char* buffer,
                int32_t num_bytes,
-               const PP_Flash_NetAddress* addr,
+               const PP_NetAddress_Private* addr,
                PP_CompletionCallback callback) {
   EnterResource<PPB_Flash_UDPSocket_API> enter(udp_socket, true);
   if (enter.failed())
diff --git a/webkit/plugins/ppapi/mock_plugin_delegate.cc b/webkit/plugins/ppapi/mock_plugin_delegate.cc
index bc12ee4..4a914bd 100644
--- a/webkit/plugins/ppapi/mock_plugin_delegate.cc
+++ b/webkit/plugins/ppapi/mock_plugin_delegate.cc
@@ -221,7 +221,7 @@ int32_t MockPluginDelegate::ConnectTcp(
 
 int32_t MockPluginDelegate::ConnectTcpAddress(
     webkit::ppapi::PPB_Flash_NetConnector_Impl* connector,
-    const struct PP_Flash_NetAddress* addr) {
+    const PP_NetAddress_Private* addr) {
   return PP_ERROR_FAILED;
 }
 
diff --git a/webkit/plugins/ppapi/mock_plugin_delegate.h b/webkit/plugins/ppapi/mock_plugin_delegate.h
index 291cf78..0988ebe 100644
--- a/webkit/plugins/ppapi/mock_plugin_delegate.h
+++ b/webkit/plugins/ppapi/mock_plugin_delegate.h
@@ -7,6 +7,8 @@
 
 #include "webkit/plugins/ppapi/plugin_delegate.h"
 
+struct PP_NetAddress_Private;
+
 namespace webkit {
 namespace ppapi {
 
@@ -97,7 +99,7 @@ class MockPluginDelegate : public PluginDelegate {
       uint16_t port);
   virtual int32_t ConnectTcpAddress(
       webkit::ppapi::PPB_Flash_NetConnector_Impl* connector,
-      const struct PP_Flash_NetAddress* addr);
+      const PP_NetAddress_Private* addr);
   virtual int32_t ShowContextMenu(
       PluginInstance* instance,
       webkit::ppapi::PPB_Flash_Menu_Impl* menu,
diff --git a/webkit/plugins/ppapi/plugin_delegate.h b/webkit/plugins/ppapi/plugin_delegate.h
index 394bcab..a5323d0 100644
--- a/webkit/plugins/ppapi/plugin_delegate.h
+++ b/webkit/plugins/ppapi/plugin_delegate.h
@@ -29,8 +29,10 @@
 
 class AudioMessageFilter;
 class GURL;
+struct PP_NetAddress_Private;
 class SkBitmap;
 class Task;
+class TransportDIB;
 
 namespace base {
 class MessageLoopProxy;
@@ -72,10 +74,6 @@ namespace webkit_glue {
 class P2PTransport;
 }  // namespace webkit_glue
 
-struct PP_Flash_NetAddress;
-
-class TransportDIB;
-
 namespace webkit {
 namespace ppapi {
 
@@ -387,7 +385,7 @@ class PluginDelegate {
       uint16_t port) = 0;
   virtual int32_t ConnectTcpAddress(
       webkit::ppapi::PPB_Flash_NetConnector_Impl* connector,
-      const struct PP_Flash_NetAddress* addr) = 0;
+      const PP_NetAddress_Private* addr) = 0;
 
   // Show the given context menu at the given position (in the plugin's
   // coordinates).
diff --git a/webkit/plugins/ppapi/ppb_flash_net_connector_impl.cc b/webkit/plugins/ppapi/ppb_flash_net_connector_impl.cc
index 1adbf48..13999592 100644
--- a/webkit/plugins/ppapi/ppb_flash_net_connector_impl.cc
+++ b/webkit/plugins/ppapi/ppb_flash_net_connector_impl.cc
@@ -36,8 +36,8 @@ int32_t PPB_Flash_NetConnector_Impl::ConnectTcp(
     const char* host,
     uint16_t port,
     PP_FileHandle* socket_out,
-    PP_Flash_NetAddress* local_addr_out,
-    PP_Flash_NetAddress* remote_addr_out,
+    PP_NetAddress_Private* local_addr_out,
+    PP_NetAddress_Private* remote_addr_out,
     PP_CompletionCallback callback) {
   // |socket_out| is not optional.
   if (!socket_out)
@@ -69,10 +69,10 @@ int32_t PPB_Flash_NetConnector_Impl::ConnectTcp(
 }
 
 int32_t PPB_Flash_NetConnector_Impl::ConnectTcpAddress(
-    const PP_Flash_NetAddress* addr,
+    const PP_NetAddress_Private* addr,
     PP_FileHandle* socket_out,
-    PP_Flash_NetAddress* local_addr_out,
-    PP_Flash_NetAddress* remote_addr_out,
+    PP_NetAddress_Private* local_addr_out,
+    PP_NetAddress_Private* remote_addr_out,
     PP_CompletionCallback callback) {
   // |socket_out| is not optional.
   if (!socket_out)
@@ -105,8 +105,8 @@ int32_t PPB_Flash_NetConnector_Impl::ConnectTcpAddress(
 
 void PPB_Flash_NetConnector_Impl::CompleteConnectTcp(
     PP_FileHandle socket,
-    const PP_Flash_NetAddress& local_addr,
-    const PP_Flash_NetAddress& remote_addr) {
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
   int32_t rv = PP_ERROR_ABORTED;
   if (!callback_->aborted()) {
     CHECK(!callback_->completed());
diff --git a/webkit/plugins/ppapi/ppb_flash_net_connector_impl.h b/webkit/plugins/ppapi/ppb_flash_net_connector_impl.h
index b1e04df..bd2e97a 100644
--- a/webkit/plugins/ppapi/ppb_flash_net_connector_impl.h
+++ b/webkit/plugins/ppapi/ppb_flash_net_connector_impl.h
@@ -31,19 +31,19 @@ class PPB_Flash_NetConnector_Impl
   virtual int32_t ConnectTcp(const char* host,
                              uint16_t port,
                              PP_FileHandle* socket_out,
-                             PP_Flash_NetAddress* local_addr_out,
-                             PP_Flash_NetAddress* remote_addr_out,
+                             PP_NetAddress_Private* local_addr_out,
+                             PP_NetAddress_Private* remote_addr_out,
                              PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t ConnectTcpAddress(const PP_Flash_NetAddress* addr,
+  virtual int32_t ConnectTcpAddress(const PP_NetAddress_Private* addr,
                                     PP_FileHandle* socket_out,
-                                    PP_Flash_NetAddress* local_addr_out,
-                                    PP_Flash_NetAddress* remote_addr_out,
+                                    PP_NetAddress_Private* local_addr_out,
+                                    PP_NetAddress_Private* remote_addr_out,
                                     PP_CompletionCallback callback) OVERRIDE;
 
   // Called to complete |ConnectTcp()| and |ConnectTcpAddress()|.
   void CompleteConnectTcp(PP_FileHandle socket,
-                          const PP_Flash_NetAddress& local_addr,
-                          const PP_Flash_NetAddress& remote_addr);
+                          const PP_NetAddress_Private& local_addr,
+                          const PP_NetAddress_Private& remote_addr);
 
  private:
   // Any pending callback (for |ConnectTcp()| or |ConnectTcpAddress()|).
@@ -52,8 +52,8 @@ class PPB_Flash_NetConnector_Impl
   // Output buffers to be filled in when the callback is completed successfully
   // (|{local,remote}_addr_out| are optional and may be null).
   PP_FileHandle* socket_out_;
-  PP_Flash_NetAddress* local_addr_out_;
-  PP_Flash_NetAddress* remote_addr_out_;
+  PP_NetAddress_Private* local_addr_out_;
+  PP_NetAddress_Private* remote_addr_out_;
 
   DISALLOW_COPY_AND_ASSIGN(PPB_Flash_NetConnector_Impl);
 };