Landing Recent QUIC changes until 2016-03-15 16:26 UTC

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 205 matching lines @@
       per_packet_options_(nullptr),
       writer_(writer),
       owns_writer_(owns_writer),
       encryption_level_(ENCRYPTION_NONE),
       has_forward_secure_encrypter_(false),
       first_required_forward_secure_packet_(0),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       connection_id_(connection_id),
       peer_address_(address),
-      migrating_peer_port_(0),
       last_packet_decrypted_(false),
       last_size_(0),
       current_packet_data_(nullptr),
       last_decrypted_packet_level_(ENCRYPTION_NONE),
       should_last_packet_instigate_acks_(false),
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
       max_undecryptable_packets_(0),
       pending_version_negotiation_packet_(false),
       save_crypto_packets_as_termination_packets_(false),
       silent_close_enabled_(false),
+      close_connection_after_five_rtos_(false),
       received_packet_manager_(&stats_),
       ack_queued_(false),
       num_retransmittable_packets_received_since_last_ack_sent_(0),
       last_ack_had_missing_packets_(false),
       num_packets_received_since_last_ack_sent_(0),
       stop_waiting_count_(0),
       ack_mode_(TCP_ACKING),
       delay_setting_retransmission_alarm_(false),
       pending_retransmission_alarm_(false),
       defer_send_in_response_to_packets_(false),
@@ skipping 26 matching lines @@
           perspective,
           kDefaultPathId,
           clock_,
           &stats_,
           FLAGS_quic_use_bbr_congestion_control ? kBBR : kCubic,
           FLAGS_quic_use_time_loss_detection ? kTime : kNack,
           /*delegate=*/nullptr),
       version_negotiation_state_(START_NEGOTIATION),
       perspective_(perspective),
       connected_(true),
-      peer_ip_changed_(false),
-      peer_port_changed_(false),
-      self_ip_changed_(false),
-      self_port_changed_(false),
       can_truncate_connection_ids_(true),
       mtu_discovery_target_(0),
       mtu_probe_count_(0),
       packets_between_mtu_probes_(kPacketsBetweenMtuProbesBase),
       next_mtu_probe_at_(kPacketsBetweenMtuProbesBase),
       largest_received_packet_size_(0),
       goaway_sent_(false),
       goaway_received_(false),
       multipath_enabled_(false) {
   DVLOG(1) << ENDPOINT
@@ skipping 65 matching lines @@
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSetFromConfig(config);
   }
   if (config.HasClientSentConnectionOption(kACKD, perspective_)) {
     ack_mode_ = ACK_DECIMATION;
   }
   if (FLAGS_quic_ack_decimation2 &&
       config.HasClientSentConnectionOption(kAKD2, perspective_)) {
     ack_mode_ = ACK_DECIMATION_WITH_REORDERING;
   }
