Landing Recent QUIC changes until Sun May 8 00:39:29 2016 +0000

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 685 matching lines @@
              << " packet_number:" << last_header_.packet_number
              << " stream_id:" << frame.stream_id
              << " received_packets:" << received_packet_manager_.ack_frame();
     CloseConnection(QUIC_UNENCRYPTED_STREAM_DATA,
                     "Unencrypted stream data seen.",
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return false;
   }
   visitor_->OnStreamFrame(frame);
   visitor_->PostProcessAfterData();
-  stats_.stream_bytes_received += frame.frame_length;
+  stats_.stream_bytes_received += frame.data_length;
   should_last_packet_instigate_acks_ = true;
   return connected_;
 }
 
 bool QuicConnection::OnAckFrame(const QuicAckFrame& incoming_ack) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnAckFrame(incoming_ack);
   }
   DVLOG(1) << ENDPOINT << "OnAckFrame: " << incoming_ack;
@@ skipping 579 matching lines @@
   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;
 
-  if (FLAGS_quic_use_socket_timestamp) {
-    time_of_last_received_packet_ = packet.receipt_time();
-    DVLOG(1) << ENDPOINT << "time of last received packet: "
-             << time_of_last_received_packet_.ToDebuggingValue();
-  }
+  time_of_last_received_packet_ = packet.receipt_time();
+  DVLOG(1) << ENDPOINT << "time of last received packet: "
+           << time_of_last_received_packet_.ToDebuggingValue();
 
   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) {
       if (encryption_level_ != ENCRYPTION_FORWARD_SECURE &&
           undecryptable_packets_.size() < max_undecryptable_packets_) {
         QueueUndecryptablePacket(packet);
       } else if (debug_visitor_ != nullptr) {
@@ skipping 38 matching lines @@
     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());
+    if (FLAGS_quic_only_one_sending_alarm) {
+      send_alarm_->Update(clock_->ApproximateNow(), QuicTime::Delta::Zero());
+    } else {
+      resume_writes_alarm_->Set(clock_->ApproximateNow());
+    }
   }
 }
 
 void QuicConnection::WriteIfNotBlocked() {
   if (!writer_->IsWriteBlocked()) {
     OnCanWrite();
   }
 }
 
 void QuicConnection::WriteAndBundleAcksIfNotBlocked() {
@@ skipping 59 matching lines @@
       received_packet_manager_.SetVersion(version());
       visitor_->OnSuccessfulVersionNegotiation(version());
       if (debug_visitor_ != nullptr) {
         debug_visitor_->OnSuccessfulVersionNegotiation(version());
       }
     }
   }
 
   DCHECK_EQ(NEGOTIATED_VERSION, version_negotiation_state_);
 
-  if (!FLAGS_quic_use_socket_timestamp) {
-    time_of_last_received_packet_ = clock_->Now();
-    DVLOG(1) << ENDPOINT << "time of last received packet: "
-             << time_of_last_received_packet_.ToDebuggingValue();
-  }
-
   if (last_size_ > largest_received_packet_size_) {
     largest_received_packet_size_ = last_size_;
   }
 
   if (perspective_ == Perspective::IS_SERVER &&
       encryption_level_ == ENCRYPTION_NONE &&
       last_size_ > packet_generator_.GetCurrentMaxPacketLength()) {
     SetMaxPacketLength(last_size_);
   }
   return true;
