Various QUIC cleanups to sync with internal code.

net/quic/congestion_control/tcp_cubic_sender_test.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/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "net/quic/congestion_control/tcp_cubic_sender.h"
 #include "net/quic/congestion_control/tcp_receiver.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using std::min;
+
 namespace net {
 namespace test {
 
 const uint32 kDefaultWindowTCP = 10 * kDefaultTCPMSS;
 
 // TODO(ianswett): Remove 10000 once b/10075719 is fixed.
 const QuicTcpCongestionWindow kDefaultMaxCongestionWindowTCP = 10000;
 
 class TcpCubicSenderPeer : public TcpCubicSender {
  public:
@@ skipping 20 matching lines @@
         sender_(new TcpCubicSenderPeer(&clock_, true,
                                        kDefaultMaxCongestionWindowTCP)),
         receiver_(new TcpReceiver()),
         sequence_number_(1),
         acked_sequence_number_(0) {
   }
 
   void SendAvailableSendWindow() {
     QuicByteCount bytes_to_send = sender_->AvailableSendWindow();
     while (bytes_to_send > 0) {
-      QuicByteCount bytes_in_packet = std::min(kDefaultTCPMSS, bytes_to_send);
+      QuicByteCount bytes_in_packet = min(kDefaultTCPMSS, bytes_to_send);
       sender_->OnPacketSent(clock_.Now(), sequence_number_++, bytes_in_packet,
                             NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
       bytes_to_send -= bytes_in_packet;
       if (bytes_to_send > 0) {
         EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
                         HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
       }
     }
   }
   // Normal is that TCP acks every other segment.
@@ skipping 323 matching lines @@
   // Lose a later packet and ensure the window decreases.
   sender_->OnPacketLost(sequence_number_, clock_.Now());
   EXPECT_GT(post_loss_window, sender_->GetCongestionWindow());
 }
 
 TEST_F(TcpCubicSenderTest, SendWindowNotAffectedByAcks) {
   QuicByteCount send_window = sender_->AvailableSendWindow();
 
   // Send a packet with no retransmittable data, and ensure that the congestion
   // window doesn't change.
-  QuicByteCount bytes_in_packet = std::min(kDefaultTCPMSS, send_window);
+  QuicByteCount bytes_in_packet = min(kDefaultTCPMSS, send_window);
   sender_->OnPacketSent(clock_.Now(), sequence_number_++, bytes_in_packet,
                         NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA);
   EXPECT_EQ(send_window, sender_->AvailableSendWindow());
 
   // Send a data packet with retransmittable data, and ensure that the
   // congestion window has shrunk.
   sender_->OnPacketSent(clock_.Now(), sequence_number_++, bytes_in_packet,
                         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
   EXPECT_GT(send_window, sender_->AvailableSendWindow());
 }
 
 TEST_F(TcpCubicSenderTest, ConfigureMaxInitialWindow) {
   QuicTcpCongestionWindow congestion_window = sender_->congestion_window();
   QuicConfig config;
   config.set_server_initial_congestion_window(2 * congestion_window,
                                        2 * congestion_window);
   EXPECT_EQ(2 * congestion_window, config.server_initial_congestion_window());
 
   sender_->SetFromConfig(config, true);
   EXPECT_EQ(2 * congestion_window, sender_->congestion_window());
 }
 
 }  // namespace test
 }  // namespace net