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"
@@ skipping 66 matching lines @@
       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),
       write_blocked_(false),
       debug_visitor_(NULL),
       packet_creator_(guid_, &framer_, random_generator_, is_server),
       packet_generator_(this, &packet_creator_),
-      timeout_(QuicTime::Delta::FromSeconds(kDefaultInitialTimeoutSecs)),
+      idle_network_timeout_(
+          QuicTime::Delta::FromSeconds(kDefaultInitialTimeoutSecs)),
+      overall_connection_timeout_(QuicTime::Delta::Infinite()),
+      creation_time_(clock_->ApproximateNow()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_packet_(clock_->ApproximateNow()),
       time_largest_observed_(QuicTime::Zero()),
       congestion_manager_(clock_, kTCP),
       version_negotiation_state_(START_NEGOTIATION),
       quic_version_(kQuicVersion1),
       max_packets_per_retransmission_alarm_(kMaxPacketsPerRetransmissionAlarm),
       is_server_(is_server),
       connected_(true),
       received_truncated_ack_(false),
       send_ack_in_response_to_packet_(false),
       address_migrating_(false) {
   helper_->SetConnection(this);
-  helper_->SetTimeoutAlarm(timeout_);
+  helper_->SetTimeoutAlarm(idle_network_timeout_);
   framer_.set_visitor(this);
   framer_.set_entropy_calculator(&entropy_manager_);
   outgoing_ack_.sent_info.least_unacked = 0;
   outgoing_ack_.sent_info.entropy_hash = 0;
   outgoing_ack_.received_info.largest_observed = 0;
   outgoing_ack_.received_info.entropy_hash = 0;
 
   /*
   if (FLAGS_fake_packet_loss_percentage > 0) {
     int32 seed = RandomBase::WeakSeed32();
     LOG(INFO) << ENDPOINT << "Seeding packet loss with " << seed;
     random_.reset(new MTRandom(seed));
   }
   */
 }
 
 QuicConnection::~QuicConnection() {
   STLDeleteValues(&unacked_packets_);
   STLDeleteValues(&group_map_);
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
     delete it->packet;
   }
+  LOG(ERROR) << "Quic connection " << write_blocked_;
 }
 
 bool QuicConnection::SelectMutualVersion(
     const QuicTagVector& available_versions) {
   // TODO(satyamshekhar): Make this generic.
   if (std::find(available_versions.begin(), available_versions.end(),
                 kQuicVersion1) == available_versions.end()) {
     return false;
   }
 
@@ skipping 171 matching lines @@
 
   DCHECK_EQ(NEGOTIATED_VERSION, version_negotiation_state_);
 
   --stats_.packets_dropped;
   DVLOG(1) << ENDPOINT << "Received packet header: " << header;
   last_header_ = header;
   return true;
 }
 
 void QuicConnection::OnFecProtectedPayload(StringPiece payload) {
+  DCHECK_EQ(IN_FEC_GROUP, last_header_.is_in_fec_group);
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   if (group != NULL) {
     group->Update(last_header_, payload);
   }
 }
 
 bool QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_) {
@@ skipping 16 matching lines @@
   }
   largest_seen_packet_with_ack_ = last_header_.packet_sequence_number;
 
   if (!ValidateAckFrame(incoming_ack)) {
     SendConnectionClose(QUIC_INVALID_ACK_DATA);
     return false;
   }
 
   received_truncated_ack_ =
       incoming_ack.received_info.missing_packets.size() >=
-      QuicFramer::GetMaxUnackedPackets(last_header_.public_header.version_flag);
+      QuicFramer::GetMaxUnackedPackets(last_header_);
 
   UpdatePacketInformationReceivedByPeer(incoming_ack);
   UpdatePacketInformationSentByPeer(incoming_ack);
   congestion_manager_.OnIncomingAckFrame(incoming_ack,
                                          time_of_last_received_packet_);
 
   // Now the we have received an ack, we might be able to send queued packets.
   if (!queued_packets_.empty()) {
     QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
         time_of_last_received_packet_, NOT_RETRANSMISSION,
@@ skipping 36 matching lines @@
     DLOG(ERROR) << ENDPOINT << "Peer's largest_observed packet decreased:"
                 << incoming_ack.received_info.largest_observed << " vs "
                 << peer_largest_observed_packet_;
     // We got an error for data we have not sent.  Error out.
     return false;
   }
 
   // We can't have too many unacked packets, or our ack frames go over
   // kMaxPacketSize.
   DCHECK_LE(incoming_ack.received_info.missing_packets.size(),
-            QuicFramer::GetMaxUnackedPackets(
-                last_header_.public_header.version_flag));
+            QuicFramer::GetMaxUnackedPackets(last_header_));
 
   if (incoming_ack.sent_info.least_unacked < peer_least_packet_awaiting_ack_) {
     DLOG(ERROR) << ENDPOINT << "Peer's sent low least_unacked: "
                 << incoming_ack.sent_info.least_unacked
                 << " vs " << peer_least_packet_awaiting_ack_;
     // We never process old ack frames, so this number should only increase.
     return false;
   }
 
   if (incoming_ack.sent_info.least_unacked >
@@ skipping 137 matching lines @@
         peer_least_packet_awaiting_ack_);
   }
   DCHECK(outgoing_ack_.received_info.missing_packets.empty() ||
          *outgoing_ack_.received_info.missing_packets.begin() >=
              peer_least_packet_awaiting_ack_);
   // Possibly close any FecGroups which are now irrelevant
   CloseFecGroupsBefore(incoming_ack.sent_info.least_unacked + 1);
 }
 
 void QuicConnection::OnFecData(const QuicFecData& fec) {
+  DCHECK_EQ(IN_FEC_GROUP, last_header_.is_in_fec_group);
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   if (group != NULL) {
     group->UpdateFec(last_header_.packet_sequence_number,
-                     last_header_.fec_entropy_flag, fec);
+                     last_header_.entropy_flag, fec);
   }
 }
 
 bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnRstStreamFrame(frame);
   }
   DLOG(INFO) << ENDPOINT << "Stream reset with error "
              << QuicUtils::StreamErrorToString(frame.error_code);