+  if (FLAGS_quic_enable_rto_timeout &&
+      config.HasClientSentConnectionOption(k5RTO, perspective_)) {
+    close_connection_after_five_rtos_ = true;
+  }
 }
 
 void QuicConnection::OnSendConnectionState(
     const CachedNetworkParameters& cached_network_params) {
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSendConnectionState(cached_network_params);
   }
 }
 
 void QuicConnection::OnReceiveConnectionState(
@@ skipping 190 matching lines @@
 
   // Multipath is not enabled, but a packet with multipath flag on is received.
   if (!multipath_enabled_ && header.public_header.multipath_flag) {
     LOG(DFATAL) << "Received a packet with multipath flag on when multipath is "
                    "not enabled.";
     SendConnectionCloseWithDetails(QUIC_BAD_MULTIPATH_FLAG,
                                    "receive a packet with multipath flag on "
                                    "when multipath is not enabled.");
     return false;
   }
+  if (!packet_generator_.IsPendingPacketEmpty()) {
+    QUIC_BUG << "Pending frames must be serialized before incoming packets are "
+             << "processed, because that may change a queued ack frame.";
+    SendConnectionCloseWithDetails(QUIC_INTERNAL_ERROR,
+                                   "Should not process packets while sending.");
+    return false;
+  }
 
   // If this packet has already been seen, or the sender has told us that it
   // will not be retransmitted, then stop processing the packet.
   if (!received_packet_manager_.IsAwaitingPacket(header.packet_number)) {
     DVLOG(1) << ENDPOINT << "Packet " << header.packet_number
              << " no longer being waited for.  Discarding.";
     if (debug_visitor_ != nullptr) {
       debug_visitor_->OnDuplicatePacket(header.packet_number);
     }
     ++stats_.packets_dropped;
@@ skipping 69 matching lines @@
     DVLOG(1) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
 
   const char* error = ValidateAckFrame(incoming_ack);
   if (error != nullptr) {
     SendConnectionCloseWithDetails(QUIC_INVALID_ACK_DATA, error);
     return false;
   }
 
-  if (FLAGS_quic_respect_send_alarm2 && send_alarm_->IsSet()) {
+  if (send_alarm_->IsSet()) {
     send_alarm_->Cancel();
   }
   ProcessAckFrame(incoming_ack);
   if (incoming_ack.is_truncated) {
     should_last_packet_instigate_acks_ = true;
   }
   // If the peer is still waiting for a packet that we are no longer planning to
   // send, send an ack to raise the high water mark.
   if (!incoming_ack.missing_packets.Empty() &&
       GetLeastUnacked() > incoming_ack.missing_packets.Min()) {
@@ skipping 334 matching lines @@
         QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS,
         StringPrintf("More than %" PRIu64 " outstanding.", kMaxTrackedPackets));
   }
 }
 
 void QuicConnection::PopulateAckFrame(QuicAckFrame* ack) {
   received_packet_manager_.UpdateReceivedPacketInfo(ack,
                                                     clock_->ApproximateNow());
 }
 
+const QuicFrame QuicConnection::GetUpdatedAckFrame() {
+  return received_packet_manager_.GetUpdatedAckFrame(clock_->ApproximateNow());
+}
+
 void QuicConnection::PopulateStopWaitingFrame(
     QuicStopWaitingFrame* stop_waiting) {
   stop_waiting->least_unacked = GetLeastUnacked();
   stop_waiting->entropy_hash = sent_entropy_manager_.GetCumulativeEntropy(
       stop_waiting->least_unacked - 1);
 }
 
 QuicPacketNumber QuicConnection::GetLeastUnacked() const {
   return sent_packet_manager_.GetLeastUnacked();
 }
@@ skipping 61 matching lines @@
   // SHLO from the server, leading to two different decrypters at the server.)
   //
   // TODO(jri): Note that ConsumeData may cause a response packet to be sent.
   // We may end up sending stale ack information if there are undecryptable
   // packets hanging around and/or there are revivable packets which may get
   // handled after this packet is sent. Change ScopedPacketBundler to do the
   // right thing: check ack_queued_, and then check undecryptable packets and
   // also if there is possibility of revival. Only bundle an ack if there's no
   // processing left that may cause received_info_ to change.
   ScopedRetransmissionScheduler alarm_delayer(this);
-  ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
+  ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   return packet_generator_.ConsumeData(id, iov, offset, fin, listener);
 }
 
 void QuicConnection::SendRstStream(QuicStreamId id,
                                    QuicRstStreamErrorCode error,
                                    QuicStreamOffset bytes_written) {
   // Opportunistically bundle an ack with this outgoing packet.
-  ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
+  ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   packet_generator_.AddControlFrame(QuicFrame(new QuicRstStreamFrame(
       id, AdjustErrorForVersion(error, version()), bytes_written)));
 
   if (error == QUIC_STREAM_NO_ERROR && version() > QUIC_VERSION_28) {
     // All data for streams which are reset with QUIC_STREAM_NO_ERROR must
     // be received by the peer.
     return;
   }
 
   sent_packet_manager_.CancelRetransmissionsForStream(id);
@@ skipping 13 matching lines @@
     }
     delete[] packet_iterator->encrypted_buffer;
     QuicUtils::ClearSerializedPacket(&(*packet_iterator));
     packet_iterator = queued_packets_.erase(packet_iterator);
   }
 }
 
 void QuicConnection::SendWindowUpdate(QuicStreamId id,
                                       QuicStreamOffset byte_offset) {
   // Opportunistically bundle an ack with this outgoing packet.
-  ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
+  ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicWindowUpdateFrame(id, byte_offset)));
 }
 
 void QuicConnection::SendBlocked(QuicStreamId id) {
   // Opportunistically bundle an ack with this outgoing packet.
-  ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
+  ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   packet_generator_.AddControlFrame(QuicFrame(new QuicBlockedFrame(id)));
 }
 
 void QuicConnection::SendPathClose(QuicPathId path_id) {
   // Opportunistically bundle an ack with this outgoing packet.
-  ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
+  ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   packet_generator_.AddControlFrame(QuicFrame(new QuicPathCloseFrame(path_id)));
   OnPathClosed(path_id);
 }
 
 const QuicConnectionStats& QuicConnection::GetStats() {
   const RttStats* rtt_stats = sent_packet_manager_.GetRttStats();
 
   // Update rtt and estimated bandwidth.
   QuicTime::Delta min_rtt = rtt_stats->min_rtt();
   if (min_rtt.IsZero()) {
@@ skipping 20 matching lines @@
                                       const QuicEncryptedPacket& packet) {
   if (!connected_) {
     return;
   }
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPacketReceived(self_address, peer_address, packet);
   }
   last_size_ = packet.length();
   current_packet_data_ = packet.data();
 
-  if (FLAGS_check_peer_address_change_after_decryption) {
-    last_packet_destination_address_ = self_address;
-    last_packet_source_address_ = peer_address;
-    if (!IsInitializedIPEndPoint(self_address_)) {
-      self_address_ = last_packet_destination_address_;
-    }
-    if (!IsInitializedIPEndPoint(peer_address_)) {
-      peer_address_ = last_packet_source_address_;
-    }
-  } else {
-    CheckForAddressMigration(self_address, peer_address);
+  last_packet_destination_address_ = self_address;
+  last_packet_source_address_ = peer_address;
+  if (!IsInitializedIPEndPoint(self_address_)) {
+    self_address_ = last_packet_destination_address_;
+  }
+  if (!IsInitializedIPEndPoint(peer_address_)) {
+    peer_address_ = last_packet_source_address_;
   }
 
   stats_.bytes_received += packet.length();
   ++stats_.packets_received;
 
   ScopedRetransmissionScheduler alarm_delayer(this);
   if (!framer_.ProcessPacket(packet)) {
     // If we are unable to decrypt this packet, it might be
     // because the CHLO or SHLO packet was lost.
     if (framer_.error() == QUIC_DECRYPTION_FAILURE) {
@@ skipping 10 matching lines @@
     return;
   }
 
   ++stats_.packets_processed;
   MaybeProcessUndecryptablePackets();
   MaybeSendInResponseToPacket();
   SetPingAlarm();
   current_packet_data_ = nullptr;
 }
 
-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()) {
-    peer_address_ = peer_address;
-  }
-  if (self_address_.address().empty()) {
-    self_address_ = self_address;
-  }
-
-  if (!peer_address.address().empty() && !peer_address_.address().empty()) {
-    peer_ip_changed_ = (peer_address.address() != peer_address_.address());
-    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_port_ = peer_address.port();
-  }
-
-  if (!self_address.address().empty() && !self_address_.address().empty()) {
-    self_ip_changed_ = (self_address.address() != self_address_.address());
-    self_port_changed_ = (self_address.port() != self_address_.port());
-  }
-}
-
 void QuicConnection::OnCanWrite() {
   DCHECK(!writer_->IsWriteBlocked());
 
   WriteQueuedPackets();
   WritePendingRetransmissions();
 
   // Sending queued packets may have caused the socket to become write blocked,
   // or the congestion manager to prohibit sending.  If we've sent everything
   // we had queued and we're still not blocked, let the visitor know it can
   // write more.
   if (!CanWrite(HAS_RETRANSMITTABLE_DATA)) {
     return;
   }
 
-  {  // Limit the scope of the bundler. ACK inclusion happens elsewhere.
-    ScopedPacketBundler bundler(this, NO_ACK);
+  {
+    ScopedPacketBundler bundler(this, SEND_ACK_IF_QUEUED);
     visitor_->OnCanWrite();
     visitor_->PostProcessAfterData();
   }
 
   // After the visitor writes, it may have caused the socket to become write
   // blocked or the congestion manager to prohibit sending, so check again.
   if (visitor_->WillingAndAbleToWrite() && !resume_writes_alarm_->IsSet() &&
       CanWrite(HAS_RETRANSMITTABLE_DATA)) {
     // We're not write blocked, but some stream didn't write out all of its
     // bytes. Register for 'immediate' resumption so we'll keep writing after
     // other connections and events have had a chance to use the thread.
     resume_writes_alarm_->Set(clock_->ApproximateNow());
   }
 }
 
 void QuicConnection::WriteIfNotBlocked() {
   if (!writer_->IsWriteBlocked()) {
     OnCanWrite();
   }
 }
 
 void QuicConnection::WriteAndBundleAcksIfNotBlocked() {
   if (!writer_->IsWriteBlocked()) {
-    ScopedPacketBundler bundler(this, ack_queued_ ? SEND_ACK : NO_ACK);
+    ScopedPacketBundler bundler(this, SEND_ACK_IF_QUEUED);
     OnCanWrite();
   }
 }
 
 bool QuicConnection::ProcessValidatedPacket(const QuicPacketHeader& header) {
   if (header.fec_flag) {
     // Drop any FEC packet.
     return false;
   }
 
-  if (FLAGS_check_peer_address_change_after_decryption) {
-    if (perspective_ == Perspective::IS_SERVER &&
-        IsInitializedIPEndPoint(self_address_) &&
-        IsInitializedIPEndPoint(last_packet_destination_address_) &&
-        (!(self_address_ == last_packet_destination_address_))) {
-      SendConnectionCloseWithDetails(
-          QUIC_ERROR_MIGRATING_ADDRESS,
-          "Self address migration is not supported at the server.");
-      return false;
-    }
-  } else {
-    if (perspective_ == Perspective::IS_SERVER &&
-        (self_ip_changed_ || self_port_changed_)) {
-      SendConnectionCloseWithDetails(
-          QUIC_ERROR_MIGRATING_ADDRESS,
-          "Self address migration is not supported at the server.");
-      return false;
-    }
+  if (perspective_ == Perspective::IS_SERVER &&
+      IsInitializedIPEndPoint(self_address_) &&
+      IsInitializedIPEndPoint(last_packet_destination_address_) &&
+      (!(self_address_ == last_packet_destination_address_))) {
+    SendConnectionCloseWithDetails(
+        QUIC_ERROR_MIGRATING_ADDRESS,
+        "Self address migration is not supported at the server.");
+    return false;
   }
 
   if (!Near(header.packet_number, last_header_.packet_number)) {
     DVLOG(1) << ENDPOINT << "Packet " << header.packet_number
              << " out of bounds.  Discarding";
     SendConnectionCloseWithDetails(QUIC_INVALID_PACKET_HEADER,
                                    "packet number out of bounds");
     return false;
   }
 
@@ skipping 115 matching lines @@
 bool QuicConnection::CanWrite(HasRetransmittableData retransmittable) {
   if (!connected_) {
     return false;
   }
 
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     return false;
   }
 
-  if (FLAGS_quic_respect_send_alarm2) {
-    // Allow acks to be sent immediately.
-    // TODO(ianswett): Remove retransmittable from
-    // SendAlgorithmInterface::TimeUntilSend.
-    if (retransmittable == NO_RETRANSMITTABLE_DATA) {
-      return true;
-    }
-    // If the send alarm is set, wait for it to fire.
-    if (send_alarm_->IsSet()) {
-      return false;
-    }
+  // Allow acks to be sent immediately.
+  // TODO(ianswett): Remove retransmittable from
+  // SendAlgorithmInterface::TimeUntilSend.
+  if (retransmittable == NO_RETRANSMITTABLE_DATA) {
+    return true;
+  }
+  // If the send alarm is set, wait for it to fire.
+  if (send_alarm_->IsSet()) {
+    return false;
   }
 
   QuicTime now = clock_->Now();
   QuicTime::Delta delay =
       sent_packet_manager_.TimeUntilSend(now, retransmittable);
   if (delay.IsInfinite()) {
     send_alarm_->Cancel();
     return false;
   }
 
   // If the scheduler requires a delay, then we can not send this packet now.
   if (!delay.IsZero()) {
     send_alarm_->Update(now.Add(delay), QuicTime::Delta::FromMilliseconds(1));
     DVLOG(1) << ENDPOINT << "Delaying sending " << delay.ToMilliseconds()
              << "ms";
     return false;
   }
-  if (!FLAGS_quic_respect_send_alarm2) {
-    send_alarm_->Cancel();
-  }
   return true;
 }
 
 bool QuicConnection::WritePacket(SerializedPacket* packet) {
   if (packet->packet_number < sent_packet_manager_.largest_sent_packet()) {
     QUIC_BUG << "Attempt to write packet:" << packet->packet_number
              << " after:" << sent_packet_manager_.largest_sent_packet();
     SendConnectionCloseWithDetails(QUIC_INTERNAL_ERROR,
                                    "Packet written out of order.");
     return true;
@@ skipping 235 matching lines @@
   }
 }
 
 void QuicConnection::OnPingTimeout() {
   if (!retransmission_alarm_->IsSet()) {
     SendPing();
   }
 }
 
 void QuicConnection::SendPing() {
-  ScopedPacketBundler bundler(this, ack_queued_ ? SEND_ACK : NO_ACK);
+  ScopedPacketBundler bundler(this, SEND_ACK_IF_QUEUED);
   packet_generator_.AddControlFrame(QuicFrame(QuicPingFrame()));
   // Send PING frame immediately, without checking for congestion window bounds.
   packet_generator_.FlushAllQueuedFrames();
 }
 
 void QuicConnection::SendAck() {
   ack_alarm_->Cancel();
   ack_queued_ = false;
   stop_waiting_count_ = 0;
   num_retransmittable_packets_received_since_last_ack_sent_ = 0;
   last_ack_had_missing_packets_ = received_packet_manager_.HasMissingPackets();
   num_packets_received_since_last_ack_sent_ = 0;
 
   packet_generator_.SetShouldSendAck(true);
 }
 
 void QuicConnection::OnRetransmissionTimeout() {
   if (!sent_packet_manager_.HasUnackedPackets()) {
     return;
   }
 
+  if (close_connection_after_five_rtos_ &&
+      sent_packet_manager_.consecutive_rto_count() >= 4) {
+    // Close on the 5th consecutive RTO, so after 4 previous RTOs have occurred.
+    SendConnectionCloseWithDetails(QUIC_TOO_MANY_RTOS,
+                                   "5 consecutive retransmission timeouts");
+    return;
+  }
+
   sent_packet_manager_.OnRetransmissionTimeout();
   WriteIfNotBlocked();
 
   // A write failure can result in the connection being closed, don't attempt to
   // write further packets, or to set alarms.
   if (!connected_) {
     return;
   }
 
   // In the TLP case, the SentPacketManager gives the connection the opportunity
@@ skipping 154 matching lines @@
                                 const string& reason) {
   if (goaway_sent_) {
     return;
   }
   goaway_sent_ = true;
 
   DVLOG(1) << ENDPOINT << "Going away with error "
            << QuicUtils::ErrorToString(error) << " (" << error << ")";
 
   // Opportunistically bundle an ack with this outgoing packet.
-  ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
+  ScopedPacketBundler ack_bundler(this, SEND_ACK_IF_PENDING);
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicGoAwayFrame(error, last_good_stream_id, reason)));
 }
 
 QuicByteCount QuicConnection::max_packet_length() const {
   return packet_generator_.GetCurrentMaxPacketLength();
 }
 
 void QuicConnection::SetMaxPacketLength(QuicByteCount length) {
   return packet_generator_.SetMaxPacketLength(LimitMaxPacketSize(length));
@@ skipping 144 matching lines @@
 
   if (packet_number_of_last_sent_packet_ >= next_mtu_probe_at_) {
     // Use an alarm to send the MTU probe to ensure that no ScopedPacketBundlers
     // are active.
     mtu_discovery_alarm_->Set(clock_->ApproximateNow());
   }
 }
 
 QuicConnection::ScopedPacketBundler::ScopedPacketBundler(
     QuicConnection* connection,
-    AckBundling send_ack)
+    AckBundling ack_mode)
     : connection_(connection),
       already_in_batch_mode_(connection != nullptr &&
                              connection->packet_generator_.InBatchMode()) {
   if (connection_ == nullptr) {
     return;
   }
   // Move generator into batch mode. If caller wants us to include an ack,
   // check the delayed-ack timer to see if there's ack info to be sent.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Entering Batch Mode.";
     connection_->packet_generator_.StartBatchOperations();
   }
