Remove default constructors for QuicTime and QuicTime::Delta and used static Zero() methods instead…

net/quic/congestion_control/fix_rate_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.
 //
 // Test for FixRate sender and receiver.
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/fix_rate_receiver.h"
 #include "net/quic/congestion_control/fix_rate_sender.h"
@@ skipping 16 matching lines @@
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
   }
   const QuicTime::Delta rtt_;
   MockClock clock_;
   scoped_ptr<FixRateSender> sender_;
   scoped_ptr<FixRateReceiver> receiver_;
 };
 
 TEST_F(FixRateTest, ReceiverAPI) {
   QuicCongestionFeedbackFrame feedback;
-  QuicTime timestamp;
+  QuicTime timestamp(QuicTime::Zero());
   receiver_->SetBitrate(300000);  // Bytes per second.
   receiver_->RecordIncomingPacket(1, 1, timestamp, false);
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   EXPECT_EQ(kFixRate, feedback.type);
   EXPECT_EQ(300000u, feedback.fix_rate.bitrate_in_bytes_per_second);
 }
 
 TEST_F(FixRateTest, SenderAPI) {
   QuicCongestionFeedbackFrame feedback;
   feedback.type = kFixRate;
@@ skipping 20 matching lines @@
 }
 
 TEST_F(FixRateTest, FixRatePacing) {
   const int64 packet_size = 1200;
   const int64 bit_rate = 240000;
   const int64 num_packets = 200;
   QuicCongestionFeedbackFrame feedback;
   receiver_->SetBitrate(240000);  // Bytes per second.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback);
-  QuicTime acc_advance_time;
+  QuicTime acc_advance_time(QuicTime::Zero());
   QuicPacketSequenceNumber sequence_number = 0;
   for (int i = 0; i < num_packets; i += 2) {
     EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
     EXPECT_EQ(kMaxPacketSize * 2, sender_->AvailableCongestionWindow());
     sender_->SentPacket(sequence_number++, packet_size, false);
     EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
     sender_->SentPacket(sequence_number++, packet_size, false);
     QuicTime::Delta advance_time = sender_->TimeUntilSend(false);
     clock_.AdvanceTime(advance_time);
     sender_->OnIncomingAck(sequence_number - 1, packet_size, rtt_);
     sender_->OnIncomingAck(sequence_number - 2, packet_size, rtt_);
     acc_advance_time = acc_advance_time.Add(advance_time);
   }
   EXPECT_EQ(num_packets * packet_size * 1000000 / bit_rate,
             acc_advance_time.ToMicroseconds());
 }
 
 }  // namespace test
 }  // namespace net