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

net/quic/congestion_control/cubic.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/cubic.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/time.h"
 
@@ skipping 52 matching lines @@
 const uint32 cube_root_table[] = {
     0,  54,  54,  54, 118, 118, 118, 118, 123, 129, 134, 138, 143, 147, 151,
   156, 157, 161, 164, 168, 170, 173, 176, 179, 181, 185, 187, 190, 192, 194,
   197, 199, 200, 202, 204, 206, 209, 211, 213, 215, 217, 219, 221, 222, 224,
   225, 227, 229, 231, 232, 234, 236, 237, 239, 240, 242, 244, 245, 246, 248,
   250, 251, 252, 254
 };
 }  // namespace
 
 Cubic::Cubic(const QuicClock* clock)
-    : clock_(clock) {
+    : clock_(clock),
+      epoch_(QuicTime::Zero()),
+      last_update_time_(QuicTime::Zero()) {
   Reset();
 }
 
 // Calculate the cube root using a table lookup followed by one Newton-Raphson
 // iteration.
 uint32 Cubic::CubeRoot(uint64 a) {
   uint32 msb = FindMostSignificantBit(a);
   DCHECK_LE(msb, 64u);
 
   if (msb < 7) {
@@ skipping 12 matching lines @@
 
   // Make one Newton-Raphson iteration.
   // Since x has an error (inaccuracy due to the use of fix point) we get a
   // more accurate result by doing x * (x - 1) instead of x * x.
   root = 2 * root + (a / (root * (root - 1)));
   root = ((root * 341) >> 10);  // Div by 3, biased low.
   return static_cast<uint32>(root);
 }
 
 void Cubic::Reset() {
-  epoch_ = QuicTime();  // Reset time.
-  last_update_time_ = QuicTime();  // Reset time.
+  epoch_ = QuicTime::Zero();  // Reset time.
+  last_update_time_ = QuicTime::Zero();  // Reset time.
   last_congestion_window_ = 0;
   last_max_congestion_window_ = 0;
   acked_packets_count_ = 0;
   estimated_tcp_congestion_window_ = 0;
   origin_point_congestion_window_ = 0;
   time_to_origin_point_ = 0;
   last_target_congestion_window_ = 0;
 }
 
 QuicTcpCongestionWindow Cubic::CongestionWindowAfterPacketLoss(
     QuicTcpCongestionWindow current_congestion_window) {
   if (current_congestion_window < last_max_congestion_window_) {
     // We never reached the old max, so assume we are competing with another
     // flow. Use our extra back off factor to allow the other flow to go up.
     last_max_congestion_window_ =
         (kBetaLastMax * current_congestion_window) >> 10;
   } else {
     last_max_congestion_window_ = current_congestion_window;
   }
-  epoch_ = QuicTime();  // Reset time.
+  epoch_ = QuicTime::Zero();  // Reset time.
   return (current_congestion_window * kBeta) >> 10;
 }
 
 QuicTcpCongestionWindow Cubic::CongestionWindowAfterAck(
     QuicTcpCongestionWindow current_congestion_window,
     QuicTime::Delta delay_min) {
   acked_packets_count_ += 1;  // Packets acked.
   QuicTime current_time = clock_->Now();
 
   // Cubic is "independent" of RTT, the update is limited by the time elapsed.
@@ skipping 50 matching lines @@
   // Compute target congestion_window based on cubic target and estimated TCP
   // congestion_window, use highest (fastest).
   if (target_congestion_window < estimated_tcp_congestion_window_) {
     target_congestion_window = estimated_tcp_congestion_window_;
   }
   DLOG(INFO) << "Target congestion_window:" << target_congestion_window;
   return target_congestion_window;
 }
 
 }  // namespace net