Migrate content/*/p2p/* code to net::IPAddress.

BUG=496258

Review URL: https://codereview.chromium.org/1833523002

Cr-Commit-Position: refs/heads/master@{#383287}

16 files changed, 80 insertions, 102 deletions

diff --git a/content/browser/renderer_host/p2p/socket_dispatcher_host.cc b/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
index 26cbb00..b1bc3c3 100644
--- a/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
+++ b/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
@@ -14,7 +14,6 @@
 #include "content/public/browser/resource_context.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
-#include "net/base/ip_address_number.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/sys_addrinfo.h"
@@ -346,14 +345,13 @@ void P2PSocketDispatcherHost::DoGetNetworkList() {
 
 void P2PSocketDispatcherHost::SendNetworkList(
     const net::NetworkInterfaceList& list,
-    const net::IPAddressNumber& default_ipv4_local_address,
-    const net::IPAddressNumber& default_ipv6_local_address) {
+    const net::IPAddress& default_ipv4_local_address,
+    const net::IPAddress& default_ipv6_local_address) {
   Send(new P2PMsg_NetworkListChanged(list, default_ipv4_local_address,
                                      default_ipv6_local_address));
 }
 
-net::IPAddressNumber P2PSocketDispatcherHost::GetDefaultLocalAddress(
-    int family) {
+net::IPAddress P2PSocketDispatcherHost::GetDefaultLocalAddress(int family) {
   DCHECK(family == AF_INET || family == AF_INET6);
 
   // Creation and connection of a UDP socket might be janky.
@@ -364,25 +362,22 @@ net::IPAddressNumber P2PSocketDispatcherHost::GetDefaultLocalAddress(
           net::DatagramSocket::DEFAULT_BIND, net::RandIntCallback(), NULL,
           net::NetLog::Source()));
 
-  net::IPAddressNumber ip_address_number;
+  net::IPAddress ip_address;
   if (family == AF_INET) {
-    ip_address_number.assign(kPublicIPv4Host,
-                             kPublicIPv4Host + net::kIPv4AddressSize);
+    ip_address = net::IPAddress(kPublicIPv4Host);
   } else {
-    ip_address_number.assign(kPublicIPv6Host,
-                             kPublicIPv6Host + net::kIPv6AddressSize);
+    ip_address = net::IPAddress(kPublicIPv6Host);
   }
 
-  if (socket->Connect(net::IPEndPoint(ip_address_number, kPublicPort)) !=
-      net::OK) {
-    return net::IPAddressNumber();
+  if (socket->Connect(net::IPEndPoint(ip_address, kPublicPort)) != net::OK) {
+    return net::IPAddress();
   }
 
   net::IPEndPoint local_address;
   if (socket->GetLocalAddress(&local_address) != net::OK)
-    return net::IPAddressNumber();
+    return net::IPAddress();
 
-  return local_address.address().bytes();
+  return local_address.address();
 }
 
 void P2PSocketDispatcherHost::OnAddressResolved(
diff --git a/content/browser/renderer_host/p2p/socket_dispatcher_host.h b/content/browser/renderer_host/p2p/socket_dispatcher_host.h
index 4615d2e..5b4ef05 100644
--- a/content/browser/renderer_host/p2p/socket_dispatcher_host.h
+++ b/content/browser/renderer_host/p2p/socket_dispatcher_host.h
@@ -94,13 +94,13 @@ class P2PSocketDispatcherHost
 
   void DoGetNetworkList();
   void SendNetworkList(const net::NetworkInterfaceList& list,
-                       const net::IPAddressNumber& default_ipv4_local_address,
-                       const net::IPAddressNumber& default_ipv6_local_address);
+                       const net::IPAddress& default_ipv4_local_address,
+                       const net::IPAddress& default_ipv6_local_address);
 
   // This connects a UDP socket to a public IP address and gets local
   // address. Since it binds to the "any" address (0.0.0.0 or ::) internally, it
   // retrieves the default local address.
-  net::IPAddressNumber GetDefaultLocalAddress(int family);
+  net::IPAddress GetDefaultLocalAddress(int family);
 
   void OnAddressResolved(DnsRequest* request,
                          const net::IPAddressList& addresses);
@@ -117,8 +117,8 @@ class P2PSocketDispatcherHost
   std::set<DnsRequest*> dns_requests_;
   P2PMessageThrottler throttler_;
 
-  net::IPAddressNumber default_ipv4_local_address_;
-  net::IPAddressNumber default_ipv6_local_address_;
+  net::IPAddress default_ipv4_local_address_;
+  net::IPAddress default_ipv6_local_address_;
 
   bool dump_incoming_rtp_packet_;
   bool dump_outgoing_rtp_packet_;
diff --git a/content/browser/renderer_host/p2p/socket_host_test_utils.cc b/content/browser/renderer_host/p2p/socket_host_test_utils.cc
index f1e20b6..81ca20d 100644
--- a/content/browser/renderer_host/p2p/socket_host_test_utils.cc
+++ b/content/browser/renderer_host/p2p/socket_host_test_utils.cc
@@ -11,6 +11,7 @@
 #include "base/thread_task_runner_handle.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
+#include "net/base/ip_address.h"
 
 const int kStunHeaderSize = 20;
 const uint16_t kStunBindingRequest = 0x0001;
@@ -213,7 +214,7 @@ void CreateStunError(std::vector<char>* packet) {
 }
 
 net::IPEndPoint ParseAddress(const std::string& ip_str, uint16_t port) {
-  net::IPAddressNumber ip;
-  EXPECT_TRUE(net::ParseIPLiteralToNumber(ip_str, &ip));
+  net::IPAddress ip;
+  EXPECT_TRUE(ip.AssignFromIPLiteral(ip_str));
   return net::IPEndPoint(ip, port);
 }
diff --git a/content/common/p2p_messages.h b/content/common/p2p_messages.h
index c0ae470..9725b25 100644
--- a/content/common/p2p_messages.h
+++ b/content/common/p2p_messages.h
@@ -63,8 +63,8 @@ IPC_STRUCT_TRAITS_END()
 
 IPC_MESSAGE_CONTROL3(P2PMsg_NetworkListChanged,
                      net::NetworkInterfaceList /* networks */,
