Remove PPAPI dependency on 'net'.

content/browser/renderer_host/pepper/pepper_udp_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_udp_socket.h"
 
 #include <string.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 32 matching lines @@
   allow_address_reuse_ = value;
 }
 
 void PepperUDPSocket::AllowBroadcast(bool value) {
   allow_broadcast_ = value;
 }
 
 void PepperUDPSocket::Bind(const PP_NetAddress_Private& addr) {
   socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
 
-  net::IPEndPoint address;
+  net::IPAddressNumber address;
+  int port;
   if (!socket_.get() ||
-      !NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address)) {
+      !NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address, &port)) {
     SendBindACKError();
     return;
   }
 
   if (allow_address_reuse_)
     socket_->AllowAddressReuse();
   if (allow_broadcast_)
     socket_->AllowBroadcast();
 
-  int result = socket_->Listen(address);
+  int result = socket_->Listen(net::IPEndPoint(address, port));
 
   if (result == net::OK &&
       socket_->GetLocalAddress(&bound_address_) != net::OK) {
     SendBindACKError();
     return;
   }
 
   OnBindCompleted(result);
 }
 
@@ skipping 13 matching lines @@
     OnRecvFromCompleted(result);
 }
 
 void PepperUDPSocket::SendTo(const std::string& data,
                              const PP_NetAddress_Private& addr) {
   if (sendto_buffer_.get() || data.empty()) {
     SendSendToACKError();
     return;
   }
 
-  net::IPEndPoint address;
-  if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address)) {
+  net::IPAddressNumber address;
+  int port;
+  if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address, &port)) {
     SendSendToACKError();
     return;
   }
 
   int data_size = data.size();
 
   sendto_buffer_ = new net::IOBuffer(data_size);
   memcpy(sendto_buffer_->data(), data.data(), data_size);
   int result = socket_->SendTo(
-      sendto_buffer_, data_size, address,
+      sendto_buffer_, data_size, net::IPEndPoint(address, port),
       base::Bind(&PepperUDPSocket::OnSendToCompleted, base::Unretained(this)));
 
   if (result != net::ERR_IO_PENDING)
     OnSendToCompleted(result);
 }
 
 void PepperUDPSocket::SendRecvFromACKError() {
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
   manager_->Send(new PpapiMsg_PPBUDPSocket_RecvFromACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, std::string(),
       addr));
 }
 
 void PepperUDPSocket::SendSendToACKError() {
   manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
 }
 
 void PepperUDPSocket::SendBindACKError() {
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
   manager_->Send(new PpapiMsg_PPBUDPSocket_BindACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, addr));
 }
 
 void PepperUDPSocket::OnBindCompleted(int result) {
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
   if (result < 0 ||
-      !NetAddressPrivateImpl::IPEndPointToNetAddress(bound_address_,
+      !NetAddressPrivateImpl::IPEndPointToNetAddress(bound_address_.address(),
+                                                     bound_address_.port(),
                                                      &addr)) {
     SendBindACKError();
   } else {
     manager_->Send(new PpapiMsg_PPBUDPSocket_BindACK(
         routing_id_, plugin_dispatcher_id_, socket_id_, true, addr));
   }
 }
 
 void PepperUDPSocket::OnRecvFromCompleted(int result) {
   DCHECK(recvfrom_buffer_.get());
 
   // Convert IPEndPoint we get back from RecvFrom to a PP_NetAddress_Private,
   // to send back.
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
   if (result < 0 ||
-      !NetAddressPrivateImpl::IPEndPointToNetAddress(recvfrom_address_,
-                                                     &addr)) {
+      !NetAddressPrivateImpl::IPEndPointToNetAddress(
+          recvfrom_address_.address(),
+          recvfrom_address_.port(),
+          &addr)) {
     SendRecvFromACKError();
   } else {
     manager_->Send(new PpapiMsg_PPBUDPSocket_RecvFromACK(
         routing_id_, plugin_dispatcher_id_, socket_id_, true,
         std::string(recvfrom_buffer_->data(), result), addr));
   }
 
   recvfrom_buffer_ = NULL;
 }
 
 void PepperUDPSocket::OnSendToCompleted(int result) {
   DCHECK(sendto_buffer_.get());
 
   if (result < 0) {
     SendSendToACKError();
   } else {
     manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
         routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
   }
 
   sendto_buffer_ = NULL;
 }