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

net/quic/quic_connection_helper_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/quic_connection_helper.h"
 
 #include <vector>
 
 #include "net/base/net_errors.h"
 #include "net/quic/test_tools/mock_clock.h"
@@ skipping 83 matching lines @@
                                                     writes_.size()));
 
     MockUDPClientSocket* socket =
         new MockUDPClientSocket(socket_data_.get(), net_log_.net_log());
     socket->Connect(IPEndPoint());
     runner_ = new TestTaskRunner(&clock_);
     helper_.reset(new QuicConnectionHelper(runner_.get(), &clock_,
                                            &random_generator_, socket));
     scheduler_ = new testing::StrictMock<MockScheduler>();
     EXPECT_CALL(*scheduler_, TimeUntilSend(_)).
-        WillRepeatedly(testing::Return(QuicTime::Delta()));
+        WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
     connection_.reset(new TestConnection(guid_, IPEndPoint(), helper_.get()));
     connection_->set_visitor(&visitor_);
     connection_->SetScheduler(scheduler_);
   }
 
   // Returns a newly created packet to send kData on stream 1.
   QuicEncryptedPacket* ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number) {
     InitializeHeader(sequence_number);
 
@@ skipping 77 matching lines @@
 
 TEST_F(QuicConnectionHelperTest, GetRandomGenerator) {
   EXPECT_EQ(&random_generator_, helper_->GetRandomGenerator());
 }
 
 TEST_F(QuicConnectionHelperTest, IsSendAlarmSet) {
   EXPECT_FALSE(helper_->IsSendAlarmSet());
 }
 
 TEST_F(QuicConnectionHelperTest, SetSendAlarm) {
-  helper_->SetSendAlarm(QuicTime::Delta());
+  helper_->SetSendAlarm(QuicTime::Delta::Zero());
   EXPECT_TRUE(helper_->IsSendAlarmSet());
 }
 
 TEST_F(QuicConnectionHelperTest, UnregisterSendAlarmIfRegistered) {
-  helper_->SetSendAlarm(QuicTime::Delta());
+  helper_->SetSendAlarm(QuicTime::Delta::Zero());
   helper_->UnregisterSendAlarmIfRegistered() ;
   EXPECT_FALSE(helper_->IsSendAlarmSet());
 }
 
 TEST_F(QuicConnectionHelperTest, TestResend) {
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2));
   Initialize();
 
   QuicTime::Delta kDefaultResendTime = QuicTime::Delta::FromMilliseconds(500);
@@ skipping 92 matching lines @@
   EXPECT_CALL(*scheduler_, TimeUntilSend(false)).WillOnce(testing::Return(
       QuicTime::Delta::FromMicroseconds(1)));
 
   connection_->SendStreamData(1, kData, 0, false, NULL);
   EXPECT_CALL(*scheduler_, SentPacket(1, _, false));
   EXPECT_EQ(1u, connection_->NumQueuedPackets());
 
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
   EXPECT_CALL(*scheduler_, TimeUntilSend(false)).WillOnce(testing::Return(
-      QuicTime::Delta()));
+      QuicTime::Delta::Zero()));
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(testing::Return(true));
   runner_->RunNextTask();
   EXPECT_EQ(0u, connection_->NumQueuedPackets());
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 }  // namespace net