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 81 matching lines @@
       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::FromMicroseconds(kDefaultTimeoutUs)),
       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),
       is_server_(is_server),
       connected_(true),
       received_truncated_ack_(false),
       send_ack_in_response_to_packet_(false) {
   helper_->SetConnection(this);
   // TODO(satyamshekhar): Have a smaller timeout till version is negotiated and
   // connection is established (CHLO fully processed).
@@ skipping 31 matching lines @@
     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;
 }
 
 void QuicConnection::OnError(QuicFramer* framer) {
+  if (!connected_) {
+    return;
+  }
   SendConnectionClose(framer->error());
 }
 
 void QuicConnection::OnPacket() {
   // TODO(satyamshekhar): Validate packet before updating the time
   // since it affects the timeout of the connection.
   time_of_last_received_packet_ = clock_->Now();
   DVLOG(1) << "time of last received packet: "
            << time_of_last_received_packet_.ToDebuggingValue();
 
@@ skipping 159 matching lines @@
   last_header_ = header;
   return true;
 }
 
 void QuicConnection::OnFecProtectedPayload(StringPiece payload) {
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   group->Update(last_header_, payload);
 }
 
-void QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) {
+bool QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) {
+  DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnStreamFrame(frame);
   }
   last_stream_frames_.push_back(frame);
+  return true;
 }
 
-void QuicConnection::OnAckFrame(const QuicAckFrame& incoming_ack) {
+bool QuicConnection::OnAckFrame(const QuicAckFrame& incoming_ack) {
+  DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnAckFrame(incoming_ack);
   }
   DVLOG(1) << "OnAckFrame: " << incoming_ack;
 
   if (last_header_.packet_sequence_number <= largest_seen_packet_with_ack_) {
     DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring";
-    return;
+    return true;
   }
   largest_seen_packet_with_ack_ = last_header_.packet_sequence_number;
 
   if (!ValidateAckFrame(incoming_ack)) {
     SendConnectionClose(QUIC_INVALID_ACK_DATA);
-    return;
+    return false;
   }
 
   // TODO(satyamshekhar): Not true if missing_packets.size() was actually
   // kMaxUnackedPackets. This can result in a dead connection if all the
   // missing packets get lost during retransmission. Now the new packets(or the
   // older packets) will not be retransmitted due to RTO
   // since received_truncated_ack_ is true and their sequence_number is >
   // peer_largest_observed_packet. Fix either by resetting it in
   // MaybeRetransmitPacketForRTO or keeping an explicit flag for ack truncation.
   received_truncated_ack_ =
       incoming_ack.received_info.missing_packets.size() >=
       GetMaxUnackedPackets(last_header_.public_header.version_flag);
 
   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()) {
-    return;
+  if (!queued_packets_.empty()) {
+    QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
+        time_of_last_received_packet_, NOT_RETRANSMISSION,
+        HAS_RETRANSMITTABLE_DATA);
+    if (delay.IsZero()) {
+      helper_->UnregisterSendAlarmIfRegistered();
+      if (!write_blocked_) {
+        OnCanWrite();
+      }
+    } else if (!delay.IsInfinite()) {
+      helper_->SetSendAlarm(time_of_last_received_packet_.Add(delay));
+    }
   }
-  QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
-      time_of_last_received_packet_, NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA);
-  if (delay.IsZero()) {
-    helper_->UnregisterSendAlarmIfRegistered();
-    if (!write_blocked_) {
-      OnCanWrite();
-    }
-  } else if (!delay.IsInfinite()) {
-    helper_->SetSendAlarm(time_of_last_received_packet_.Add(delay));
-  }
+  return connected_;
 }
 
-void QuicConnection::OnCongestionFeedbackFrame(
+bool QuicConnection::OnCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback) {
+  DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnCongestionFeedbackFrame(feedback);
   }
   congestion_manager_.OnIncomingQuicCongestionFeedbackFrame(
       feedback, time_of_last_received_packet_);
+  return connected_;
 }
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
   if (incoming_ack.received_info.largest_observed >
       packet_creator_.sequence_number()) {
     DLOG(ERROR) << ENDPOINT << "Peer's observed unsent packet:"
                 << incoming_ack.received_info.largest_observed << " vs "
                 << packet_creator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
@@ skipping 167 matching lines @@
   CloseFecGroupsBefore(incoming_ack.sent_info.least_unacked + 1);
 }
 
 void QuicConnection::OnFecData(const QuicFecData& fec) {
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   group->UpdateFec(last_header_.packet_sequence_number,
                    last_header_.fec_entropy_flag, fec);
 }
 
-void QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
+bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
+  DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnRstStreamFrame(frame);
   }
   DLOG(INFO) << "Stream reset with error "
              << QuicUtils::StreamErrorToString(frame.error_code);
   visitor_->OnRstStream(frame);
+  return connected_;
 }
 
