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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_utils.h"
 
 using base::hash_map;
 using base::hash_set;
 using base::StringPiece;
 using std::list;
 using std::make_pair;
 using std::min;
 using std::max;
 using std::vector;
 using std::set;
 using std::string;
 
 namespace net {
-
-// TODO(pwestin): kDefaultTimeoutUs is in int64.
-int32 kNegotiatedTimeoutUs = kDefaultTimeoutUs;
-
 namespace {
 
 // The largest gap in packets we'll accept without closing the connection.
 // This will likely have to be tuned.
 const QuicPacketSequenceNumber kMaxPacketGap = 5000;
 
 // The maximum number of nacks which can be transmitted in a single ack packet
 // without exceeding kMaxPacketSize.
 // TODO(satyamshekhar): Get rid of magic numbers and move this to protocol.h
 // 16 - Min ack frame size.
@@ skipping 29 matching lines @@
 }
 
 }  // namespace
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 QuicConnection::QuicConnection(QuicGuid guid,
                                IPEndPoint address,
                                QuicConnectionHelperInterface* helper,
                                bool is_server)
-    : helper_(helper),
-      framer_(kQuicVersion1,
+    : framer_(kQuicVersion1,
               helper->GetClock()->ApproximateNow(),
               is_server),
+      helper_(helper),
       encryption_level_(ENCRYPTION_NONE),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       guid_(guid),
       peer_address_(address),
       largest_seen_packet_with_ack_(0),
       peer_largest_observed_packet_(0),
       least_packet_awaited_by_peer_(1),
       peer_least_packet_awaiting_ack_(0),
       handling_retransmission_timeout_(false),
@@ skipping 35 matching lines @@
 QuicConnection::~QuicConnection() {
   STLDeleteValues(&unacked_packets_);
   STLDeleteValues(&group_map_);
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
     delete it->packet;
   }
 }
 
 bool QuicConnection::SelectMutualVersion(
-    const QuicVersionTagList& available_versions) {
+    const QuicTagVector& available_versions) {
   // TODO(satyamshekhar): Make this generic.
   if (std::find(available_versions.begin(), available_versions.end(),
                 kQuicVersion1) == available_versions.end()) {
     return false;
   }
 
   // Right now we only support kQuicVersion1 so it's okay not to
   // update the framer and quic_version_. When start supporting more
   // versions please update both.
   return true;
@@ skipping 21 matching lines @@
 }
 
 void QuicConnection::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   if (debug_visitor_) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
   CloseConnection(QUIC_PUBLIC_RESET, true);
 }
 
-bool QuicConnection::OnProtocolVersionMismatch(
-    QuicVersionTag received_version) {
+bool QuicConnection::OnProtocolVersionMismatch(QuicTag received_version) {
   // TODO(satyamshekhar): Implement no server state in this mode.
   if (!is_server_) {
     LOG(DFATAL) << "Framer called OnProtocolVersionMismatch for server. "
                 << "Closing connection.";
     CloseConnection(QUIC_INTERNAL_ERROR, false);
     return false;
   }
   DCHECK_NE(quic_version_, received_version);
 
   if (debug_visitor_) {
@@ skipping 480 matching lines @@
     SendAck();
   } else if (!last_stream_frames_.empty()) {
     // TODO(alyssar) this case should really be "if the packet contained any
     // non-ack frame", rather than "if the packet contained a stream frame"
     helper_->SetAckAlarm(congestion_manager_.DefaultRetransmissionTime());
   }
   send_ack_in_response_to_packet_ = !send_ack_in_response_to_packet_;
 }
 
 void QuicConnection::SendVersionNegotiationPacket() {
-  QuicVersionTagList supported_versions;
+  QuicTagVector supported_versions;
   supported_versions.push_back(kQuicVersion1);
   QuicEncryptedPacket* encrypted =
       packet_creator_.SerializeVersionNegotiationPacket(supported_versions);
   // TODO(satyamshekhar): implement zero server state negotiation.
   int error;
   helper_->WritePacketToWire(*encrypted, &error);
   delete encrypted;
 }
 
 QuicConsumedData QuicConnection::SendStreamData(QuicStreamId id,
@@ skipping 593 matching lines @@
     group_map_.erase(it);
     delete fec_group;
     it = next;
   }
 }
 
 bool QuicConnection::HasQueuedData() const {
   return !queued_packets_.empty() || packet_generator_.HasQueuedData();
 }
 
+void QuicConnection::SetConnectionTimeout(QuicTime::Delta timeout) {
+  timeout_ = timeout;
+  CheckForTimeout();
+}
+
 bool QuicConnection::CheckForTimeout() {
   QuicTime now = clock_->ApproximateNow();
   QuicTime time_of_last_packet = std::max(time_of_last_received_packet_,
                                           time_of_last_sent_packet_);
 
   QuicTime::Delta delta = now.Subtract(time_of_last_packet);
   DVLOG(1) << "last packet " << time_of_last_packet.ToDebuggingValue()
            << " now:" << now.ToDebuggingValue()
            << " delta:" << delta.ToMicroseconds();
   if (delta >= timeout_) {
     SendConnectionClose(QUIC_CONNECTION_TIMED_OUT);
     return true;
   }
   helper_->SetTimeoutAlarm(timeout_.Subtract(delta));
   return false;
 }
 
 }  // namespace net