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

ppapi/proxy/ppb_flash_tcp_socket_proxy.cc

 // 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/proxy/ppb_flash_tcp_socket_proxy.h"
 
 #include <algorithm>
 #include <cstring>
 #include <map>
 
@@ skipping 47 matching lines @@
   virtual ~FlashTCPSocket();
 
   // Resource overrides.
   virtual PPB_Flash_TCPSocket_API* AsPPB_Flash_TCPSocket_API() OVERRIDE;
 
   // PPB_Flash_TCPSocket_API implementation.
   virtual int32_t Connect(const char* host,
                           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;
   virtual int32_t Read(char* buffer,
                        int32_t bytes_to_read,
                        PP_CompletionCallback callback) OVERRIDE;
   virtual int32_t Write(const char* buffer,
                         int32_t bytes_to_write,
                         PP_CompletionCallback callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
 
   // 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);
 
  private:
   enum ConnectionState {
     // Before a connection is successfully established (including a connect
     // request is pending or a previous connect request failed).
     BEFORE_CONNECT,
     // A connection has been successfully established (including a request of
@@ skipping 22 matching lines @@
   ConnectionState connection_state_;
 
   PP_CompletionCallback connect_callback_;
   PP_CompletionCallback ssl_handshake_callback_;
   PP_CompletionCallback read_callback_;
   PP_CompletionCallback write_callback_;
 
   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);
 };
 
 FlashTCPSocket::FlashTCPSocket(const HostResource& resource, uint32 socket_id)
     : Resource(resource),
       socket_id_(socket_id),
       connection_state_(BEFORE_CONNECT),
       connect_callback_(PP_BlockUntilComplete()),
       ssl_handshake_callback_(PP_BlockUntilComplete()),
@@ skipping 27 matching lines @@
                                 PP_CompletionCallback callback) {
   if (!host)
     return PP_ERROR_BADARGUMENT;
 
   return ConnectWithMessage(
       new PpapiHostMsg_PPBFlashTCPSocket_Connect(socket_id_, host, port),
       callback);
 }
 
 int32_t FlashTCPSocket::ConnectWithNetAddress(
-    const PP_Flash_NetAddress* addr,
+    const PP_NetAddress_Private* addr,
     PP_CompletionCallback callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
 
   return ConnectWithMessage(
       new PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress(
           socket_id_, *addr),
       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;
 
   *local_addr = 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;
 
   *remote_addr = remote_addr_;
   return PP_TRUE;
 }
 
 int32_t FlashTCPSocket::SSLHandshake(const char* server_name,
                                      uint16_t server_port,
                                      PP_CompletionCallback callback) {
@@ skipping 82 matching lines @@
   PostAbortAndClearIfNecessary(&connect_callback_);
   PostAbortAndClearIfNecessary(&ssl_handshake_callback_);
   PostAbortAndClearIfNecessary(&read_callback_);
   PostAbortAndClearIfNecessary(&write_callback_);
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
 }
 
 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;
   }
 
   if (succeeded) {
     local_addr_ = local_addr;
     remote_addr_ = remote_addr;
     connection_state_ = CONNECTED;
   }
@@ skipping 112 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_WriteACK, OnMsgWriteACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 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;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnConnectCompleted(succeeded, local_addr, remote_addr);
 }
 
@@ skipping 34 matching lines @@
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnWriteCompleted(succeeded, bytes_written);
 }
 
 }  // namespace proxy
 }  // namespace ppapi