Landing Recent QUIC changes until 7/18/2016 11:21:53 UTC

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 1073 matching lines @@
     }
 
     // If there are new missing packets to report, send an ack immediately.
     if (received_packet_manager_.HasNewMissingPackets()) {
       if (ack_mode_ == ACK_DECIMATION_WITH_REORDERING) {
         // Wait the minimum of an eighth min_rtt and the existing ack time.
         QuicTime ack_time =
             clock_->ApproximateNow() +
             0.125 * sent_packet_manager_->GetRttStats()->min_rtt();
         if (!ack_alarm_->IsSet() || ack_alarm_->deadline() > ack_time) {
-          ack_alarm_->Cancel();
-          ack_alarm_->Set(ack_time);
+          ack_alarm_->Update(ack_time, QuicTime::Delta::Zero());
         }
       } else {
         ack_queued_ = true;
       }
     }
   }
 
   if (ack_queued_) {
     ack_alarm_->Cancel();
   }
@@ skipping 45 matching lines @@
   return sent_packet_manager_->GetLeastUnacked(path_id);
 }
 
 void QuicConnection::MaybeSendInResponseToPacket() {
   if (!connected_) {
     return;
   }
   // Now that we have received an ack, we might be able to send packets which
   // are queued locally, or drain streams which are blocked.
   if (defer_send_in_response_to_packets_) {
-    send_alarm_->Cancel();
-    send_alarm_->Set(clock_->ApproximateNow());
+    send_alarm_->Update(clock_->ApproximateNow(), QuicTime::Delta::Zero());
   } else {
     WriteAndBundleAcksIfNotBlocked();
   }
 }
 
 void QuicConnection::SendVersionNegotiationPacket() {
   // TODO(alyssar): implement zero server state negotiation.
   pending_version_negotiation_packet_ = true;
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
@@ skipping 654 matching lines @@
     SetMaxPacketLength(packet_size);
   }
 }
 
 void QuicConnection::OnHandshakeComplete() {
   sent_packet_manager_->SetHandshakeConfirmed();
   // The client should immediately ack the SHLO to confirm the handshake is
   // complete with the server.
   if (perspective_ == Perspective::IS_CLIENT && !ack_queued_ &&
       ack_frame_updated()) {
-    ack_alarm_->Cancel();
-    ack_alarm_->Set(clock_->ApproximateNow());
+    ack_alarm_->Update(clock_->ApproximateNow(), QuicTime::Delta::Zero());
   }
 }
 
 void QuicConnection::SendOrQueuePacket(SerializedPacket* packet) {
   // The caller of this function is responsible for checking CanWrite().
   if (packet->encrypted_buffer == nullptr) {
     QUIC_BUG << "packet.encrypted_buffer == nullptr in to SendOrQueuePacket";
     return;
   }
   if (version() <= QUIC_VERSION_33) {
@@ skipping 348 matching lines @@
 void QuicConnection::SetTimeoutAlarm() {
   QuicTime time_of_last_packet =
       max(time_of_last_received_packet_, time_of_last_sent_new_packet_);
 
   QuicTime deadline = time_of_last_packet + idle_network_timeout_;
   if (!handshake_timeout_.IsInfinite()) {
     deadline =
         min(deadline, stats_.connection_creation_time + handshake_timeout_);
   }
 
-  timeout_alarm_->Cancel();
-  timeout_alarm_->Set(deadline);
+  timeout_alarm_->Update(deadline, QuicTime::Delta::Zero());
 }
 
 void QuicConnection::SetPingAlarm() {
   if (perspective_ == Perspective::IS_SERVER) {
     // Only clients send pings.
     return;
   }
   if (!visitor_->HasOpenDynamicStreams()) {
     ping_alarm_->Cancel();
     // Don't send a ping unless there are open streams.
@@ skipping 294 matching lines @@
 // the sender and a signaling mechanism -- if the sender uses a
 // different MinRTO, we may get spurious retransmissions. May not have
 // any benefits, but if the delayed ack becomes a significant source
 // of (likely, tail) latency, then consider such a mechanism.
 const QuicTime::Delta QuicConnection::DelayedAckTime() {
   return QuicTime::Delta::FromMilliseconds(
       min(kMaxDelayedAckTimeMs, kMinRetransmissionTimeMs / 2));
 }
 
 }  // namespace net