Various QUIC cleanups to sync with internal code.

net/quic/congestion_control/tcp_cubic_sender.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/tcp_cubic_sender.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 
 using std::max;
+using std::min;
 
 namespace net {
 
 namespace {
 // Constants based on TCP defaults.
 // The minimum cwnd based on RFC 3782 (TCP NewReno) for cwnd reductions on a
 // fast retransmission.  The cwnd after a timeout is still 1.
 const QuicTcpCongestionWindow kMinimumCongestionWindow = 2;
 const int64 kHybridStartLowWindow = 16;
 const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
@@ skipping 168 matching lines @@
 
 QuicByteCount TcpCubicSender::AvailableSendWindow() {
   if (bytes_in_flight_ > SendWindow()) {
     return 0;
   }
   return SendWindow() - bytes_in_flight_;
 }
 
 QuicByteCount TcpCubicSender::SendWindow() {
   // What's the current send window in bytes.
-  return std::min(receive_window_, GetCongestionWindow());
+  return min(receive_window_, GetCongestionWindow());
 }
 
 QuicBandwidth TcpCubicSender::BandwidthEstimate() const {
   return QuicBandwidth::FromBytesAndTimeDelta(GetCongestionWindow(),
                                               SmoothedRtt());
 }
 
 QuicTime::Delta TcpCubicSender::SmoothedRtt() const {
   if (smoothed_rtt_.IsZero()) {
     return QuicTime::Delta::FromMilliseconds(kInitialRttMs);
@@ skipping 50 matching lines @@
       if (reno_) {
         // Classic Reno congestion avoidance provided for testing.
         if (congestion_window_count_ >= congestion_window_) {
           congestion_window_++;
           congestion_window_count_ = 0;
         } else {
           congestion_window_count_++;
         }
         DVLOG(1) << "Reno; congestion window:" << congestion_window_;
       } else {
-        congestion_window_ = std::min(
+        congestion_window_ = min(
             max_tcp_congestion_window_,
             cubic_.CongestionWindowAfterAck(congestion_window_, delay_min_));
         DVLOG(1) << "Cubic; congestion window:" << congestion_window_;
       }
     }
   }
 }
 
 void TcpCubicSender::OnRetransmissionTimeout() {
   cubic_.Reset();
@@ skipping 40 matching lines @@
       hybrid_slow_start_.Reset(end_sequence_number_);
     }
     hybrid_slow_start_.Update(rtt, delay_min_);
     if (hybrid_slow_start_.Exit()) {
       slowstart_threshold_ = congestion_window_;
     }
   }
 }
 
 }  // namespace net