Land recent QUIC changes.

net/quic/congestion_control/hybrid_slow_start.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/congestion_control/hybrid_slow_start.h"
 
 namespace net {
 
 // Note(pwestin): the magic clamping numbers come from the original code in
 // tcp_cubic.c.
@@ skipping 15 matching lines @@
       current_rtt_(QuicTime::Delta::Zero()) {
 }
 
 void HybridSlowStart::Restart() {
   found_ack_train_ = false;
   found_delay_  = false;
 }
 
 void HybridSlowStart::Reset(QuicPacketSequenceNumber end_sequence_number) {
   DLOG(INFO) << "Reset hybrid slow start @" << end_sequence_number;
-  round_start_ = last_time_ = clock_->Now();
+  round_start_ = last_time_ = clock_->ApproximateNow();
   end_sequence_number_ = end_sequence_number;
   current_rtt_ = QuicTime::Delta::Zero();
   sample_count_ = 0;
   started_ = true;
 }
 
 bool HybridSlowStart::EndOfRound(QuicPacketSequenceNumber ack) {
   // TODO(pwestin): do we need to handle wraparound?
   return end_sequence_number_ <= ack;
 }
 
 void HybridSlowStart::Update(QuicTime::Delta rtt, QuicTime::Delta delay_min) {
   // The original code doesn't invoke this until we hit 16 packet per burst.
   // Since the code handles lower than 16 grecefully and I removed that
   // limit.
   if (found_ack_train_ || found_delay_) {
     return;
   }
-  QuicTime current_time = clock_->Now();
+  QuicTime current_time = clock_->ApproximateNow();
 
   // First detection parameter - ack-train detection.
   // Since slow start burst out packets we can indirectly estimate the inter-
   // arrival time by looking at the arrival time of the ACKs if the ACKs are
   // spread out more then half the minimum RTT packets are beeing spread out
   // more than the capacity.
   // This first trigger will not come into play until we hit roughly 4.8 Mbit/s.
   // TODO(pwestin): we need to make sure our pacing don't trigger this detector.
   if (current_time.Subtract(last_time_).ToMicroseconds() <=
       kHybridStartDelayMinThresholdUs) {
@@ skipping 33 matching lines @@
 bool HybridSlowStart::Exit() {
   // If either one of the two conditions are met we exit from slow start
   // immediately.
   if (found_ack_train_ || found_delay_) {
     return true;
   }
   return false;
 }
 
 }  // namespace net