Various QUIC cleanups to sync with internal code.

net/quic/congestion_control/inter_arrival_sender.cc

 // Copyright (c) 2013 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/inter_arrival_sender.h"
 
+#include <algorithm>
+
+using std::max;
+using std::min;
+
 namespace net {
 
 namespace {
 const int64 kProbeBitrateKBytesPerSecond = 1200;  // 9.6 Mbit/s
 const float kPacketLossBitrateReduction = 0.7f;
 const float kUncertainSafetyMargin = 0.7f;
 const float kMaxBitrateReduction = 0.9f;
 const float kMinBitrateReduction = 0.05f;
 const uint64 kMinBitrateKbit = 10;
 const int kInitialRttMs = 60;  // At a typical RTT 60 ms.
@@ skipping 168 matching lines @@
     case kChannelEstimateUnknown:
       channel_estimate = available_channel_estimate;
       break;
     case kChannelEstimateUncertain:
       channel_estimate = channel_estimate.Scale(kUncertainSafetyMargin);
       break;
     case kChannelEstimateGood:
       // Do nothing.
       break;
   }
-  new_rate = std::max(new_rate,
-                       QuicBandwidth::FromKBitsPerSecond(kMinBitrateKbit));
+  new_rate = max(new_rate,
+                 QuicBandwidth::FromKBitsPerSecond(kMinBitrateKbit));
 
   bitrate_ramp_up_->Reset(new_rate, available_channel_estimate,
                           channel_estimate);
 
   current_bandwidth_ = new_rate;
   paced_sender_->UpdateBandwidthEstimate(feedback_receive_time, new_rate);
   DVLOG(1) << "Probe result; new rate:"
              << new_rate.ToKBitsPerSecond() << " Kbits/s "
              << " available estimate:"
              << available_channel_estimate.ToKBitsPerSecond() << " Kbits/s "
@@ skipping 193 matching lines @@
 
     QuicBandwidth draining_rate = back_down_bandwidth_.Scale(fraction_of_rate);
     QuicBandwidth max_estimated_draining_rate =
         back_down_bandwidth_.Subtract(current_bandwidth_);
     if (draining_rate > max_estimated_draining_rate) {
       // We drained faster than our old send rate, go back to our old rate.
       new_estimate = back_down_bandwidth_;
     } else {
       // Use our drain rate and our kMinBitrateReduction to go to our
       // new estimate.
-      new_estimate = std::max(current_bandwidth_,
-                              current_bandwidth_.Add(draining_rate).Scale(
-                                  1.0f - kMinBitrateReduction));
+      new_estimate = max(current_bandwidth_,
+                         current_bandwidth_.Add(draining_rate).Scale(
+                             1.0f - kMinBitrateReduction));
       DVLOG(1) << "Draining calculation; current rate:"
                  << current_bandwidth_.ToKBitsPerSecond() << " Kbits/s "
                  << "draining rate:"
                  << draining_rate.ToKBitsPerSecond() << " Kbits/s "
                  << "new estimate:"
                  << new_estimate.ToKBitsPerSecond() << " Kbits/s "
                  << " buffer reduction:"
                  << buffer_reduction.ToMicroseconds() << " us "
                  << " elapsed time:"
                  << elapsed_time.ToMicroseconds()  << " us ";
@@ skipping 35 matching lines @@
 
   // To drain all build up buffer within one RTT we need to reduce the
   // bitrate with the following.
   // TODO(pwestin): this is a crude first implementation.
   int64 draining_rate_per_rtt = (estimated_byte_buildup *
       kNumMicrosPerSecond) / SmoothedRtt().ToMicroseconds();
 
   float decrease_factor =
       draining_rate_per_rtt / current_bandwidth_.ToBytesPerSecond();
 
-  decrease_factor = std::max(decrease_factor, kMinBitrateReduction);
-  decrease_factor = std::min(decrease_factor, kMaxBitrateReduction);
+  decrease_factor = max(decrease_factor, kMinBitrateReduction);
+  decrease_factor = min(decrease_factor, kMaxBitrateReduction);
   back_down_congestion_delay_ = estimated_congestion_delay;
   QuicBandwidth new_target_bitrate =
       current_bandwidth_.Scale(1.0f - decrease_factor);
 
   // While in delay sensing mode send at least one packet per RTT.
   QuicBandwidth min_delay_bitrate =
       QuicBandwidth::FromBytesAndTimeDelta(max_segment_size_, SmoothedRtt());
-  new_target_bitrate = std::max(new_target_bitrate, min_delay_bitrate);
+  new_target_bitrate = max(new_target_bitrate, min_delay_bitrate);
 
   ResetCurrentBandwidth(feedback_receive_time, new_target_bitrate);
 
   DVLOG(1) << "New bandwidth estimate after delay event:"
       << current_bandwidth_.ToKBitsPerSecond()
       << " Kbits/s min delay bitrate:"
       << min_delay_bitrate.ToKBitsPerSecond()
       << " Kbits/s RTT:"
       << SmoothedRtt().ToMicroseconds()
       << " us";
 }
 
 void InterArrivalSender::EstimateBandwidthAfterLossEvent(
     QuicTime feedback_receive_time) {
   ResetCurrentBandwidth(feedback_receive_time,
                         current_bandwidth_.Scale(kPacketLossBitrateReduction));
   DVLOG(1) << "New bandwidth estimate after loss event:"
              << current_bandwidth_.ToKBitsPerSecond()
              << " Kbits/s";
 }
 
 void InterArrivalSender::ResetCurrentBandwidth(QuicTime feedback_receive_time,
                                                QuicBandwidth new_rate) {
-  new_rate = std::max(new_rate,
-                      QuicBandwidth::FromKBitsPerSecond(kMinBitrateKbit));
+  new_rate = max(new_rate,
+                 QuicBandwidth::FromKBitsPerSecond(kMinBitrateKbit));
   QuicBandwidth channel_estimate = QuicBandwidth::Zero();
   ChannelEstimateState channel_estimator_state =
       channel_estimator_->GetChannelEstimate(&channel_estimate);
 
   switch (channel_estimator_state) {
     case kChannelEstimateUnknown:
       channel_estimate = current_bandwidth_;
       break;
     case kChannelEstimateUncertain:
       channel_estimate = channel_estimate.Scale(kUncertainSafetyMargin);
       break;
     case kChannelEstimateGood:
       // Do nothing.
       break;
   }
   back_down_time_ = feedback_receive_time;
   back_down_bandwidth_ = current_bandwidth_;
   bitrate_ramp_up_->Reset(new_rate, current_bandwidth_, channel_estimate);
   if (new_rate != current_bandwidth_) {
     current_bandwidth_ = new_rate;
     paced_sender_->UpdateBandwidthEstimate(feedback_receive_time,
                                            current_bandwidth_);
     state_machine_->DecreaseBitrateDecision();
   }
 }
 
 }  // namespace net