Change IPEndpoint::address() to return a net::IPAddress

net/quic/quic_connection.cc

Index: net/quic/quic_connection.cc
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index a3298bcc70abe1439d99a88dc9061cc66e090f64..cf0fd8a8409f0cc6326058b01bb8d0469a212d58 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -1093,7 +1093,7 @@ void QuicConnection::SendVersionNegotiationPacket() {
           framer_.supported_versions()));
   WriteResult result =
       writer_->WritePacket(version_packet->data(), version_packet->length(),
-                           self_address().address(), peer_address());
+                           self_address().address_number(), peer_address());
 
   if (result.status == WRITE_STATUS_ERROR) {
     OnWriteError(result.error_code);
@@ -1262,24 +1262,28 @@ void QuicConnection::CheckForAddressMigration(const IPEndPoint& self_address,
   self_ip_changed_ = false;
   self_port_changed_ = false;
 
-  if (peer_address_.address().empty()) {
+  if (peer_address_.address_number().empty()) {
     peer_address_ = peer_address;
   }
-  if (self_address_.address().empty()) {
+  if (self_address_.address_number().empty()) {
     self_address_ = self_address;
   }
 
-  if (!peer_address.address().empty() && !peer_address_.address().empty()) {
-    peer_ip_changed_ = (peer_address.address() != peer_address_.address());
+  if (!peer_address.address_number().empty() &&
+      !peer_address_.address_number().empty()) {
+    peer_ip_changed_ =
+        (peer_address.address_number() != peer_address_.address_number());
     peer_port_changed_ = (peer_address.port() != peer_address_.port());
 
     // Store in case we want to migrate connection in ProcessValidatedPacket.
-    migrating_peer_ip_ = peer_address.address();
+    migrating_peer_ip_ = peer_address.address_number();
     migrating_peer_port_ = peer_address.port();
   }
 
-  if (!self_address.address().empty() && !self_address_.address().empty()) {
-    self_ip_changed_ = (self_address.address() != self_address_.address());
+  if (!self_address.address_number().empty() &&
+      !self_address_.address_number().empty()) {
+    self_ip_changed_ =
+        (self_address.address_number() != self_address_.address_number());
     self_port_changed_ = (self_address.port() != self_address_.port());
   }
 
@@ -1403,7 +1407,7 @@ bool QuicConnection::ProcessValidatedPacket(const QuicPacketHeader& header) {
   if (peer_ip_changed_ || peer_port_changed_) {
     IPEndPoint old_peer_address = peer_address_;
     peer_address_ = IPEndPoint(
-        peer_ip_changed_ ? migrating_peer_ip_ : peer_address_.address(),
+        peer_ip_changed_ ? migrating_peer_ip_ : peer_address_.address_number(),
         peer_port_changed_ ? migrating_peer_port_ : peer_address_.port());
 
     DVLOG(1) << ENDPOINT << "Peer's ip:port changed from "
@@ -1623,7 +1627,7 @@ bool QuicConnection::WritePacketInner(QueuedPacket* packet) {
   QuicTime packet_send_time = clock_->Now();
   WriteResult result =
       writer_->WritePacket(encrypted->data(), encrypted->length(),
-                           self_address().address(), peer_address());
+                           self_address().address_number(), peer_address());
   if (result.error_code == ERR_IO_PENDING) {
     DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
   }
@@ -1684,7 +1688,7 @@ bool QuicConnection::WritePacketInner(QueuedPacket* packet) {
     OnWriteError(result.error_code);
     DLOG(ERROR) << ENDPOINT << "failed writing " << encrypted->length()
                 << " bytes "
-                << " from host " << (self_address().address().empty()
+                << " from host " << (self_address().address_number().empty()
                                          ? " empty address "
                                          : self_address().ToStringWithoutPort())
                 << " to address " << peer_address().ToString();
@@ -2359,7 +2363,7 @@ void QuicConnection::SetMtuDiscoveryTarget(QuicByteCount target) {
 
 QuicByteCount QuicConnection::LimitMaxPacketSize(
     QuicByteCount suggested_max_packet_size) {
-  if (peer_address_.address().empty()) {
+  if (peer_address_.address_number().empty()) {
     LOG(DFATAL) << "Attempted to use a connection without a valid peer address";
     return suggested_max_packet_size;
   }