@@ skipping 212 matching lines @@
       // Continue, because some queued packets may still be writable.
       // This can happen if a retransmit send fail.
       ++packet_iterator;
     }
   }
 
   return !write_blocked_;
 }
 
 void QuicConnection::RecordPacketReceived(const QuicPacketHeader& header) {
-  DLOG(INFO) << ENDPOINT << "Recording received packet: "
-             << header.packet_sequence_number;
   QuicPacketSequenceNumber sequence_number = header.packet_sequence_number;
   DCHECK(IsAwaitingPacket(outgoing_ack_.received_info, sequence_number));
 
   InsertMissingPacketsBetween(
       &outgoing_ack_.received_info,
       max(outgoing_ack_.received_info.largest_observed + 1,
           peer_least_packet_awaiting_ack_),
       header.packet_sequence_number);
 
   if (outgoing_ack_.received_info.largest_observed >
@@ skipping 435 matching lines @@
   if (group == NULL || !group->CanRevive()) {
     return;
   }
   QuicPacketHeader revived_header;
   char revived_payload[kMaxPacketSize];
   size_t len = group->Revive(&revived_header, revived_payload, kMaxPacketSize);
   revived_header.public_header.guid = guid_;
   revived_header.public_header.version_flag = false;
   revived_header.public_header.reset_flag = false;
   revived_header.fec_flag = false;
-  revived_header.fec_group = kNoFecOffset;
+  revived_header.is_in_fec_group = NOT_IN_FEC_GROUP;
+  revived_header.fec_group = 0;
   group_map_.erase(last_header_.fec_group);
   delete group;
 
   last_packet_revived_ = true;
   if (debug_visitor_) {
     debug_visitor_->OnRevivedPacket(revived_header,
                                     StringPiece(revived_payload, len));
   }
 
   ++stats_.packets_revived;
@@ skipping 89 matching lines @@
     DCHECK(!fec_group->CanRevive());
     FecGroupMap::iterator next = it;
     ++next;
     group_map_.erase(it);
     delete fec_group;
     it = next;
   }
 }
 
 bool QuicConnection::HasQueuedData() const {
-  return !queued_packets_.empty() || packet_generator_.HasQueuedData();
+  return !queued_packets_.empty() || packet_generator_.HasQueuedFrames();
 }
 
-void QuicConnection::SetConnectionTimeout(QuicTime::Delta timeout) {
-  timeout_ = timeout;
-  CheckForTimeout();
+void QuicConnection::SetIdleNetworkTimeout(QuicTime::Delta timeout) {
+  // if (timeout < idle_network_timeout_) {
+    idle_network_timeout_ = timeout;
+    CheckForTimeout();
+  // } else {
+  //   idle_network_timeout_ = timeout;
+  // }
+}
+
+void QuicConnection::SetOverallConnectionTimeout(QuicTime::Delta timeout) {
+  // if (timeout < overall_connection_timeout_) {
+    overall_connection_timeout_ = timeout;
+    CheckForTimeout();
+  // } else {
+  //   overall_connection_timeout_ = timeout;
+  // }
 }
 
 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) << ENDPOINT << "last packet "
            << time_of_last_packet.ToDebuggingValue()
            << " now:" << now.ToDebuggingValue()
-           << " delta:" << delta.ToMicroseconds();
-  if (delta >= timeout_) {
+           << " delta:" << delta.ToMicroseconds()
+           << " network_timeout: " << idle_network_timeout_.ToMicroseconds();
+  if (delta >= idle_network_timeout_) {
+    DVLOG(1) << ENDPOINT << "Connection timedout due to no network activity.";
     SendConnectionClose(QUIC_CONNECTION_TIMED_OUT);
     return true;
   }
-  helper_->SetTimeoutAlarm(timeout_.Subtract(delta));
+
+  // Next timeout delta.
+  QuicTime::Delta timeout = idle_network_timeout_.Subtract(delta);
+
+  if (!overall_connection_timeout_.IsInfinite()) {
+    QuicTime::Delta connected_time = now.Subtract(creation_time_);
+    DVLOG(1) << ENDPOINT << "connection time: "
+             << connected_time.ToMilliseconds() << " overall timeout: "
+             << overall_connection_timeout_.ToMilliseconds();
+    if (connected_time >= overall_connection_timeout_) {
+      DVLOG(1) << ENDPOINT <<
+          "Connection timedout due to overall connection timeout.";
+      SendConnectionClose(QUIC_CONNECTION_TIMED_OUT);
+      return true;
+    }
+
+    // Take the min timeout.
+    QuicTime::Delta connection_timeout =
+        overall_connection_timeout_.Subtract(connected_time);
+    if (connection_timeout < timeout) {
+      timeout = connection_timeout;
+    }
+  }
+
+  helper_->SetTimeoutAlarm(timeout);
   return false;
 }
 
 }  // namespace net