Land Recent QUIC Changes.

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>
 #include <iterator>
@@ skipping 1161 matching lines @@
   }
 }
 
 void QuicConnection::WriteIfNotBlocked() {
   if (!writer_->IsWriteBlocked()) {
     OnCanWrite();
   }
 }
 
 bool QuicConnection::ProcessValidatedPacket() {
-  if ((!FLAGS_quic_allow_port_migration && peer_port_changed_) ||
-      peer_ip_changed_ || self_ip_changed_ || self_port_changed_) {
+  if (peer_ip_changed_ || self_ip_changed_ || self_port_changed_) {
     SendConnectionCloseWithDetails(
         QUIC_ERROR_MIGRATING_ADDRESS,
         "Neither IP address migration, nor self port migration are supported.");
     return false;
   }
 
-  // Port migration is supported, do it now if port has changed.
-  if (FLAGS_quic_allow_port_migration &&
-      peer_port_changed_) {
+  // Peer port migration is supported, do it now if port has changed.
+  if (peer_port_changed_) {
     DVLOG(1) << ENDPOINT << "Peer's port changed from "
              << peer_address_.port() << " to " << migrating_peer_port_
              << ", migrating connection.";
     peer_address_ = IPEndPoint(peer_address_.address(), migrating_peer_port_);
   }
 
   time_of_last_received_packet_ = clock_->Now();
   DVLOG(1) << ENDPOINT << "time of last received packet: "
            << time_of_last_received_packet_.ToDebuggingValue();
 
@@ skipping 332 matching lines @@
         set_encryption_level(encryption_level_);
   }
   sent_packet_manager_.OnSerializedPacket(serialized_packet);
   // The TransmissionType is NOT_RETRANSMISSION because all retransmissions
   // serialize packets and invoke SendOrQueuePacket directly.
   return SendOrQueuePacket(encryption_level_,
                            serialized_packet,
                            NOT_RETRANSMISSION);
 }
 
+void QuicConnection::OnHandshakeComplete() {
+  sent_packet_manager_.SetHandshakeConfirmed();
+}
+
 bool QuicConnection::SendOrQueuePacket(EncryptionLevel level,
                                        const SerializedPacket& packet,
                                        TransmissionType transmission_type) {
   if (packet.packet == NULL) {
     LOG(DFATAL) << "NULL packet passed in to SendOrQueuePacket";
     return true;
   }
 
   sent_entropy_manager_.RecordPacketEntropyHash(packet.sequence_number,
                                                 packet.entropy_hash);
@@ skipping 234 matching lines @@
   packet_generator_.FlushAllQueuedFrames();
 }
 
 void QuicConnection::CloseConnection(QuicErrorCode error, bool from_peer) {
   if (!connected_) {
     DLOG(DFATAL) << "Error: attempt to close an already closed connection"
                  << base::debug::StackTrace().ToString();
     return;
   }
   connected_ = false;
+  if (debug_visitor_.get() != NULL) {
+    debug_visitor_->OnConnectionClosed(error, from_peer);
+  }
   visitor_->OnConnectionClosed(error, from_peer);
   // Cancel the alarms so they don't trigger any action now that the
   // connection is closed.
   ack_alarm_->Cancel();
   resume_writes_alarm_->Cancel();
   retransmission_alarm_->Cancel();
   send_alarm_->Cancel();
   timeout_alarm_->Cancel();
 }
 
@@ skipping 174 matching lines @@
   // 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_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net