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

net/quic/quic_connection.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 "net/quic/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 
 #include <algorithm>
@@ skipping 1075 matching lines @@
     visitor_->OnWriteBlocked();
     return;
   }
   DVLOG(1) << ENDPOINT << "Sending version negotiation packet: {"
            << QuicVersionVectorToString(framer_.supported_versions()) << "}";
   scoped_ptr<QuicEncryptedPacket> version_packet(
       packet_generator_.SerializeVersionNegotiationPacket(
           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);
     return;
   }
   if (result.status == WRITE_STATUS_BLOCKED) {
     visitor_->OnWriteBlocked();
     if (writer_->IsWriteBlockedDataBuffered()) {
       pending_version_negotiation_packet_ = false;
     }
@@ skipping 148 matching lines @@
   SetPingAlarm();
 }
 
 void QuicConnection::CheckForAddressMigration(const IPEndPoint& self_address,
                                               const IPEndPoint& peer_address) {
   peer_ip_changed_ = false;
   peer_port_changed_ = false;
   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());
   }
 
   // TODO(vasilvv): reset maximum packet size on connection migration. Whenever
   // the connection is migrated, it usually ends up being on a different path,
   // with possibly smaller MTU.  This means the max packet size has to be reset
   // and MTU discovery mechanism re-initialized.  The main reason the code does
   // not do it now is that the retransmission code currently cannot deal with
   // the case when it needs to resend a packet created with larger MTU (see
   // b/22172803).
@@ skipping 103 matching lines @@
         debug_visitor_->OnSuccessfulVersionNegotiation(version());
       }
     }
   }
 
   DCHECK_EQ(NEGOTIATED_VERSION, version_negotiation_state_);
 
   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 "
              << old_peer_address.ToString() << " to "
              << peer_address_.ToString() << ", migrating connection.";
 
     visitor_->OnConnectionMigration();
     DCHECK_NE(type, NO_CHANGE);
     sent_packet_manager_.OnConnectionMigration(type);
   }
@@ skipping 199 matching lines @@
            << ", encrypted length:" << encrypted->length();
   DVLOG(2) << ENDPOINT << "packet(" << packet_number << "): " << std::endl
            << QuicUtils::StringToHexASCIIDump(encrypted->AsStringPiece());
 
   // Measure the RTT from before the write begins to avoid underestimating the
   // min_rtt_, especially in cases where the thread blocks or gets swapped out
   // during the WritePacket below.
   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);
   }
 
   if (result.status == WRITE_STATUS_BLOCKED) {
     visitor_->OnWriteBlocked();
     // If the socket buffers the the data, then the packet should not
     // be queued and sent again, which would result in an unnecessary
     // duplicate packet being sent.  The helper must call OnCanWrite
     // when the write completes, and OnWriteError if an error occurs.
@@ skipping 40 matching lines @@
   ++stats_.packets_sent;
   if (packet->transmission_type != NOT_RETRANSMISSION) {
     stats_.bytes_retransmitted += result.bytes_written;
     ++stats_.packets_retransmitted;
   }
 
   if (result.status == WRITE_STATUS_ERROR) {
     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();
     return false;
   }
 
   return true;
 }
 
 bool QuicConnection::ShouldDiscardPacket(const QueuedPacket& packet) {
@@ skipping 654 matching lines @@
   }
   return false;
 }
 
 void QuicConnection::SetMtuDiscoveryTarget(QuicByteCount target) {
   mtu_discovery_target_ = LimitMaxPacketSize(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;
   }
 
   const QuicByteCount writer_limit = writer_->GetMaxPacketSize(peer_address());
 
   QuicByteCount max_packet_size = suggested_max_packet_size;
   if (max_packet_size > writer_limit) {
     max_packet_size = writer_limit;
   }
@@ skipping 40 matching lines @@
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 }  // namespace net