Add IPAddress class as a replacement for the IPAddressNumber typedef.

net/base/ip_endpoint.cc

Index: net/base/ip_endpoint.cc
diff --git a/net/base/ip_endpoint.cc b/net/base/ip_endpoint.cc
index 78348493d9868768a2134fbcbe72f4a64bf6d5f5..3668dd28978b43d67806128998eebb7f054e1ef5 100644
--- a/net/base/ip_endpoint.cc
+++ b/net/base/ip_endpoint.cc
@@ -6,7 +6,6 @@
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/sys_byteorder.h"
 #if defined(OS_WIN)
 #include <winsock2.h>
 #elif defined(OS_POSIX)
@@ -16,19 +15,15 @@
 
 namespace net {
 
-namespace {
-// By definition, socklen_t is large enough to hold both sizes.
-const socklen_t kSockaddrInSize = sizeof(struct sockaddr_in);
-const socklen_t kSockaddrIn6Size = sizeof(struct sockaddr_in6);
-}
-
 IPEndPoint::IPEndPoint() : port_(0) {}
 
 IPEndPoint::~IPEndPoint() {}
 
 IPEndPoint::IPEndPoint(const IPAddressNumber& address, uint16_t port)
-    : address_(address), port_(port) {
-}
+    : address_(IPAddress::FromLegacy(address)), port_(port) {}
+
+IPEndPoint::IPEndPoint(const IPAddress& address, uint16_t port)
+    : address_(address), port_(port) {}
 
 IPEndPoint::IPEndPoint(const IPEndPoint& endpoint) {
   address_ = endpoint.address_;
@@ -36,14 +31,14 @@ IPEndPoint::IPEndPoint(const IPEndPoint& endpoint) {
 }
 
 AddressFamily IPEndPoint::GetFamily() const {
-  return GetAddressFamily(address_);
+  return address_.GetAddressFamily();
 }
 
 int IPEndPoint::GetSockAddrFamily() const {
   switch (address_.size()) {
-    case kIPv4AddressSize:
+    case IPAddress::kIPv4AddressSize:
       return AF_INET;
-    case kIPv6AddressSize:
+    case IPAddress::kIPv6AddressSize:
       return AF_INET6;
     default:
       NOTREACHED() << "Bad IP address";
@@ -55,34 +50,7 @@ bool IPEndPoint::ToSockAddr(struct sockaddr* address,
                             socklen_t* address_length) const {
   DCHECK(address);
   DCHECK(address_length);
-  switch (address_.size()) {
-    case kIPv4AddressSize: {
-      if (*address_length < kSockaddrInSize)
-        return false;
-      *address_length = kSockaddrInSize;
-      struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(address);
-      memset(addr, 0, sizeof(struct sockaddr_in));
-      addr->sin_family = AF_INET;
-      addr->sin_port = base::HostToNet16(port_);
-      memcpy(&addr->sin_addr, &address_[0], kIPv4AddressSize);
-      break;
-    }
-    case kIPv6AddressSize: {
-      if (*address_length < kSockaddrIn6Size)
-        return false;
-      *address_length = kSockaddrIn6Size;
-      struct sockaddr_in6* addr6 =
-          reinterpret_cast<struct sockaddr_in6*>(address);
-      memset(addr6, 0, sizeof(struct sockaddr_in6));
-      addr6->sin6_family = AF_INET6;
-      addr6->sin6_port = base::HostToNet16(port_);
-      memcpy(&addr6->sin6_addr, &address_[0], kIPv6AddressSize);
-      break;
-    }
-    default:
-      return false;
-  }
-  return true;
+  return address_.ToSockAddrWithPort(address, address_length, port_);
 }
 
 bool IPEndPoint::FromSockAddr(const struct sockaddr* sock_addr,
@@ -97,28 +65,26 @@ bool IPEndPoint::FromSockAddr(const struct sockaddr* sock_addr,
     return false;
   }
 
-  address_.assign(address, address + address_len);
+  std::vector<unsigned char> vec(address, address + address_len);
+  IPAddress ip_address(vec);
+  address_ = ip_address;
   port_ = port;
   return true;
 }
 
 std::string IPEndPoint::ToString() const {
-  return IPAddressToStringWithPort(address_, port_);
+  return address_.ToStringWithPort(port_);
 }
 
 std::string IPEndPoint::ToStringWithoutPort() const {
-  return IPAddressToString(address_);
+  return address_.ToString();
 }
 
 bool IPEndPoint::operator<(const IPEndPoint& that) const {
-  // Sort IPv4 before IPv6.
-  if (address_.size() != that.address_.size()) {
-    return address_.size() < that.address_.size();
-  }
-  if (address_ != that.address_) {
-    return address_ < that.address_;
+  if (address_ == that.address_) {
+    return port_ < that.port_;
   }
-  return port_ < that.port_;
+  return address_ < that.address_;
 }
 
 bool IPEndPoint::operator==(const IPEndPoint& that) const {