-void QuicConnection::OnConnectionCloseFrame(
+bool QuicConnection::OnConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame) {
+  DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnConnectionCloseFrame(frame);
   }
   DLOG(INFO) << ENDPOINT << "Connection closed with error "
              << QuicUtils::ErrorToString(frame.error_code);
   CloseConnection(frame.error_code, true);
+  return false;
 }
 
-void QuicConnection::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
+bool QuicConnection::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
+  DCHECK(connected_);
   DLOG(INFO) << ENDPOINT << "Go away received with error "
              << QuicUtils::ErrorToString(frame.error_code)
              << " and reason:" << frame.reason_phrase;
   visitor_->OnGoAway(frame);
+  return connected_;
 }
 
 void QuicConnection::OnPacketComplete() {
   // TODO(satyamshekhar): Don't do anything if this packet closed the
   // connection.
   if (!last_packet_revived_) {
     DLOG(INFO) << ENDPOINT << "Got packet "
                << last_header_.packet_sequence_number
                << " with " << last_stream_frames_.size()
                << " stream frames for " << last_header_.public_header.guid;
     congestion_manager_.RecordIncomingPacket(
         last_size_, last_header_.packet_sequence_number,
         time_of_last_received_packet_, last_packet_revived_);
   } else {
     DLOG(INFO) << ENDPOINT << "Got revived packet with "
                << last_stream_frames_.size() << " frames.";
   }
 
   if ((last_stream_frames_.empty() ||
        visitor_->OnPacket(self_address_, peer_address_,
                           last_header_, last_stream_frames_))) {
     RecordPacketReceived(last_header_);
   }
 
   MaybeSendAckInResponseToPacket();
   last_stream_frames_.clear();
 }
 
 QuicAckFrame* QuicConnection::CreateAckFrame() {
+  UpdateOutgoingAck();
+  if (time_largest_observed_ == QuicTime::Zero()) {
+    // We have not received any new higher sequence numbers since we sent our
+    // last ACK.
+    outgoing_ack_.received_info.delta_time_largest_observed =
+        QuicTime::Delta::Infinite();
+  } else {
+    outgoing_ack_.received_info.delta_time_largest_observed =
+        clock_->ApproximateNow().Subtract(time_largest_observed_);
+
+    time_largest_observed_ = QuicTime::Zero();
+  }
   return new QuicAckFrame(outgoing_ack_);
 }
 
 QuicCongestionFeedbackFrame* QuicConnection::CreateFeedbackFrame() {
   return new QuicCongestionFeedbackFrame(outgoing_congestion_feedback_);
 }
 
 void QuicConnection::MaybeSendAckInResponseToPacket() {
   if (send_ack_in_response_to_packet_) {
     SendAck();
@@ skipping 124 matching lines @@
           peer_least_packet_awaiting_ack_),
       header.packet_sequence_number);
 
   if (outgoing_ack_.received_info.largest_observed >
       header.packet_sequence_number) {
     // We've gotten one of the out of order packets - remove it from our
     // "missing packets" list.
     DVLOG(1) << "Removing "  << sequence_number << " from missing list";
     outgoing_ack_.received_info.missing_packets.erase(sequence_number);
   }
-  outgoing_ack_.received_info.largest_observed = max(
-      outgoing_ack_.received_info.largest_observed,
-      header.packet_sequence_number);
-  // TODO(pwestin): update received_info with time_of_last_received_packet_.
+  if (header.packet_sequence_number >
+      outgoing_ack_.received_info.largest_observed) {
+    outgoing_ack_.received_info.largest_observed =
+        header.packet_sequence_number;
+    time_largest_observed_ = time_of_last_received_packet_;
+  }
   entropy_manager_.RecordReceivedPacketEntropyHash(sequence_number,
                                                    header.entropy_hash);
 }
 
 bool QuicConnection::MaybeRetransmitPacketForRTO(
     QuicPacketSequenceNumber sequence_number) {
   DCHECK_EQ(ContainsKey(unacked_packets_, sequence_number),
             ContainsKey(retransmission_map_, sequence_number));
 
   if (!ContainsKey(unacked_packets_, sequence_number)) {
@@ skipping 71 matching lines @@
   // TODO(ianswett): If the packet is a retransmit, the current send alarm may
   // be too long.
   if (write_blocked_ || helper_->IsSendAlarmSet()) {
     return false;
   }
 
   QuicTime now = clock_->Now();
   QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
       now, retransmission, retransmittable);
   if (delay.IsInfinite()) {
-    // TODO(pwestin): should be false but trigger other bugs see b/8350327.
-    return true;
+    return false;
   }
 
   // If the scheduler requires a delay, then we can not send this packet now.
   if (!delay.IsZero()) {
     helper_->SetSendAlarm(now.Add(delay));
     return false;
   }
   return true;
 }
 
@@ skipping 357 matching lines @@
            << " delta:" << delta.ToMicroseconds();
   if (delta >= timeout_) {
     SendConnectionClose(QUIC_CONNECTION_TIMED_OUT);
     return true;
   }
   helper_->SetTimeoutAlarm(timeout_.Subtract(delta));
   return false;
 }
 
 }  // namespace net