@@ skipping 172 matching lines @@
     // If the socket buffers the the data, then the packet should not
     // be queued and sent again, which would result in an unnecessary
     // duplicate packet being sent.  The helper must call OnCanWrite
     // when the write completes, and OnWriteError if an error occurs.
     if (!writer_->IsWriteBlockedDataBuffered()) {
       return false;
     }
   }
   if (result.status != WRITE_STATUS_ERROR && debug_visitor_ != nullptr) {
     // Pass the write result to the visitor.
-    debug_visitor_->OnPacketSent(*packet, packet->original_packet_number,
+    debug_visitor_->OnPacketSent(*packet, packet->original_path_id,
+                                 packet->original_packet_number,
                                  packet->transmission_type, packet_send_time);
   }
   if (packet->transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = packet_send_time;
     if (IsRetransmittable(*packet) == HAS_RETRANSMITTABLE_DATA &&
         last_send_for_timeout_ <= time_of_last_received_packet_) {
       last_send_for_timeout_ = packet_send_time;
     }
   }
   SetPingAlarm();
   MaybeSetMtuAlarm();
   DVLOG(1) << ENDPOINT << "time we began writing last sent packet: "
            << packet_send_time.ToDebuggingValue();
 
   // TODO(ianswett): Change the packet number length and other packet creator
   // options by a more explicit API than setting a struct value directly,
   // perhaps via the NetworkChangeVisitor.
   packet_generator_.UpdateSequenceNumberLength(
       sent_packet_manager_.least_packet_awaited_by_peer(),
       sent_packet_manager_.EstimateMaxPacketsInFlight(max_packet_length()));
 
   bool reset_retransmission_alarm = sent_packet_manager_.OnPacketSent(
-      packet, packet->original_packet_number, packet_send_time,
-      packet->transmission_type, IsRetransmittable(*packet));
+      packet, packet->original_path_id, packet->original_packet_number,
+      packet_send_time, packet->transmission_type, IsRetransmittable(*packet));
 
   if (reset_retransmission_alarm || !retransmission_alarm_->IsSet()) {
     SetRetransmissionAlarm();
   }
 
   stats_.bytes_sent += result.bytes_written;
   ++stats_.packets_sent;
   if (packet->transmission_type != NOT_RETRANSMISSION) {
     stats_.bytes_retransmitted += result.bytes_written;
     ++stats_.packets_retransmitted;
@@ skipping 71 matching lines @@
 }
 
 void QuicConnection::OnUnrecoverableError(QuicErrorCode error,
                                           const string& error_details,
                                           ConnectionCloseSource source) {
   // The packet creator or generator encountered an unrecoverable error: tear
   // down local connection state immediately.
   TearDownLocalConnectionState(error, error_details, source);
 }
 
-void QuicConnection::OnCongestionWindowChange() {
+void QuicConnection::OnCongestionChange() {
   visitor_->OnCongestionWindowChange(clock_->ApproximateNow());
-}
 
-void QuicConnection::OnRttChange() {
   // Uses the connection's smoothed RTT. If zero, uses initial_rtt.
   QuicTime::Delta rtt = sent_packet_manager_.GetRttStats()->smoothed_rtt();
   if (rtt.IsZero()) {
     rtt = QuicTime::Delta::FromMicroseconds(
         sent_packet_manager_.GetRttStats()->initial_rtt_us());
   }
 
   if (debug_visitor_)
     debug_visitor_->OnRttChanged(rtt);
 }
@@ skipping 77 matching lines @@
   }
 
   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.
     CloseConnection(QUIC_TOO_MANY_RTOS, "5 consecutive retransmission timeouts",
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
+  // Cancel the send alarm to ensure TimeUntilSend is re-evaluated.
+  if (FLAGS_quic_only_one_sending_alarm) {
+    send_alarm_->Cancel();
+  }
   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 301 matching lines @@
   QuicTime::Delta ping_timeout = QuicTime::Delta::FromSeconds(kPingTimeoutSecs);
   ping_alarm_->Update(clock_->ApproximateNow().Add(ping_timeout),
                       QuicTime::Delta::FromSeconds(1));
 }
 
 void QuicConnection::SetRetransmissionAlarm() {
   if (delay_setting_retransmission_alarm_) {
     pending_retransmission_alarm_ = true;
     return;
   }
+  // Once the handshake has been confirmed, the retransmission alarm should
+  // never fire before the send alarm.
+  if (FLAGS_quic_only_one_sending_alarm &&
+      sent_packet_manager_.handshake_confirmed() && send_alarm_->IsSet()) {
+    DCHECK(!sent_packet_manager_.GetRetransmissionTime().IsInitialized() ||
+           sent_packet_manager_.GetRetransmissionTime() >=
+               send_alarm_->deadline())
+        << " retransmission_time:"
+        << sent_packet_manager_.GetRetransmissionTime().ToDebuggingValue()
+        << " send_alarm:" << send_alarm_->deadline().ToDebuggingValue();
+    retransmission_alarm_->Cancel();
+    return;
+  }
   QuicTime retransmission_time = sent_packet_manager_.GetRetransmissionTime();
   retransmission_alarm_->Update(retransmission_time,
                                 QuicTime::Delta::FromMilliseconds(1));
 }
 
 void QuicConnection::MaybeSetMtuAlarm() {
   // Do not set the alarm if the target size is less than the current size.
   // This covers the case when |mtu_discovery_target_| is at its default value,
   // zero.
   if (mtu_discovery_target_ <= max_packet_length()) {
@@ skipping 226 matching lines @@
 }
 
 StringPiece QuicConnection::GetCurrentPacket() {
   if (current_packet_data_ == nullptr) {
     return StringPiece();
   }
   return StringPiece(current_packet_data_, last_size_);
 }
 
 }  // namespace net