Remove stats for recording reno vs cubic mode in internal server's varz.

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 <algorithm>
 #include <cmath>
 
 #include "base/basictypes.h"
@@ skipping 20 matching lines @@
 
 const uint32 kDefaultNumConnections = 2;
 const float kBeta = 0.7f;  // Default Cubic backoff factor.
 // Additional backoff factor when loss occurs in the concave part of the Cubic
 // curve. This additional backoff factor is expected to give up bandwidth to
 // new concurrent flows and speed up convergence.
 const float kBetaLastMax = 0.85f;
 
 }  // namespace
 
-Cubic::Cubic(const QuicClock* clock, QuicConnectionStats* stats)
+Cubic::Cubic(const QuicClock* clock)
     : clock_(clock),
       num_connections_(kDefaultNumConnections),
       epoch_(QuicTime::Zero()),
-      last_update_time_(QuicTime::Zero()),
-      stats_(stats) {
+      last_update_time_(QuicTime::Zero()) {
   Reset();
 }
 
 void Cubic::SetNumConnections(int num_connections) {
   num_connections_ = num_connections;
 }
 
 float Cubic::Alpha() const {
   // TCPFriendly alpha is described in Section 3.3 of the CUBIC paper. Note that
   // beta here is a cwnd multiplier, and is equal to 1-beta from the paper.
@@ skipping 15 matching lines @@
   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;
 }
 
-void Cubic::UpdateCongestionControlStats(QuicPacketCount new_cubic_mode_cwnd,
-                                         QuicPacketCount new_reno_mode_cwnd) {
-  QuicPacketCount highest_new_cwnd = max(new_cubic_mode_cwnd,
-                                         new_reno_mode_cwnd);
-  if (last_congestion_window_ < highest_new_cwnd) {
-    // cwnd will increase to highest_new_cwnd.
-    stats_->cwnd_increase_congestion_avoidance +=
-        highest_new_cwnd - last_congestion_window_;
-    if (new_cubic_mode_cwnd > new_reno_mode_cwnd) {
-      // This cwnd increase is due to cubic mode.
-      stats_->cwnd_increase_cubic_mode +=
-          new_cubic_mode_cwnd - last_congestion_window_;
-    }
-  }
-}
-
 QuicPacketCount Cubic::CongestionWindowAfterPacketLoss(
     QuicPacketCount 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_ =
         static_cast<int>(kBetaLastMax * current_congestion_window);
   } else {
     last_max_congestion_window_ = current_congestion_window;
   }
@@ skipping 56 matching lines @@
     // Update estimated TCP congestion_window.
     QuicPacketCount required_ack_count = static_cast<QuicPacketCount>(
         estimated_tcp_congestion_window_ / Alpha());
     if (acked_packets_count_ < required_ack_count) {
       break;
     }
     acked_packets_count_ -= required_ack_count;
     estimated_tcp_congestion_window_++;
   }
 
-  // Update cubic mode and reno mode stats in QuicConnectionStats.
-  UpdateCongestionControlStats(target_congestion_window,
-                               estimated_tcp_congestion_window_);
-
   // We have a new cubic congestion window.
   last_target_congestion_window_ = target_congestion_window;
 
   // 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_;
   }
 
   DVLOG(1) << "Target congestion_window: " << target_congestion_window;
   return target_congestion_window;
 }
 
 }  // namespace net