Use IPEndPoint for P2P IPC messages

chrome/renderer/p2p/ipc_socket_factory.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 "chrome/renderer/p2p/ipc_socket_factory.h"
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "chrome/renderer/p2p/socket_client.h"
 #include "chrome/renderer/p2p/socket_dispatcher.h"
 #include "third_party/libjingle/source/talk/base/asyncpacketsocket.h"
 
 namespace {
 
 const size_t kIPv4AddressSize = 4;
 
 // Chromium and libjingle represent socket addresses differently. The
 // following two functions are used to convert addresses from one
 // representation to another.
-bool ChromeToLibjingleSocketAddress(const P2PSocketAddress& address_chrome,
+bool ChromeToLibjingleSocketAddress(const net::IPEndPoint& address_chrome,
                                     talk_base::SocketAddress* address_lj) {
-  if (address_chrome.address.size() != kIPv4AddressSize) {
+  if (address_chrome.GetFamily() != AF_INET) {
     LOG(ERROR) << "Only IPv4 addresses are supported.";
     return false;
   }
   uint32 ip_as_int = ntohl(*reinterpret_cast<const uint32*>(
-      &address_chrome.address[0]));
-  *address_lj =  talk_base::SocketAddress(ip_as_int, address_chrome.port);
+      &address_chrome.address()[0]));
+  *address_lj =  talk_base::SocketAddress(ip_as_int, address_chrome.port());
   return true;
 }
 
-bool LibjingleToChromeSocketAddress(const talk_base::SocketAddress& address_lj,
-                                    P2PSocketAddress* address_chrome) {
+bool LibjingleToIPEndPoint(const talk_base::SocketAddress& address_lj,
+                           net::IPEndPoint* address_chrome) {
   uint32 ip = htonl(address_lj.ip());
-  address_chrome->address.resize(kIPv4AddressSize);
-  memcpy(&address_chrome->address[0], &ip, kIPv4AddressSize);
-  address_chrome->port = address_lj.port();
+  net::IPAddressNumber address;
+  address.resize(kIPv4AddressSize);
+  memcpy(&address[0], &ip, kIPv4AddressSize);
+  *address_chrome = net::IPEndPoint(address, address_lj.port());
   return true;
 }
 
 // IpcPacketSocket implements talk_base::AsyncPacketSocket interface
 // using P2PSocketClient that works over IPC-channel. It must be used
 // on the thread it was created.
 class IpcPacketSocket : public talk_base::AsyncPacketSocket,
                         public P2PSocketClient::Delegate {
  public:
   IpcPacketSocket();
   virtual ~IpcPacketSocket();
 
   bool Init(P2PSocketType type, P2PSocketClient* client,
             const talk_base::SocketAddress& address);
 
   // talk_base::AsyncPacketSocket interface.
   virtual talk_base::SocketAddress GetLocalAddress(bool* allocated) const;
   virtual talk_base::SocketAddress GetRemoteAddress() const;
   virtual int Send(const void *pv, size_t cb);
   virtual int SendTo(const void *pv, size_t cb,
                      const talk_base::SocketAddress& addr);
   virtual int Close();
   virtual talk_base::Socket::ConnState GetState() const;
   virtual int GetOption(talk_base::Socket::Option opt, int* value);
   virtual int SetOption(talk_base::Socket::Option opt, int value);
   virtual int GetError() const;
   virtual void SetError(int error);
 
   // P2PSocketClient::Delegate
-  virtual void OnOpen(const P2PSocketAddress& address);
+  virtual void OnOpen(const net::IPEndPoint& address);
   virtual void OnError();
-  virtual void OnDataReceived(const P2PSocketAddress& address,
+  virtual void OnDataReceived(const net::IPEndPoint& address,
                               const std::vector<char>& data);
 
  private:
   enum State {
     STATE_UNINITIALIZED,
     STATE_OPENING,
     STATE_OPEN,
     STATE_CLOSED,
     STATE_ERROR,
   };
@@ skipping 37 matching lines @@
 
 bool IpcPacketSocket::Init(P2PSocketType type, P2PSocketClient* client,
                            const talk_base::SocketAddress& address) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
   client_ = client;
   remote_address_ = address;
   state_ = STATE_OPENING;
 
-  P2PSocketAddress address_chrome;
-  if (!LibjingleToChromeSocketAddress(address, &address_chrome)) {
+  net::IPEndPoint address_chrome;
+  if (!LibjingleToIPEndPoint(address, &address_chrome)) {
     return false;
   }
 
   client_->Init(type, address_chrome, this,
                 base::MessageLoopProxy::CreateForCurrentThread());
 
   return true;
 }
 
 // talk_base::AsyncPacketSocket interface.
@@ skipping 31 matching lines @@
     case STATE_ERROR:
       return error_;
     case STATE_OPEN:
       // Continue sending the packet.
       break;
   }
 
   const char* data_char = reinterpret_cast<const char*>(data);
   std::vector<char> data_vector(data_char, data_char + data_size);
 
-  P2PSocketAddress address_chrome;
-  if (!LibjingleToChromeSocketAddress(address, &address_chrome)) {
+  net::IPEndPoint address_chrome;
+  if (!LibjingleToIPEndPoint(address, &address_chrome)) {
     // Just drop the packet if we failed to convert the address.
     return 0;
   }
 
   client_->Send(address_chrome, data_vector);
 
   // Fake successful send. The caller ignores result anyway.
   return data_size;
 }
 
@@ skipping 45 matching lines @@
 int IpcPacketSocket::GetError() const {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   return error_;
 }
 
 void IpcPacketSocket::SetError(int error) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   error_ = error;
 }
 
-void IpcPacketSocket::OnOpen(const P2PSocketAddress& address) {
+void IpcPacketSocket::OnOpen(const net::IPEndPoint& address) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (!ChromeToLibjingleSocketAddress(address, &local_address_)) {
     // Always expect correct IPv4 address to be allocated.
     NOTREACHED();
   }
   SignalAddressReady(this, local_address_);
   address_initialized_ = true;
   state_ = STATE_OPEN;
 }
 
 void IpcPacketSocket::OnError() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   state_ = STATE_ERROR;
   error_ = ECONNABORTED;
 }
 
-void IpcPacketSocket::OnDataReceived(const P2PSocketAddress& address,
+void IpcPacketSocket::OnDataReceived(const net::IPEndPoint& address,
                                      const std::vector<char>& data) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   talk_base::SocketAddress address_lj;
   if (!ChromeToLibjingleSocketAddress(address, &address_lj)) {
     // We should always be able to convert address here because we
     // don't expect IPv6 address on IPv4 connections.
     NOTREACHED();
     return;
   }
@@ skipping 37 matching lines @@
 
 talk_base::AsyncPacketSocket* IpcPacketSocketFactory::CreateClientTcpSocket(
     const talk_base::SocketAddress& local_address,
     const talk_base::SocketAddress& remote_address,
     const talk_base::ProxyInfo& proxy_info,
     const std::string& user_agent, bool ssl) {
   // TODO(sergeyu): Implement this;
   NOTIMPLEMENTED();
   return NULL;
 }