QUIC - small formatting changes to keep code in sync with internal source.

net/quic/congestion_control/tcp_cubic_bytes_sender_test.cc

 // Copyright (c) 2015 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_bytes_sender.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 109 matching lines @@
   QuicPacketSequenceNumber sequence_number_;
   QuicPacketSequenceNumber acked_sequence_number_;
   QuicByteCount bytes_in_flight_;
   TransmissionInfo standard_packet_;
 };
 
 TEST_F(TcpCubicBytesSenderTest, SimpleSender) {
   // At startup make sure we are at the default.
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0, HAS_RETRANSMITTABLE_DATA)
-                  .IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0,
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0, HAS_RETRANSMITTABLE_DATA)
-                  .IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0,
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
   // And that window is un-affected.
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
 
   // Fill the send window with data, then verify that we can't send.
   SendAvailableSendWindow();
   EXPECT_FALSE(sender_->TimeUntilSend(clock_.Now(),
                                       sender_->GetCongestionWindow(),
                                       HAS_RETRANSMITTABLE_DATA).IsZero());
 }
 
 TEST_F(TcpCubicBytesSenderTest, ApplicationLimitedSlowStart) {
   // Send exactly 10 packets and ensure the CWND ends at 14 packets.
   const int kNumberOfAcks = 5;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0, HAS_RETRANSMITTABLE_DATA)
-                  .IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0,
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0, HAS_RETRANSMITTABLE_DATA)
-                  .IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0,
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
 
   SendAvailableSendWindow();
   for (int i = 0; i < kNumberOfAcks; ++i) {
     AckNPackets(2);
   }
   QuicByteCount bytes_to_send = sender_->GetCongestionWindow();
   // It's expected 2 acks will arrive when the bytes_in_flight are greater than
   // half the CWND.
   EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * 2, bytes_to_send);
 }
 
 TEST_F(TcpCubicBytesSenderTest, ExponentialSlowStart) {
   const int kNumberOfAcks = 20;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0, HAS_RETRANSMITTABLE_DATA)
-                  .IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0,
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
   EXPECT_FALSE(sender_->HasReliableBandwidthEstimate());
   EXPECT_EQ(QuicBandwidth::Zero(), sender_->BandwidthEstimate());
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0, HAS_RETRANSMITTABLE_DATA)
-                  .IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), 0,
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
 
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
   const QuicByteCount cwnd = sender_->GetCongestionWindow();
   EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * kNumberOfAcks, cwnd);
   EXPECT_FALSE(sender_->HasReliableBandwidthEstimate());
   EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(
@@ skipping 288 matching lines @@
                                     HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(TcpCubicBytesSenderTest, ConfigureMaxInitialWindow) {
   QuicConfig config;
 
   // Verify that kCOPT: kIW10 forces the congestion window to the default of 10.
   QuicTagVector options;
   options.push_back(kIW10);
   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
-  sender_->SetFromConfig(config,
-                         /* is_server= */ Perspective::IS_SERVER,
+  sender_->SetFromConfig(config, Perspective::IS_SERVER,
                          /* using_pacing= */ false);
   EXPECT_EQ(10u * kDefaultTCPMSS, sender_->GetCongestionWindow());
 }
 
 TEST_F(TcpCubicBytesSenderTest, DisableAckTrainDetectionWithPacing) {
   EXPECT_TRUE(sender_->hybrid_slow_start().ack_train_detection());
 
   QuicConfig config;
-  sender_->SetFromConfig(config,
-                         /* is_server= */ Perspective::IS_SERVER,
+  sender_->SetFromConfig(config, Perspective::IS_SERVER,
                          /* using_pacing= */ true);
   EXPECT_FALSE(sender_->hybrid_slow_start().ack_train_detection());
 }
 
 TEST_F(TcpCubicBytesSenderTest, 2ConnectionCongestionAvoidanceAtEndOfRecovery) {
   sender_->SetNumEmulatedConnections(2);
   // Ack 10 packets in 5 acks to raise the CWND to 20.
   const int kNumberOfAcks = 5;
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
@@ skipping 128 matching lines @@
 
   cached_network_params.set_bandwidth_estimate_bytes_per_second(
       (kMinCongestionWindowForBandwidthResumption - 1) * kDefaultTCPMSS);
   EXPECT_TRUE(sender_->ResumeConnectionState(cached_network_params));
   EXPECT_EQ(kMinCongestionWindowForBandwidthResumption * kDefaultTCPMSS,
             sender_->GetCongestionWindow());
 }
 
 }  // namespace test
 }  // namespace net