-  // Bundle an ack if the alarm is set or with every second packet if we need to
-  // raise the peer's least unacked.
-  bool ack_pending =
-      connection_->ack_alarm_->IsSet() || connection_->stop_waiting_count_ > 1;
-  if (send_ack == SEND_ACK || (send_ack == BUNDLE_PENDING_ACK && ack_pending)) {
+  if (ShouldSendAck(ack_mode)) {
     DVLOG(1) << "Bundling ack with outgoing packet.";
-    DCHECK(send_ack == SEND_ACK || connection_->ack_frame_updated() ||
+    DCHECK(ack_mode == SEND_ACK || connection_->ack_frame_updated() ||
            connection_->stop_waiting_count_ > 1);
     connection_->SendAck();
   }
 }
 
+bool QuicConnection::ScopedPacketBundler::ShouldSendAck(
+    AckBundling ack_mode) const {
+  switch (ack_mode) {
+    case SEND_ACK:
+      return true;
+    case SEND_ACK_IF_QUEUED:
+      return connection_->ack_queued();
+    case SEND_ACK_IF_PENDING:
+      return connection_->ack_alarm_->IsSet() ||
+             connection_->stop_waiting_count_ > 1;
+    default:
+      QUIC_BUG << "Unsupported ack_mode.";
+      return true;
+  }
+}
+
 QuicConnection::ScopedPacketBundler::~ScopedPacketBundler() {
   if (connection_ == nullptr) {
     return;
   }
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
@@ skipping 105 matching lines @@
   ++mtu_probe_count_;
 
   DVLOG(2) << "Sending a path MTU discovery packet #" << mtu_probe_count_;
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 void QuicConnection::MaybeMigrateConnectionToNewPeerAddress() {
   IPEndPoint last_peer_address;
-  if (FLAGS_check_peer_address_change_after_decryption) {
-    last_peer_address = last_packet_source_address_;
-  } else {
-    last_peer_address = IPEndPoint(
-        peer_ip_changed_ ? migrating_peer_ip_ : peer_address_.address(),
-        peer_port_changed_ ? migrating_peer_port_ : peer_address_.port());
-  }
+  last_peer_address = last_packet_source_address_;
   PeerAddressChangeType peer_address_change_type =
       QuicUtils::DetermineAddressChangeType(peer_address_, last_peer_address);
   // TODO(fayang): Currently, all peer address change type are allowed. Need to
   // add a method ShouldAllowPeerAddressChange(PeerAddressChangeType type) to
-  // determine whehter |type| is allowed.
-  if (FLAGS_check_peer_address_change_after_decryption) {
-    if (peer_address_change_type == NO_CHANGE) {
-      return;
-    }
-
-    IPEndPoint old_peer_address = peer_address_;
-    peer_address_ = last_packet_source_address_;
-
-    DVLOG(1) << ENDPOINT << "Peer's ip:port changed from "
-             << old_peer_address.ToString() << " to "
-             << peer_address_.ToString() << ", migrating connection.";
-
-    visitor_->OnConnectionMigration(peer_address_change_type);
-    sent_packet_manager_.OnConnectionMigration(peer_address_change_type);
-
+  // determine whether |type| is allowed.
+  if (peer_address_change_type == NO_CHANGE) {
     return;
   }
 
-  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_port_changed_ ? migrating_peer_port_ : peer_address_.port());
+  IPEndPoint old_peer_address = peer_address_;
+  peer_address_ = last_packet_source_address_;
 
-    DVLOG(1) << ENDPOINT << "Peer's ip:port changed from "
-             << old_peer_address.ToString() << " to "
-             << peer_address_.ToString() << ", migrating connection.";
+  DVLOG(1) << ENDPOINT << "Peer's ip:port changed from "
+           << old_peer_address.ToString() << " to " << peer_address_.ToString()
+           << ", migrating connection.";
 
-    visitor_->OnConnectionMigration(peer_address_change_type);
-    DCHECK_NE(peer_address_change_type, NO_CHANGE);
-    sent_packet_manager_.OnConnectionMigration(peer_address_change_type);
-  }
+  visitor_->OnConnectionMigration(peer_address_change_type);
+  sent_packet_manager_.OnConnectionMigration(peer_address_change_type);
 }
 
 void QuicConnection::OnPathClosed(QuicPathId path_id) {
   // Stop receiving packets on this path.
   framer_.OnPathClosed(path_id);
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 StringPiece QuicConnection::GetCurrentPacket() {
   if (current_packet_data_ == nullptr) {
     return StringPiece();
   }
   return StringPiece(current_packet_data_, last_size_);
 }
 
 }  // namespace net