-                     net::IPAddressNumber /* default_ipv4_local_address */,
-                     net::IPAddressNumber /* default_ipv6_local_address */)
+                     net::IPAddress /* default_ipv4_local_address */,
+                     net::IPAddress /* default_ipv6_local_address */)
 
 IPC_MESSAGE_CONTROL2(P2PMsg_GetHostAddressResult,
                      int32_t /* request_id */,
diff --git a/content/renderer/p2p/ipc_network_manager.cc b/content/renderer/p2p/ipc_network_manager.cc
index 4850d55..326d646 100644
--- a/content/renderer/p2p/ipc_network_manager.cc
+++ b/content/renderer/p2p/ipc_network_manager.cc
@@ -14,7 +14,7 @@
 #include "base/thread_task_runner_handle.h"
 #include "content/public/common/content_switches.h"
 #include "jingle/glue/utils.h"
-#include "net/base/ip_address_number.h"
+#include "net/base/ip_address.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/network_interfaces.h"
 #include "third_party/webrtc/base/socketaddress.h"
@@ -73,8 +73,8 @@ void IpcNetworkManager::StopUpdating() {
 
 void IpcNetworkManager::OnNetworkListChanged(
     const net::NetworkInterfaceList& list,
-    const net::IPAddressNumber& default_ipv4_local_address,
-    const net::IPAddressNumber& default_ipv6_local_address) {
+    const net::IPAddress& default_ipv4_local_address,
+    const net::IPAddress& default_ipv6_local_address) {
   // Update flag if network list received for the first time.
   if (!network_list_received_)
     network_list_received_ = true;
@@ -90,7 +90,7 @@ void IpcNetworkManager::OnNetworkListChanged(
   for (net::NetworkInterfaceList::const_iterator it = list.begin();
        it != list.end(); it++) {
     rtc::IPAddress ip_address =
-        jingle_glue::IPAddressNumberToIPAddress(it->address.bytes());
+        jingle_glue::NetIPAddressToRtcIPAddress(it->address);
     DCHECK(!ip_address.IsNil());
 
     rtc::IPAddress prefix = rtc::TruncateIP(ip_address, it->prefix_length);
@@ -101,8 +101,7 @@ void IpcNetworkManager::OnNetworkListChanged(
 
     rtc::InterfaceAddress iface_addr;
     if (it->address.IsIPv4()) {
-      use_default_ipv4_address |=
-          (default_ipv4_local_address == it->address.bytes());
+      use_default_ipv4_address |= (default_ipv4_local_address == it->address);
       iface_addr = rtc::InterfaceAddress(ip_address);
     } else {
       DCHECK(it->address.IsIPv6());
@@ -116,8 +115,7 @@ void IpcNetworkManager::OnNetworkListChanged(
         continue;
       }
 
-      use_default_ipv6_address |=
-          (default_ipv6_local_address == it->address.bytes());
+      use_default_ipv6_address |= (default_ipv6_local_address == it->address);
     }
     network->AddIP(iface_addr);
     networks.push_back(network.release());
@@ -128,11 +126,11 @@ void IpcNetworkManager::OnNetworkListChanged(
   rtc::IPAddress ipv6_defualt;
   if (use_default_ipv4_address) {
     ipv4_default =
-        jingle_glue::IPAddressNumberToIPAddress(default_ipv4_local_address);
+        jingle_glue::NetIPAddressToRtcIPAddress(default_ipv4_local_address);
   }
   if (use_default_ipv6_address) {
     ipv6_defualt =
-        jingle_glue::IPAddressNumberToIPAddress(default_ipv6_local_address);
+        jingle_glue::NetIPAddressToRtcIPAddress(default_ipv6_local_address);
   }
   set_default_local_addresses(ipv4_default, ipv6_defualt);
 
diff --git a/content/renderer/p2p/ipc_network_manager.h b/content/renderer/p2p/ipc_network_manager.h
index 40e631a..c2ee02b 100644
--- a/content/renderer/p2p/ipc_network_manager.h
+++ b/content/renderer/p2p/ipc_network_manager.h
@@ -14,6 +14,10 @@
 #include "content/renderer/p2p/network_list_observer.h"
 #include "third_party/webrtc/base/network.h"
 
+namespace net {
+class IPAddress;
+}
+
 namespace content {
 
 // IpcNetworkManager is a NetworkManager for libjingle that gets a
@@ -32,8 +36,8 @@ class IpcNetworkManager : public rtc::NetworkManagerBase,
   // P2PSocketDispatcher::NetworkListObserver interface.
   void OnNetworkListChanged(
       const net::NetworkInterfaceList& list,
-      const net::IPAddressNumber& default_ipv4_local_address,
-      const net::IPAddressNumber& default_ipv6_local_address) override;
+      const net::IPAddress& default_ipv4_local_address,
+      const net::IPAddress& default_ipv6_local_address) override;
 
  private:
   void SendNetworksChangedSignal();
diff --git a/content/renderer/p2p/ipc_network_manager_unittest.cc b/content/renderer/p2p/ipc_network_manager_unittest.cc
index 31fcd47..fb87c9e 100644
--- a/content/renderer/p2p/ipc_network_manager_unittest.cc
+++ b/content/renderer/p2p/ipc_network_manager_unittest.cc
@@ -5,7 +5,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/network_list_manager.h"
-#include "net/base/ip_address_number.h"
+#include "net/base/ip_address.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/network_interfaces.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -53,33 +53,23 @@ class IpcNetworkManagerTest : public testing::Test {
 // issue 19249005 integrated into chromium
 TEST_F(IpcNetworkManagerTest, TestMergeNetworkList) {
   net::NetworkInterfaceList list;
-  net::IPAddressNumber ip_number;
+  net::IPAddress ip;
   std::vector<rtc::Network*> networks;
   rtc::IPAddress ip_address;
 
   // Add 2 networks with the same prefix and prefix length.
-  EXPECT_TRUE(net::ParseIPLiteralToNumber(kIPv6PublicAddrString1, &ip_number));
-  list.push_back(
-      net::NetworkInterface("em1",
-                            "em1",
-                            0,
-                            net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
-                            ip_number,
-                            64,
-                            net::IP_ADDRESS_ATTRIBUTE_NONE));
-
-  EXPECT_TRUE(net::ParseIPLiteralToNumber(kIPv6PublicAddrString2, &ip_number));
-  list.push_back(
-      net::NetworkInterface("em1",
-                            "em1",
-                            0,
-                            net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
-                            ip_number,
-                            64,
-                            net::IP_ADDRESS_ATTRIBUTE_NONE));
-
-  network_manager_->OnNetworkListChanged(list, net::IPAddressNumber(),
-                                         net::IPAddressNumber());
+  EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv6PublicAddrString1));
+  list.push_back(net::NetworkInterface(
+      "em1", "em1", 0, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, ip, 64,
+      net::IP_ADDRESS_ATTRIBUTE_NONE));
+
+  EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv6PublicAddrString2));
+  list.push_back(net::NetworkInterface(
+      "em1", "em1", 0, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, ip, 64,
+      net::IP_ADDRESS_ATTRIBUTE_NONE));
+
+  network_manager_->OnNetworkListChanged(list, net::IPAddress(),
+                                         net::IPAddress());
   network_manager_->GetNetworks(&networks);
   EXPECT_EQ(1uL, networks.size());
   EXPECT_EQ(2uL, networks[0]->GetIPs().size());
@@ -87,19 +77,13 @@ TEST_F(IpcNetworkManagerTest, TestMergeNetworkList) {
   // Add another network with different prefix length, should result in
   // a different network.
   networks.clear();
-  list.push_back(
-      net::NetworkInterface("em1",
-                            "em1",
-                            0,
-                            net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
-                            ip_number,
-                            48,
-                            net::IP_ADDRESS_ATTRIBUTE_NONE));
+  list.push_back(net::NetworkInterface(
+      "em1", "em1", 0, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, ip, 48,
+      net::IP_ADDRESS_ATTRIBUTE_NONE));
 
   // Push an unknown address as the default address.
-  EXPECT_TRUE(net::ParseIPLiteralToNumber(kIPv4MappedAddrString, &ip_number));
-  network_manager_->OnNetworkListChanged(list, net::IPAddressNumber(),
-                                         ip_number);
+  EXPECT_TRUE(ip.AssignFromIPLiteral(kIPv4MappedAddrString));
+  network_manager_->OnNetworkListChanged(list, net::IPAddress(), ip);
 
   // The unknown default address should be ignored.
   EXPECT_FALSE(network_manager_->GetDefaultLocalAddress(AF_INET6, &ip_address));
diff --git a/content/renderer/p2p/ipc_socket_factory.cc b/content/renderer/p2p/ipc_socket_factory.cc
index 724b1ed..20fa056 100644
--- a/content/renderer/p2p/ipc_socket_factory.cc
+++ b/content/renderer/p2p/ipc_socket_factory.cc
@@ -318,7 +318,7 @@ bool IpcPacketSocket::Init(P2PSocketType type,
 
     if (remote_address.IsUnresolvedIP()) {
       remote_endpoint =
-          net::IPEndPoint(net::IPAddressNumber(), remote_address.port());
+          net::IPEndPoint(net::IPAddress(), remote_address.port());
     } else {
       if (!jingle_glue::SocketAddressToIPEndPoint(remote_address,
                                                   &remote_endpoint)) {
@@ -421,7 +421,7 @@ int IpcPacketSocket::SendTo(const void *data, size_t data_size,
 
   net::IPEndPoint address_chrome;
   if (address.IsUnresolvedIP()) {
-    address_chrome = net::IPEndPoint(net::IPAddressNumber(), address.port());
+    address_chrome = net::IPEndPoint(net::IPAddress(), address.port());
   } else {
     if (!jingle_glue::SocketAddressToIPEndPoint(address, &address_chrome)) {
       LOG(WARNING) << "Failed to convert remote address to IPEndPoint: address="
diff --git a/content/renderer/p2p/network_list_observer.h b/content/renderer/p2p/network_list_observer.h
index c0fcc59..309f0ce 100644
--- a/content/renderer/p2p/network_list_observer.h
+++ b/content/renderer/p2p/network_list_observer.h
@@ -7,9 +7,8 @@
 
 #include <vector>
 
-#include "net/base/ip_address_number.h"
-
 namespace net {
+class IPAddress;
 struct NetworkInterface;
 typedef std::vector<NetworkInterface> NetworkInterfaceList;
 }  // namespace net
@@ -22,8 +21,8 @@ class NetworkListObserver {
 
   virtual void OnNetworkListChanged(
       const net::NetworkInterfaceList& list,
-      const net::IPAddressNumber& default_ipv4_local_address,
-      const net::IPAddressNumber& default_ipv6_local_address) = 0;
+      const net::IPAddress& default_ipv4_local_address,
+      const net::IPAddress& default_ipv6_local_address) = 0;
 
  protected:
   NetworkListObserver() {}
diff --git a/content/renderer/p2p/socket_dispatcher.cc b/content/renderer/p2p/socket_dispatcher.cc
index fce70e2..c8e0779 100644
--- a/content/renderer/p2p/socket_dispatcher.cc
+++ b/content/renderer/p2p/socket_dispatcher.cc
@@ -125,8 +125,8 @@ void P2PSocketDispatcher::UnregisterHostAddressRequest(int id) {
 
 void P2PSocketDispatcher::OnNetworkListChanged(
     const net::NetworkInterfaceList& networks,
-    const net::IPAddressNumber& default_ipv4_local_address,
-    const net::IPAddressNumber& default_ipv6_local_address) {
+    const net::IPAddress& default_ipv4_local_address,
+    const net::IPAddress& default_ipv6_local_address) {
   network_list_observers_->Notify(
       FROM_HERE, &NetworkListObserver::OnNetworkListChanged, networks,
       default_ipv4_local_address, default_ipv6_local_address);
diff --git a/content/renderer/p2p/socket_dispatcher.h b/content/renderer/p2p/socket_dispatcher.h
index 3a80f2a..0b23dd0 100644
--- a/content/renderer/p2p/socket_dispatcher.h
+++ b/content/renderer/p2p/socket_dispatcher.h
@@ -36,8 +36,6 @@
 #include "content/renderer/p2p/network_list_manager.h"
 #include "ipc/message_filter.h"
 #include "net/base/ip_address.h"
-#include "net/base/ip_address_number.h"
-#include "net/base/ip_endpoint.h"
 #include "net/base/network_interfaces.h"
 
 namespace base {
@@ -97,10 +95,9 @@ class CONTENT_EXPORT P2PSocketDispatcher : public IPC::MessageFilter,
   void UnregisterHostAddressRequest(int id);
 
   // Incoming message handlers.
-  void OnNetworkListChanged(
-      const net::NetworkInterfaceList& networks,
-      const net::IPAddressNumber& default_ipv4_local_address,
-      const net::IPAddressNumber& default_ipv6_local_address);
+  void OnNetworkListChanged(const net::NetworkInterfaceList& networks,
+                            const net::IPAddress& default_ipv4_local_address,
+                            const net::IPAddress& default_ipv6_local_address);
   void OnGetHostAddressResult(int32_t request_id,
                               const net::IPAddressList& addresses);
   void OnSocketCreated(int socket_id,
diff --git a/jingle/glue/chrome_async_socket_unittest.cc b/jingle/glue/chrome_async_socket_unittest.cc
index 0a9fd31..d4c774d 100644
--- a/jingle/glue/chrome_async_socket_unittest.cc
+++ b/jingle/glue/chrome_async_socket_unittest.cc
@@ -16,6 +16,7 @@
 #include "base/message_loop/message_pump_default.h"
 #include "jingle/glue/resolving_client_socket_factory.h"
 #include "net/base/address_list.h"
+#include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/http/transport_security_state.h"
@@ -174,10 +175,8 @@ class ChromeAsyncSocketTest
         &ssl_socket_data_provider_);
 
     // Fake DNS resolution for |addr_| and pass it to the factory.
-    net::IPAddressNumber resolved_addr;
-    EXPECT_TRUE(net::ParseIPLiteralToNumber("127.0.0.1", &resolved_addr));
-    const net::AddressList address_list =
-        net::AddressList::CreateFromIPAddress(resolved_addr, addr_.port());
+    const net::AddressList address_list = net::AddressList::CreateFromIPAddress(
+        net::IPAddress::IPv4Localhost(), addr_.port());
     scoped_ptr<MockXmppClientSocketFactory> mock_xmpp_client_socket_factory(
         new MockXmppClientSocketFactory(
             mock_client_socket_factory.release(),
diff --git a/jingle/glue/fake_ssl_client_socket_unittest.cc b/jingle/glue/fake_ssl_client_socket_unittest.cc
index 50f7457..aa1cfb3 100644
--- a/jingle/glue/fake_ssl_client_socket_unittest.cc
+++ b/jingle/glue/fake_ssl_client_socket_unittest.cc
@@ -15,6 +15,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/io_buffer.h"
+#include "net/base/ip_address.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log.h"
 #include "net/socket/socket_test_util.h"
@@ -279,7 +280,7 @@ TEST_F(FakeSSLClientSocketTest, PassThroughMethods) {
   scoped_ptr<MockClientSocket> mock_client_socket(new MockClientSocket());
   const int kReceiveBufferSize = 10;
   const int kSendBufferSize = 20;
-  net::IPEndPoint ip_endpoint(net::IPAddressNumber(net::kIPv4AddressSize), 80);
+  net::IPEndPoint ip_endpoint(net::IPAddress::IPv4AllZeros(), 80);
   const int kPeerAddress = 30;
   net::BoundNetLog net_log;
   EXPECT_CALL(*mock_client_socket, SetReceiveBufferSize(kReceiveBufferSize));
diff --git a/jingle/glue/proxy_resolving_client_socket.cc b/jingle/glue/proxy_resolving_client_socket.cc
index 1962319..c546cf9 100644
--- a/jingle/glue/proxy_resolving_client_socket.cc
+++ b/jingle/glue/proxy_resolving_client_socket.cc
@@ -12,6 +12,7 @@
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
+#include "net/base/ip_address.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_auth_controller.h"
@@ -354,13 +355,13 @@ int ProxyResolvingClientSocket::GetPeerAddress(
   if (proxy_info_.is_direct())
     return transport_->socket()->GetPeerAddress(address);
 
-  net::IPAddressNumber ip_number;
-  if (!net::ParseIPLiteralToNumber(dest_host_port_pair_.host(), &ip_number)) {
+  net::IPAddress ip_address;
+  if (!ip_address.AssignFromIPLiteral(dest_host_port_pair_.host())) {
     // Do not expose the proxy IP address to the caller.
     return net::ERR_NAME_NOT_RESOLVED;
   }
 
-  *address = net::IPEndPoint(ip_number, dest_host_port_pair_.port());
+  *address = net::IPEndPoint(ip_address, dest_host_port_pair_.port());
   return net::OK;
 }
 
diff --git a/jingle/glue/utils.cc b/jingle/glue/utils.cc
index d74c6bc..5a71779 100644
--- a/jingle/glue/utils.cc
+++ b/jingle/glue/utils.cc
@@ -11,6 +11,7 @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
+#include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "third_party/webrtc/base/byteorder.h"
 #include "third_party/webrtc/base/socketaddress.h"
@@ -34,17 +35,16 @@ bool SocketAddressToIPEndPoint(const rtc::SocketAddress& address,
       ip_endpoint->FromSockAddr(reinterpret_cast<sockaddr*>(&addr), size);
 }
 
-rtc::IPAddress IPAddressNumberToIPAddress(
-    const net::IPAddressNumber& ip_address_number) {
-  if (ip_address_number.size() == net::kIPv4AddressSize) {
+rtc::IPAddress NetIPAddressToRtcIPAddress(const net::IPAddress& ip_address) {
+  if (ip_address.IsIPv4()) {
     uint32_t address;
-    memcpy(&address, &ip_address_number[0], sizeof(uint32_t));
+    memcpy(&address, ip_address.bytes().data(), sizeof(uint32_t));
     address = rtc::NetworkToHost32(address);
     return rtc::IPAddress(address);
   }
-  if (ip_address_number.size() == net::kIPv6AddressSize) {
+  if (ip_address.IsIPv6()) {
     in6_addr address;
-    memcpy(&address, &ip_address_number[0], sizeof(in6_addr));
+    memcpy(&address, ip_address.bytes().data(), sizeof(in6_addr));
     return rtc::IPAddress(address);
   }
   return rtc::IPAddress();
diff --git a/jingle/glue/utils.h b/jingle/glue/utils.h
index 99c0ac0..1acd749 100644
--- a/jingle/glue/utils.h
+++ b/jingle/glue/utils.h
@@ -7,10 +7,10 @@
 
 #include <string>
 
-#include "net/base/ip_address_number.h"
 #include "third_party/webrtc/base/ipaddress.h"
 
 namespace net {
+class IPAddress;
 class IPEndPoint;
 }  // namespace net
 
@@ -32,8 +32,7 @@ bool IPEndPointToSocketAddress(const net::IPEndPoint& ip_endpoint,
 bool SocketAddressToIPEndPoint(const rtc::SocketAddress& address,
                                net::IPEndPoint* ip_endpoint);
 
-rtc::IPAddress IPAddressNumberToIPAddress(
-    const net::IPAddressNumber& ip_address_number);
+rtc::IPAddress NetIPAddressToRtcIPAddress(const net::IPAddress& ip_address);
 
 // Helper functions to serialize and deserialize P2P candidates.
 std::string SerializeP2PCandidate(const cricket::Candidate& candidate);