Remove PPAPI dependency on 'net'.

content/browser/renderer_host/pepper/pepper_tcp_socket.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/pepper/pepper_tcp_socket.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 75 matching lines @@
       base::Bind(&PepperTCPSocket::OnResolveCompleted, base::Unretained(this)),
       net::BoundNetLog());
   if (result != net::ERR_IO_PENDING)
     OnResolveCompleted(result);
 }
 
 void PepperTCPSocket::ConnectWithNetAddress(
     const PP_NetAddress_Private& net_addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  net::IPAddressNumber address;
+  int port;
   if (connection_state_ != BEFORE_CONNECT ||
-      !NetAddressPrivateImpl::NetAddressToAddressList(net_addr,
-                                                      &address_list_)) {
+      !NetAddressPrivateImpl::NetAddressToIPEndPoint(net_addr,
+                                                     &address,
+                                                     &port)) {
     SendConnectACKError();
     return;
   }
 
+  // Copy the single IPEndPoint to address_list_.
+  address_list_.clear();
+  address_list_.push_back(net::IPEndPoint(address, port));
   connection_state_ = CONNECT_IN_PROGRESS;
   StartConnect(address_list_);
 }
 
 void PepperTCPSocket::SSLHandshake(
     const std::string& server_name,
     uint16_t server_port,
     const std::vector<std::vector<char> >& trusted_certs,
     const std::vector<std::vector<char> >& untrusted_certs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 203 matching lines @@
     connection_state_ = BEFORE_CONNECT;
   } else {
     net::IPEndPoint ip_end_point_local;
     net::IPEndPoint ip_end_point_remote;
     PP_NetAddress_Private local_addr =
         NetAddressPrivateImpl::kInvalidNetAddress;
     PP_NetAddress_Private remote_addr =
         NetAddressPrivateImpl::kInvalidNetAddress;
 
     if (socket_->GetLocalAddress(&ip_end_point_local) != net::OK ||
-        !NetAddressPrivateImpl::IPEndPointToNetAddress(ip_end_point_local,
-                                                       &local_addr) ||
+        !NetAddressPrivateImpl::IPEndPointToNetAddress(
+            ip_end_point_local.address(),
+            ip_end_point_local.port(),
+            &local_addr) ||
         socket_->GetPeerAddress(&ip_end_point_remote) != net::OK ||
-        !NetAddressPrivateImpl::IPEndPointToNetAddress(ip_end_point_remote,
-                                                       &remote_addr)) {
+        !NetAddressPrivateImpl::IPEndPointToNetAddress(
+            ip_end_point_remote.address(),
+            ip_end_point_remote.port(),
+            &remote_addr)) {
       SendConnectACKError();
       connection_state_ = BEFORE_CONNECT;
     } else {
       manager_->Send(new PpapiMsg_PPBTCPSocket_ConnectACK(
           routing_id_, plugin_dispatcher_id_, socket_id_, true,
           local_addr, remote_addr));
       connection_state_ = CONNECTED;
     }
   }
 }
@@ skipping 57 matching lines @@
   DCHECK(write_buffer_base_.get());
   DCHECK(write_buffer_.get());
   DCHECK_GT(write_buffer_->BytesRemaining(), 0);
 
   int result = socket_->Write(write_buffer_, write_buffer_->BytesRemaining(),
                               base::Bind(&PepperTCPSocket::OnWriteCompleted,
                                          base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnWriteCompleted(result);
 }