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

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 "net/quic/congestion_control/quic_send_scheduler.h"
 
 namespace {
 // Constants based on TCP defaults.
@@ skipping 12 matching lines @@
       cubic_(clock),
       reno_(reno),
       congestion_window_count_(0),
       receiver_congestion_window_in_bytes_(kDefaultReceiveWindow),
       last_received_accumulated_number_of_lost_packets_(0),
       bytes_in_flight_(0),
       update_end_sequence_number_(true),
       end_sequence_number_(0),
       congestion_window_(kInitialCongestionWindow),
       slowstart_threshold_(kMaxCongestionWindow),
-      delay_min_() {
+      delay_min_(QuicTime::Delta::Zero()) {
 }
 
 void TcpCubicSender::OnIncomingQuicCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback) {
   if (last_received_accumulated_number_of_lost_packets_ !=
       feedback.tcp.accumulated_number_of_lost_packets) {
     int recovered_lost_packets =
         last_received_accumulated_number_of_lost_packets_ -
         feedback.tcp.accumulated_number_of_lost_packets;
     last_received_accumulated_number_of_lost_packets_ =
@@ skipping 46 matching lines @@
     if (AvailableCongestionWindow() == 0) {
       update_end_sequence_number_ = false;
       DLOG(INFO) << "Stop update end sequence number @" << sequence_number;
     }
   }
 }
 
 QuicTime::Delta TcpCubicSender::TimeUntilSend(bool retransmit) {
   if (retransmit) {
     // For TCP we can always send a retransmit immediately.
-    return QuicTime::Delta();
+    return QuicTime::Delta::Zero();
   }
   if (AvailableCongestionWindow() == 0) {
     return QuicTime::Delta::Infinite();
   }
-  return QuicTime::Delta();
+  return QuicTime::Delta::Zero();
 }
 
 size_t TcpCubicSender::AvailableCongestionWindow() {
   if (bytes_in_flight_ > CongestionWindow()) {
     return 0;
   }
   return CongestionWindow() - bytes_in_flight_;
 }
 
 size_t TcpCubicSender::CongestionWindow() {
   // What's the current congestion window in bytes.
   return std::min(receiver_congestion_window_in_bytes_,
                   static_cast<int>(congestion_window_ * kMaxSegmentSize));
 }
 
 int TcpCubicSender::BandwidthEstimate() {
   // TODO(pwestin): make a long term estimate, based on RTT and loss rate? or
   // instantaneous estimate?
   // Throughput ~= (1/RTT)*sqrt(3/2p)
   return kNoValidEstimate;
 }
 
 void TcpCubicSender::Reset() {
-  delay_min_ = QuicTime::Delta();  // Reset to 0.
+  delay_min_ = QuicTime::Delta::Zero();
   hybrid_slow_start_.Restart();
 }
 
 bool TcpCubicSender::IsCwndLimited() const {
   const size_t congestion_window_bytes = congestion_window_ * kMaxSegmentSize;
   if (bytes_in_flight_ >= congestion_window_bytes) {
     return true;
   }
   const size_t tcp_max_burst = kMaxBurstLength * kMaxSegmentSize;
   const size_t left = congestion_window_bytes - bytes_in_flight_;
@@ skipping 66 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