Remove 'Flash' from TCP/UDP Pepper interfaces.

content/browser/renderer_host/pepper_message_filter.cc

Index: content/browser/renderer_host/pepper_message_filter.cc
diff --git a/content/browser/renderer_host/pepper_message_filter.cc b/content/browser/renderer_host/pepper_message_filter.cc
index 3a37d80d3404743b24974fa4c5a3d08357761db6..29404cc6de6fe57c293dd5debfc1deffcbeb1e1c 100644
--- a/content/browser/renderer_host/pepper_message_filter.cc
+++ b/content/browser/renderer_host/pepper_message_filter.cc
@@ -40,11 +40,9 @@
 #include "net/socket/tcp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 #include "net/url_request/url_request_context.h"
-#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 "webkit/plugins/ppapi/ppb_flash_net_connector_impl.h"
+#include "ppapi/proxy/ppb_tcp_socket_proxy.h"
+#include "ppapi/shared_impl/private/net_address_impl.h"
 
 #if defined(ENABLE_FLAPPER_HACKS)
 #include <sys/types.h>
@@ -55,10 +53,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_impl.h.
 bool SockaddrToNetAddress(const sockaddr* sa,
                           socklen_t sa_length,
-                          PP_Flash_NetAddress* net_addr) {
+                          PP_NetAddress* net_addr) {
   if (!sa || sa_length <= 0 || !net_addr)
     return false;
 
@@ -69,7 +67,7 @@ bool SockaddrToNetAddress(const sockaddr* sa,
 }
 
 bool IPEndPointToNetAddress(const net::IPEndPoint& ip,
-                            PP_Flash_NetAddress* net_addr) {
+                            PP_NetAddress* net_addr) {
   sockaddr_storage storage = { 0 };
   size_t length = sizeof(storage);
 
@@ -78,18 +76,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.
 bool AddressListToNetAddress(const net::AddressList& address_list,
-                             PP_Flash_NetAddress* net_addr) {
+                             PP_NetAddress* 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& net_addr,
                             net::IPEndPoint* ip_end_point) {
   if (!ip_end_point ||
-      !ppapi::FlashNetAddressImpl::ValidateNetAddress(net_addr))
+      !ppapi::NetAddressImpl::ValidateNetAddress(net_addr))
     return false;
 
   if (!ip_end_point->FromSockAddr(
@@ -100,7 +98,7 @@ bool NetAddressToIPEndPoint(const PP_Flash_NetAddress& net_addr,
   return true;
 }
 
-bool NetAddressToAddressList(const PP_Flash_NetAddress& net_addr,
+bool NetAddressToAddressList(const PP_NetAddress& net_addr,
                              net::AddressList* address_list) {
   if (!address_list)
     return false;
@@ -118,24 +116,24 @@ 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| 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*>(0)->data) >=
+               sizeof(sockaddr_storage), PP_NetAddress_data_too_small);
 #endif
 
-const PP_Flash_NetAddress kInvalidNetAddress = { 0 };
+const PP_NetAddress kInvalidNetAddress = { 0 };
 
-class PepperMessageFilter::FlashTCPSocket {
+class PepperMessageFilter::TCPSocket {
  public:
-  FlashTCPSocket(FlashTCPSocketManager* manager,
+  TCPSocket(TCPSocketManager* manager,
                  int32 routing_id,
                  uint32 plugin_dispatcher_id,
                  uint32 socket_id);
-  ~FlashTCPSocket();
+  ~TCPSocket();
 
   void Connect(const std::string& host, uint16_t port);
-  void ConnectWithNetAddress(const PP_Flash_NetAddress& net_addr);
+  void ConnectWithNetAddress(const PP_NetAddress& 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);
@@ -172,7 +170,7 @@ class PepperMessageFilter::FlashTCPSocket {
 
   bool IsConnected() const;
 
-  FlashTCPSocketManager* manager_;
+  TCPSocketManager* manager_;
   int32 routing_id_;
   uint32 plugin_dispatcher_id_;
   uint32 socket_id_;
@@ -180,11 +178,11 @@ class PepperMessageFilter::FlashTCPSocket {
   ConnectionState connection_state_;
   bool end_of_file_reached_;
 
-  net::OldCompletionCallbackImpl<FlashTCPSocket> resolve_callback_;
-  net::OldCompletionCallbackImpl<FlashTCPSocket> connect_callback_;
-  net::OldCompletionCallbackImpl<FlashTCPSocket> ssl_handshake_callback_;
-  net::OldCompletionCallbackImpl<FlashTCPSocket> read_callback_;
-  net::OldCompletionCallbackImpl<FlashTCPSocket> write_callback_;
+  net::OldCompletionCallbackImpl<TCPSocket> resolve_callback_;
+  net::OldCompletionCallbackImpl<TCPSocket> connect_callback_;
+  net::OldCompletionCallbackImpl<TCPSocket> ssl_handshake_callback_;
+  net::OldCompletionCallbackImpl<TCPSocket> read_callback_;
+  net::OldCompletionCallbackImpl<TCPSocket> write_callback_;
 
   scoped_ptr<net::SingleRequestHostResolver> resolver_;
   net::AddressList address_list_;
@@ -194,14 +192,14 @@ class PepperMessageFilter::FlashTCPSocket {
   scoped_refptr<net::IOBuffer> read_buffer_;
   scoped_refptr<net::IOBuffer> write_buffer_;
 
-  DISALLOW_COPY_AND_ASSIGN(FlashTCPSocket);
+  DISALLOW_COPY_AND_ASSIGN(TCPSocket);
 };
 
 // Base class for TCP and UDP socket managers.
 template<class SocketType>
-class PepperMessageFilter::FlashSocketManager {
+class PepperMessageFilter::SocketManager {
  public:
-  explicit FlashSocketManager(PepperMessageFilter* pepper_message_filter);
+  explicit SocketManager(PepperMessageFilter* pepper_message_filter);
 
  protected:
   // |socket_id| will be set to 0 on failure, non-zero otherwise.
@@ -210,13 +208,13 @@ class PepperMessageFilter::FlashSocketManager {
   uint32 next_socket_id_;
   PepperMessageFilter* pepper_message_filter_;
 
-  // SocketMap can hold either FlashTCPSocket or FlashUDPSocket.
+  // SocketMap can hold either TCPSocket or UDPSocket.
   typedef std::map<uint32, linked_ptr<SocketType> > SocketMap;
   SocketMap sockets_;
 };
 
 template<class SocketType>
-PepperMessageFilter::FlashSocketManager<SocketType>::FlashSocketManager(
+PepperMessageFilter::SocketManager<SocketType>::SocketManager(
     PepperMessageFilter* pepper_message_filter)
     : next_socket_id_(1),
       pepper_message_filter_(pepper_message_filter) {
@@ -224,14 +222,14 @@ PepperMessageFilter::FlashSocketManager<SocketType>::FlashSocketManager(
 }
 
 template<class SocketType>
-bool PepperMessageFilter::FlashSocketManager<SocketType>::GenerateSocketID(
+bool PepperMessageFilter::SocketManager<SocketType>::GenerateSocketID(
     uint32* socket_id) {
   // Generate a socket ID. For each process which sends us socket requests, IDs
   // of living sockets must be unique, to each socket type.  TCP and UDP have
   // unique managers, so the socket ID can be the same in this case.
   //
   // However, it is safe to generate IDs based on the internal state of a single
-  // FlashSocketManager object, because for each plugin or renderer process,
+  // SocketManager object, because for each plugin or renderer process,
   // there is at most one PepperMessageFilter talking to it
 
   if (sockets_.size() >= std::numeric_limits<uint32>::max()) {
@@ -249,12 +247,12 @@ bool PepperMessageFilter::FlashSocketManager<SocketType>::GenerateSocketID(
   return true;
 }
 
-// FlashTCPSocketManager manages the mapping from socket IDs to FlashTCPSocket
+// TCPSocketManager manages the mapping from socket IDs to TCPSocket
 // instances.
-class PepperMessageFilter::FlashTCPSocketManager
-    : public FlashSocketManager<FlashTCPSocket> {
+class PepperMessageFilter::TCPSocketManager
+    : public SocketManager<TCPSocket> {
  public:
-  explicit FlashTCPSocketManager(PepperMessageFilter* pepper_message_filter);
+  explicit TCPSocketManager(PepperMessageFilter* pepper_message_filter);
 
   void OnMsgCreate(int32 routing_id,
                    uint32 plugin_dispatcher_id,
@@ -263,7 +261,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& net_addr);
   void OnMsgSSLHandshake(uint32 socket_id,
                          const std::string& server_name,
                          uint16_t server_port);
@@ -271,7 +269,7 @@ class PepperMessageFilter::FlashTCPSocketManager
   void OnMsgWrite(uint32 socket_id, const std::string& data);
   void OnMsgDisconnect(uint32 socket_id);
 
-  // Used by FlashTCPSocket.
+  // Used by TCPSocket.
   bool Send(IPC::Message* message) {
     return pepper_message_filter_->Send(message);
   }
@@ -289,11 +287,11 @@ class PepperMessageFilter::FlashTCPSocketManager
   // This is lazily created. Users should use GetCertVerifier to retrieve it.
   scoped_ptr<net::CertVerifier> cert_verifier_;
 
-  DISALLOW_COPY_AND_ASSIGN(FlashTCPSocketManager);
+  DISALLOW_COPY_AND_ASSIGN(TCPSocketManager);
 };
 
-PepperMessageFilter::FlashTCPSocket::FlashTCPSocket(
-    FlashTCPSocketManager* manager,
+PepperMessageFilter::TCPSocket::TCPSocket(
+    TCPSocketManager* manager,
     int32 routing_id,
     uint32 plugin_dispatcher_id,
     uint32 socket_id)
@@ -304,26 +302,26 @@ PepperMessageFilter::FlashTCPSocket::FlashTCPSocket(
       connection_state_(BEFORE_CONNECT),
       end_of_file_reached_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          resolve_callback_(this, &FlashTCPSocket::OnResolveCompleted)),
+          resolve_callback_(this, &TCPSocket::OnResolveCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          connect_callback_(this, &FlashTCPSocket::OnConnectCompleted)),
+          connect_callback_(this, &TCPSocket::OnConnectCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           ssl_handshake_callback_(this,
-                                  &FlashTCPSocket::OnSSLHandshakeCompleted)),
+                                  &TCPSocket::OnSSLHandshakeCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &FlashTCPSocket::OnReadCompleted)),
+          read_callback_(this, &TCPSocket::OnReadCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &FlashTCPSocket::OnWriteCompleted)) {
+          write_callback_(this, &TCPSocket::OnWriteCompleted)) {
   DCHECK(manager);
 }
 
-PepperMessageFilter::FlashTCPSocket::~FlashTCPSocket() {
+PepperMessageFilter::TCPSocket::~TCPSocket() {
   // Make sure no further callbacks from socket_.
   if (socket_.get())
     socket_->Disconnect();
 }
 
-void PepperMessageFilter::FlashTCPSocket::Connect(const std::string& host,
+void PepperMessageFilter::TCPSocket::Connect(const std::string& host,
                                                   uint16_t port) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
@@ -342,8 +340,8 @@ void PepperMessageFilter::FlashTCPSocket::Connect(const std::string& host,
     OnResolveCompleted(result);
 }
 
-void PepperMessageFilter::FlashTCPSocket::ConnectWithNetAddress(
-    const PP_Flash_NetAddress& net_addr) {
+void PepperMessageFilter::TCPSocket::ConnectWithNetAddress(
+    const PP_NetAddress& net_addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (connection_state_ != BEFORE_CONNECT ||
@@ -356,7 +354,7 @@ void PepperMessageFilter::FlashTCPSocket::ConnectWithNetAddress(
   StartConnect(address_list_);
 }
 
-void PepperMessageFilter::FlashTCPSocket::SSLHandshake(
+void PepperMessageFilter::TCPSocket::SSLHandshake(
     const std::string& server_name,
     uint16_t server_port) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ -392,7 +390,7 @@ void PepperMessageFilter::FlashTCPSocket::SSLHandshake(
     OnSSLHandshakeCompleted(result);
 }
 
-void PepperMessageFilter::FlashTCPSocket::Read(int32 bytes_to_read) {
+void PepperMessageFilter::TCPSocket::Read(int32 bytes_to_read) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!IsConnected() || end_of_file_reached_ || read_buffer_.get() ||
@@ -401,9 +399,9 @@ void PepperMessageFilter::FlashTCPSocket::Read(int32 bytes_to_read) {
     return;
   }
 
-  if (bytes_to_read > ppapi::proxy::kFlashTCPSocketMaxReadSize) {
+  if (bytes_to_read > ppapi::proxy::kTCPSocketMaxReadSize) {
     NOTREACHED();
-    bytes_to_read = ppapi::proxy::kFlashTCPSocketMaxReadSize;
+    bytes_to_read = ppapi::proxy::kTCPSocketMaxReadSize;
   }
 
   read_buffer_ = new net::IOBuffer(bytes_to_read);
@@ -412,7 +410,7 @@ void PepperMessageFilter::FlashTCPSocket::Read(int32 bytes_to_read) {
     OnReadCompleted(result);
 }
 
-void PepperMessageFilter::FlashTCPSocket::Write(const std::string& data) {
+void PepperMessageFilter::TCPSocket::Write(const std::string& data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!IsConnected() || write_buffer_.get() || data.empty()) {
@@ -421,9 +419,9 @@ void PepperMessageFilter::FlashTCPSocket::Write(const std::string& data) {
   }
 
   int data_size = data.size();
-  if (data_size > ppapi::proxy::kFlashTCPSocketMaxWriteSize) {
+  if (data_size > ppapi::proxy::kTCPSocketMaxWriteSize) {
     NOTREACHED();
-    data_size = ppapi::proxy::kFlashTCPSocketMaxWriteSize;
+    data_size = ppapi::proxy::kTCPSocketMaxWriteSize;
   }
 
   write_buffer_ = new net::IOBuffer(data_size);
@@ -433,7 +431,7 @@ void PepperMessageFilter::FlashTCPSocket::Write(const std::string& data) {
     OnWriteCompleted(result);
 }
 
-void PepperMessageFilter::FlashTCPSocket::StartConnect(
+void PepperMessageFilter::TCPSocket::StartConnect(
     const net::AddressList& addresses) {
   DCHECK(connection_state_ == CONNECT_IN_PROGRESS);
 
@@ -444,28 +442,28 @@ void PepperMessageFilter::FlashTCPSocket::StartConnect(
     OnConnectCompleted(result);
 }
 
-void PepperMessageFilter::FlashTCPSocket::SendConnectACKError() {
-  manager_->Send(new PpapiMsg_PPBFlashTCPSocket_ConnectACK(
+void PepperMessageFilter::TCPSocket::SendConnectACKError() {
+  manager_->Send(new PpapiMsg_PPBTCPSocket_ConnectACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false,
       kInvalidNetAddress, kInvalidNetAddress));
 }
 
-void PepperMessageFilter::FlashTCPSocket::SendReadACKError() {
-  manager_->Send(new PpapiMsg_PPBFlashTCPSocket_ReadACK(
+void PepperMessageFilter::TCPSocket::SendReadACKError() {
+  manager_->Send(new PpapiMsg_PPBTCPSocket_ReadACK(
     routing_id_, plugin_dispatcher_id_, socket_id_, false, std::string()));
 }
 
-void PepperMessageFilter::FlashTCPSocket::SendWriteACKError() {
-  manager_->Send(new PpapiMsg_PPBFlashTCPSocket_WriteACK(
+void PepperMessageFilter::TCPSocket::SendWriteACKError() {
+  manager_->Send(new PpapiMsg_PPBTCPSocket_WriteACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
 }
 
-void PepperMessageFilter::FlashTCPSocket::SendSSLHandshakeACK(bool succeeded) {
-  manager_->Send(new PpapiMsg_PPBFlashTCPSocket_SSLHandshakeACK(
+void PepperMessageFilter::TCPSocket::SendSSLHandshakeACK(bool succeeded) {
+  manager_->Send(new PpapiMsg_PPBTCPSocket_SSLHandshakeACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, succeeded));
 }
 
-void PepperMessageFilter::FlashTCPSocket::OnResolveCompleted(int result) {
+void PepperMessageFilter::TCPSocket::OnResolveCompleted(int result) {
   DCHECK(connection_state_ == CONNECT_IN_PROGRESS);
 
   if (result != net::OK) {
@@ -477,7 +475,7 @@ void PepperMessageFilter::FlashTCPSocket::OnResolveCompleted(int result) {
   StartConnect(address_list_);
 }
 
-void PepperMessageFilter::FlashTCPSocket::OnConnectCompleted(int result) {
+void PepperMessageFilter::TCPSocket::OnConnectCompleted(int result) {
   DCHECK(connection_state_ == CONNECT_IN_PROGRESS && socket_.get());
 
   if (result != net::OK) {
@@ -486,8 +484,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 local_addr = kInvalidNetAddress;
+    PP_NetAddress remote_addr = kInvalidNetAddress;
 
     if (socket_->GetLocalAddress(&ip_end_point) != net::OK ||
         !IPEndPointToNetAddress(ip_end_point, &local_addr) ||
@@ -496,7 +494,7 @@ void PepperMessageFilter::FlashTCPSocket::OnConnectCompleted(int result) {
       SendConnectACKError();
       connection_state_ = BEFORE_CONNECT;
     } else {
-      manager_->Send(new PpapiMsg_PPBFlashTCPSocket_ConnectACK(
+      manager_->Send(new PpapiMsg_PPBTCPSocket_ConnectACK(
           routing_id_, plugin_dispatcher_id_, socket_id_, true,
           local_addr, remote_addr));
       connection_state_ = CONNECTED;
@@ -504,7 +502,7 @@ void PepperMessageFilter::FlashTCPSocket::OnConnectCompleted(int result) {
   }
 }
 
-void PepperMessageFilter::FlashTCPSocket::OnSSLHandshakeCompleted(int result) {
+void PepperMessageFilter::TCPSocket::OnSSLHandshakeCompleted(int result) {
   DCHECK(connection_state_ == SSL_HANDSHAKE_IN_PROGRESS);
 
   bool succeeded = result == net::OK;
@@ -512,16 +510,16 @@ void PepperMessageFilter::FlashTCPSocket::OnSSLHandshakeCompleted(int result) {
   connection_state_ = succeeded ? SSL_CONNECTED : SSL_HANDSHAKE_FAILED;
 }
 
-void PepperMessageFilter::FlashTCPSocket::OnReadCompleted(int result) {
+void PepperMessageFilter::TCPSocket::OnReadCompleted(int result) {
   DCHECK(read_buffer_.get());
 
   if (result > 0) {
-    manager_->Send(new PpapiMsg_PPBFlashTCPSocket_ReadACK(
+    manager_->Send(new PpapiMsg_PPBTCPSocket_ReadACK(
         routing_id_, plugin_dispatcher_id_, socket_id_, true,
         std::string(read_buffer_->data(), result)));
   } else if (result == 0) {
     end_of_file_reached_ = true;
-    manager_->Send(new PpapiMsg_PPBFlashTCPSocket_ReadACK(
+    manager_->Send(new PpapiMsg_PPBTCPSocket_ReadACK(
         routing_id_, plugin_dispatcher_id_, socket_id_, true, std::string()));
   } else {
     SendReadACKError();
@@ -529,11 +527,11 @@ void PepperMessageFilter::FlashTCPSocket::OnReadCompleted(int result) {
   read_buffer_ = NULL;
 }
 
-void PepperMessageFilter::FlashTCPSocket::OnWriteCompleted(int result) {
+void PepperMessageFilter::TCPSocket::OnWriteCompleted(int result) {
   DCHECK(write_buffer_.get());
 
   if (result >= 0) {
-    manager_->Send(new PpapiMsg_PPBFlashTCPSocket_WriteACK(
+    manager_->Send(new PpapiMsg_PPBTCPSocket_WriteACK(
         routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
   } else {
     SendWriteACKError();
@@ -541,22 +539,22 @@ void PepperMessageFilter::FlashTCPSocket::OnWriteCompleted(int result) {
   write_buffer_ = NULL;
 }
 
-bool PepperMessageFilter::FlashTCPSocket::IsConnected() const {
+bool PepperMessageFilter::TCPSocket::IsConnected() const {
   return connection_state_ == CONNECTED ||
          connection_state_ == SSL_CONNECTED;
 }
 
-class PepperMessageFilter::FlashUDPSocket {
+class PepperMessageFilter::UDPSocket {
  public:
-  FlashUDPSocket(PepperMessageFilter* pepper_message_filter,
+  UDPSocket(PepperMessageFilter* pepper_message_filter,
                  int32 routing_id,
                  uint32 plugin_dispatcher_id,
                  uint32 socket_id);
-  ~FlashUDPSocket();
+  ~UDPSocket();
 
-  void Bind(const PP_Flash_NetAddress& addr);
+  void Bind(const PP_NetAddress& 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& addr);
 
  private:
   void SendBindACK(bool result);
@@ -571,8 +569,8 @@ class PepperMessageFilter::FlashUDPSocket {
   uint32 plugin_dispatcher_id_;
   uint32 socket_id_;
 
-  net::OldCompletionCallbackImpl<FlashUDPSocket> recvfrom_callback_;
-  net::OldCompletionCallbackImpl<FlashUDPSocket> sendto_callback_;
+  net::OldCompletionCallbackImpl<UDPSocket> recvfrom_callback_;
+  net::OldCompletionCallbackImpl<UDPSocket> sendto_callback_;
 
   scoped_ptr<net::UDPServerSocket> socket_;
 
@@ -581,10 +579,10 @@ class PepperMessageFilter::FlashUDPSocket {
 
   net::IPEndPoint recvfrom_address_;
 
-  DISALLOW_COPY_AND_ASSIGN(FlashUDPSocket);
+  DISALLOW_COPY_AND_ASSIGN(UDPSocket);
 };
 
-PepperMessageFilter::FlashUDPSocket::FlashUDPSocket(
+PepperMessageFilter::UDPSocket::UDPSocket(
     PepperMessageFilter* pepper_message_filter,
     int32 routing_id,
     uint32 plugin_dispatcher_id,
@@ -594,20 +592,20 @@ PepperMessageFilter::FlashUDPSocket::FlashUDPSocket(
       plugin_dispatcher_id_(plugin_dispatcher_id),
       socket_id_(socket_id),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          recvfrom_callback_(this, &FlashUDPSocket::OnRecvFromCompleted)),
+          recvfrom_callback_(this, &UDPSocket::OnRecvFromCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          sendto_callback_(this, &FlashUDPSocket::OnSendToCompleted)) {
+          sendto_callback_(this, &UDPSocket::OnSendToCompleted)) {
   DCHECK(pepper_message_filter);
 }
 
-PepperMessageFilter::FlashUDPSocket::~FlashUDPSocket() {
+PepperMessageFilter::UDPSocket::~UDPSocket() {
   // Make sure there are no further callbacks from socket_.
   if (socket_.get())
     socket_->Close();
 }
 
-void PepperMessageFilter::FlashUDPSocket::Bind(
-    const PP_Flash_NetAddress& addr) {
+void PepperMessageFilter::UDPSocket::Bind(
+    const PP_NetAddress& addr) {
   socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
 
   net::IPEndPoint address;
@@ -621,7 +619,7 @@ void PepperMessageFilter::FlashUDPSocket::Bind(
   SendBindACK(result == net::OK);
 }
 
-void PepperMessageFilter::FlashUDPSocket::RecvFrom(int32_t num_bytes) {
+void PepperMessageFilter::UDPSocket::RecvFrom(int32_t num_bytes) {
   if (recvfrom_buffer_.get()) {
     SendRecvFromACKError();
     return;
@@ -637,9 +635,9 @@ void PepperMessageFilter::FlashUDPSocket::RecvFrom(int32_t num_bytes) {
     OnRecvFromCompleted(result);
 }
 
-void PepperMessageFilter::FlashUDPSocket::SendTo(
+void PepperMessageFilter::UDPSocket::SendTo(
     const std::string& data,
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress& addr) {
   if (sendto_buffer_.get() || data.empty()) {
     SendSendToACKError();
     return;
@@ -664,37 +662,37 @@ void PepperMessageFilter::FlashUDPSocket::SendTo(
     OnSendToCompleted(result);
 }
 
-void PepperMessageFilter::FlashUDPSocket::SendRecvFromACKError() {
-  PP_Flash_NetAddress addr = kInvalidNetAddress;
+void PepperMessageFilter::UDPSocket::SendRecvFromACKError() {
+  PP_NetAddress addr = kInvalidNetAddress;
   pepper_message_filter_->Send(
-      new PpapiMsg_PPBFlashUDPSocket_RecvFromACK(
+      new PpapiMsg_PPBUDPSocket_RecvFromACK(
           routing_id_, plugin_dispatcher_id_, socket_id_, false,
           std::string(), addr));
 }
 
-void PepperMessageFilter::FlashUDPSocket::SendSendToACKError() {
+void PepperMessageFilter::UDPSocket::SendSendToACKError() {
   pepper_message_filter_->Send(
-      new PpapiMsg_PPBFlashUDPSocket_SendToACK(
+      new PpapiMsg_PPBUDPSocket_SendToACK(
           routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
 }
 
-void PepperMessageFilter::FlashUDPSocket::SendBindACK(bool result) {
+void PepperMessageFilter::UDPSocket::SendBindACK(bool result) {
   pepper_message_filter_->Send(
-      new PpapiMsg_PPBFlashUDPSocket_BindACK(
+      new PpapiMsg_PPBUDPSocket_BindACK(
           routing_id_, plugin_dispatcher_id_, socket_id_, result));
 }
 
-void PepperMessageFilter::FlashUDPSocket::OnRecvFromCompleted(int result) {
+void PepperMessageFilter::UDPSocket::OnRecvFromCompleted(int result) {
   DCHECK(recvfrom_buffer_.get());
 
-  // Convert IPEndPoint we get back from RecvFrom to a PP_Flash_NetAddress,
-  // to send back to Flash.
-  PP_Flash_NetAddress addr = kInvalidNetAddress;
+  // Convert IPEndPoint we get back from RecvFrom to a PP_NetAddress,
+  // to send back.
+  PP_NetAddress addr = kInvalidNetAddress;
   if (!IPEndPointToNetAddress(recvfrom_address_, &addr) || result < 0) {
     SendRecvFromACKError();
   } else {
     pepper_message_filter_->Send(
-        new PpapiMsg_PPBFlashUDPSocket_RecvFromACK(
+        new PpapiMsg_PPBUDPSocket_RecvFromACK(
             routing_id_, plugin_dispatcher_id_, socket_id_, true,
             std::string(recvfrom_buffer_->data(), result), addr));
   }
@@ -702,33 +700,33 @@ void PepperMessageFilter::FlashUDPSocket::OnRecvFromCompleted(int result) {
   recvfrom_buffer_ = NULL;
 }
 
-void PepperMessageFilter::FlashUDPSocket::OnSendToCompleted(int result) {
+void PepperMessageFilter::UDPSocket::OnSendToCompleted(int result) {
   DCHECK(sendto_buffer_.get());
 
   pepper_message_filter_->Send(
-      new PpapiMsg_PPBFlashUDPSocket_SendToACK(
+      new PpapiMsg_PPBUDPSocket_SendToACK(
           routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
 
   sendto_buffer_ = NULL;
 }
 
-PepperMessageFilter::FlashTCPSocketManager::FlashTCPSocketManager(
+PepperMessageFilter::TCPSocketManager::TCPSocketManager(
     PepperMessageFilter* pepper_message_filter)
-    : FlashSocketManager<FlashTCPSocket>(pepper_message_filter) {
+    : SocketManager<TCPSocket>(pepper_message_filter) {
 }
 
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgCreate(
+void PepperMessageFilter::TCPSocketManager::OnMsgCreate(
     int32 routing_id,
     uint32 plugin_dispatcher_id,
     uint32* socket_id) {
   if (!GenerateSocketID(socket_id))
     return;
 
-  sockets_[*socket_id] = linked_ptr<FlashTCPSocket>(
-      new FlashTCPSocket(this, routing_id, plugin_dispatcher_id, *socket_id));
+  sockets_[*socket_id] = linked_ptr<TCPSocket>(
+      new TCPSocket(this, routing_id, plugin_dispatcher_id, *socket_id));
 }
 
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgConnect(
+void PepperMessageFilter::TCPSocketManager::OnMsgConnect(
     uint32 socket_id,
     const std::string& host,
     uint16_t port) {
@@ -741,9 +739,9 @@ void PepperMessageFilter::FlashTCPSocketManager::OnMsgConnect(
   iter->second->Connect(host, port);
 }
 
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgConnectWithNetAddress(
+void PepperMessageFilter::TCPSocketManager::OnMsgConnectWithNetAddress(
     uint32 socket_id,
-    const PP_Flash_NetAddress& net_addr) {
+    const PP_NetAddress& net_addr) {
   SocketMap::iterator iter = sockets_.find(socket_id);
   if (iter == sockets_.end()) {
     NOTREACHED();
@@ -753,7 +751,7 @@ void PepperMessageFilter::FlashTCPSocketManager::OnMsgConnectWithNetAddress(
   iter->second->ConnectWithNetAddress(net_addr);
 }
 
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgSSLHandshake(
+void PepperMessageFilter::TCPSocketManager::OnMsgSSLHandshake(
     uint32 socket_id,
     const std::string& server_name,
     uint16_t server_port) {
@@ -766,7 +764,7 @@ void PepperMessageFilter::FlashTCPSocketManager::OnMsgSSLHandshake(
   iter->second->SSLHandshake(server_name, server_port);
 }
 
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgRead(
+void PepperMessageFilter::TCPSocketManager::OnMsgRead(
     uint32 socket_id,
     int32_t bytes_to_read) {
   SocketMap::iterator iter = sockets_.find(socket_id);
@@ -778,7 +776,7 @@ void PepperMessageFilter::FlashTCPSocketManager::OnMsgRead(
   iter->second->Read(bytes_to_read);
 }
 
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgWrite(
+void PepperMessageFilter::TCPSocketManager::OnMsgWrite(
     uint32 socket_id,
     const std::string& data) {
   SocketMap::iterator iter = sockets_.find(socket_id);
@@ -790,7 +788,7 @@ void PepperMessageFilter::FlashTCPSocketManager::OnMsgWrite(
   iter->second->Write(data);
 }
 
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgDisconnect(
+void PepperMessageFilter::TCPSocketManager::OnMsgDisconnect(
     uint32 socket_id) {
   SocketMap::iterator iter = sockets_.find(socket_id);
   if (iter == sockets_.end()) {
@@ -798,63 +796,63 @@ void PepperMessageFilter::FlashTCPSocketManager::OnMsgDisconnect(
     return;
   }
 
-  // Destroy the FlashTCPSocket instance will cancel any pending completion
+  // Destroy the TCPSocket instance will cancel any pending completion
   // callback. From this point on, there won't be any messages associated with
   // this socket sent to the plugin side.
   sockets_.erase(iter);
 }
 
 net::CertVerifier*
-PepperMessageFilter::FlashTCPSocketManager::GetCertVerifier() {
+PepperMessageFilter::TCPSocketManager::GetCertVerifier() {
   if (!cert_verifier_.get())
     cert_verifier_.reset(new net::CertVerifier());
 
   return cert_verifier_.get();
 }
 
-// FlashUDPSocketManager manages the mapping from socket IDs to FlashUDPSocket
+// UDPSocketManager manages the mapping from socket IDs to UDPSocket
 // instances.
-class PepperMessageFilter::FlashUDPSocketManager
-    : public FlashSocketManager<FlashUDPSocket> {
+class PepperMessageFilter::UDPSocketManager
+    : public SocketManager<UDPSocket> {
  public:
-  explicit FlashUDPSocketManager(PepperMessageFilter* pepper_message_filter);
+  explicit UDPSocketManager(PepperMessageFilter* pepper_message_filter);
 
   void OnMsgCreate(int32 routing_id,
                    uint32 plugin_dispatcher_id,
                    uint32* socket_id);
   void OnMsgBind(uint32 socket_id,
-                 const PP_Flash_NetAddress& addr);
+                 const PP_NetAddress& 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& addr);
   void OnMsgClose(uint32 socket_id);
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(FlashUDPSocketManager);
+  DISALLOW_COPY_AND_ASSIGN(UDPSocketManager);
 };
 
-PepperMessageFilter::FlashUDPSocketManager::FlashUDPSocketManager(
+PepperMessageFilter::UDPSocketManager::UDPSocketManager(
     PepperMessageFilter* pepper_message_filter)
-    : FlashSocketManager<FlashUDPSocket>(pepper_message_filter) {
+    : SocketManager<UDPSocket>(pepper_message_filter) {
 }
 
-void PepperMessageFilter::FlashUDPSocketManager::OnMsgCreate(
+void PepperMessageFilter::UDPSocketManager::OnMsgCreate(
     int32 routing_id,
     uint32 plugin_dispatcher_id,
     uint32* socket_id) {
   if (!GenerateSocketID(socket_id))
     return;
 
-  sockets_[*socket_id] = linked_ptr<FlashUDPSocket>(
-      new FlashUDPSocket(pepper_message_filter_, routing_id,
+  sockets_[*socket_id] = linked_ptr<UDPSocket>(
+      new UDPSocket(pepper_message_filter_, routing_id,
                          plugin_dispatcher_id, *socket_id));
 }
 
-void PepperMessageFilter::FlashUDPSocketManager::OnMsgBind(
+void PepperMessageFilter::UDPSocketManager::OnMsgBind(
     uint32 socket_id,
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress& addr) {
   SocketMap::iterator iter = sockets_.find(socket_id);
   if (iter == sockets_.end()) {
     NOTREACHED();
@@ -864,7 +862,7 @@ void PepperMessageFilter::FlashUDPSocketManager::OnMsgBind(
   iter->second->Bind(addr);
 }
 
-void PepperMessageFilter::FlashUDPSocketManager::OnMsgRecvFrom(
+void PepperMessageFilter::UDPSocketManager::OnMsgRecvFrom(
     uint32 socket_id,
     int32_t num_bytes) {
   SocketMap::iterator iter = sockets_.find(socket_id);
@@ -876,10 +874,10 @@ void PepperMessageFilter::FlashUDPSocketManager::OnMsgRecvFrom(
   iter->second->RecvFrom(num_bytes);
 }
 
-void PepperMessageFilter::FlashUDPSocketManager::OnMsgSendTo(
+void PepperMessageFilter::UDPSocketManager::OnMsgSendTo(
     uint32 socket_id,
     const std::string& data,
-    const PP_Flash_NetAddress& addr) {
+    const PP_NetAddress& addr) {
   SocketMap::iterator iter = sockets_.find(socket_id);
   if (iter == sockets_.end()) {
     NOTREACHED();
@@ -889,7 +887,7 @@ void PepperMessageFilter::FlashUDPSocketManager::OnMsgSendTo(
   iter->second->SendTo(data, addr);
 }
 
-void PepperMessageFilter::FlashUDPSocketManager::OnMsgClose(
+void PepperMessageFilter::UDPSocketManager::OnMsgClose(
     uint32 socket_id) {
   SocketMap::iterator iter = sockets_.find(socket_id);
   if (iter == sockets_.end()) {
@@ -897,7 +895,7 @@ void PepperMessageFilter::FlashUDPSocketManager::OnMsgClose(
     return;
   }
 
-  // Destroy the FlashUDPSocket instance will cancel any pending completion
+  // Destroy the UDPSocket instance will cancel any pending completion
   // callback. From this point on, there won't be any messages associated with
   // this socket sent to the plugin side.
   sockets_.erase(iter);
@@ -908,9 +906,9 @@ PepperMessageFilter::PepperMessageFilter(
     : resource_context_(resource_context),
       host_resolver_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          socket_manager_tcp_(new FlashTCPSocketManager(this))),
+          socket_manager_tcp_(new TCPSocketManager(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          socket_manager_udp_(new FlashUDPSocketManager(this))) {
+          socket_manager_udp_(new UDPSocketManager(this))) {
   DCHECK(resource_context_);
 }
 
@@ -918,9 +916,9 @@ PepperMessageFilter::PepperMessageFilter(net::HostResolver* host_resolver)
     : resource_context_(NULL),
       host_resolver_(host_resolver),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          socket_manager_tcp_(new FlashTCPSocketManager(this))),
+          socket_manager_tcp_(new TCPSocketManager(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          socket_manager_udp_(new FlashUDPSocketManager(this))) {
+          socket_manager_udp_(new UDPSocketManager(this))) {
   DCHECK(host_resolver);
 }
 
@@ -939,45 +937,45 @@ bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg,
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PpapiHostMsg_PPBFont_GetFontFamilies,
                                     OnGetFontFamilies)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Create,
-        socket_manager_tcp_.get(), FlashTCPSocketManager::OnMsgCreate)
+        PpapiHostMsg_PPBTCPSocket_Create,
+        socket_manager_tcp_.get(), TCPSocketManager::OnMsgCreate)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Connect,
-        socket_manager_tcp_.get(), FlashTCPSocketManager::OnMsgConnect)
+        PpapiHostMsg_PPBTCPSocket_Connect,
+        socket_manager_tcp_.get(), TCPSocketManager::OnMsgConnect)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress,
+        PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress,
         socket_manager_tcp_.get(),
-        FlashTCPSocketManager::OnMsgConnectWithNetAddress)
+        TCPSocketManager::OnMsgConnectWithNetAddress)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_SSLHandshake,
+        PpapiHostMsg_PPBTCPSocket_SSLHandshake,
         socket_manager_tcp_.get(),
-        FlashTCPSocketManager::OnMsgSSLHandshake)
+        TCPSocketManager::OnMsgSSLHandshake)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Read,
-        socket_manager_tcp_.get(), FlashTCPSocketManager::OnMsgRead)
+        PpapiHostMsg_PPBTCPSocket_Read,
+        socket_manager_tcp_.get(), TCPSocketManager::OnMsgRead)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Write,
-        socket_manager_tcp_.get(), FlashTCPSocketManager::OnMsgWrite)
+        PpapiHostMsg_PPBTCPSocket_Write,
+        socket_manager_tcp_.get(), TCPSocketManager::OnMsgWrite)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Disconnect,
-        socket_manager_tcp_.get(), FlashTCPSocketManager::OnMsgDisconnect)
+        PpapiHostMsg_PPBTCPSocket_Disconnect,
+        socket_manager_tcp_.get(), TCPSocketManager::OnMsgDisconnect)
 
     // UDP
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashUDPSocket_Create,
-        socket_manager_udp_.get(), FlashUDPSocketManager::OnMsgCreate)
+        PpapiHostMsg_PPBUDPSocket_Create,
+        socket_manager_udp_.get(), UDPSocketManager::OnMsgCreate)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashUDPSocket_Bind,
-        socket_manager_udp_.get(), FlashUDPSocketManager::OnMsgBind)
+        PpapiHostMsg_PPBUDPSocket_Bind,
+        socket_manager_udp_.get(), UDPSocketManager::OnMsgBind)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashUDPSocket_RecvFrom,
-        socket_manager_udp_.get(), FlashUDPSocketManager::OnMsgRecvFrom)
+        PpapiHostMsg_PPBUDPSocket_RecvFrom,
+        socket_manager_udp_.get(), UDPSocketManager::OnMsgRecvFrom)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashUDPSocket_SendTo,
-        socket_manager_udp_.get(), FlashUDPSocketManager::OnMsgSendTo)
+        PpapiHostMsg_PPBUDPSocket_SendTo,
+        socket_manager_udp_.get(), UDPSocketManager::OnMsgSendTo)
     IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashUDPSocket_Close,
-        socket_manager_udp_.get(), FlashUDPSocketManager::OnMsgClose)
+        PpapiHostMsg_PPBUDPSocket_Close,
+        socket_manager_udp_.get(), UDPSocketManager::OnMsgClose)
 
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
@@ -988,9 +986,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& addr,
+                     PP_NetAddress* local_addr_out,
+                     PP_NetAddress* remote_addr_out) {
   *local_addr_out = kInvalidNetAddress;
   *remote_addr_out = kInvalidNetAddress;
 
@@ -1084,12 +1082,12 @@ void PepperMessageFilter::OnConnectTcp(int routing_id,
 
 void PepperMessageFilter::OnConnectTcpAddress(int routing_id,
                                               int request_id,
-                                              const PP_Flash_NetAddress& addr) {
+                                              const PP_NetAddress& 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::NetAddressImpl::ValidateNetAddress(addr) ||
       !base::WorkerPool::PostTask(FROM_HERE,
            NewRunnableMethod(
                this,
@@ -1132,9 +1130,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 local_addr = kInvalidNetAddress;
+  PP_NetAddress remote_addr = kInvalidNetAddress;
+  PP_NetAddress 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 +1157,11 @@ void PepperMessageFilter::ConnectTcpOnWorkerThread(int routing_id,
 void PepperMessageFilter::ConnectTcpAddressOnWorkerThread(
     int routing_id,
     int request_id,
-    PP_Flash_NetAddress addr) {
+    PP_NetAddress addr) {
   IPC::PlatformFileForTransit socket_for_transit =
       IPC::InvalidPlatformFileForTransit();
-  PP_Flash_NetAddress local_addr = kInvalidNetAddress;
-  PP_Flash_NetAddress remote_addr = kInvalidNetAddress;
+  PP_NetAddress local_addr = kInvalidNetAddress;
+  PP_NetAddress remote_addr = kInvalidNetAddress;
 
   int fd = ConnectTcpSocket(addr, &local_addr, &remote_addr);
   if (fd != -1)