Conver DLOG(INFO) to DVLOG(1) in QUIC code.

BUG=258671

Review URL: https://codereview.chromium.org/83123006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@236843 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 39 insertions, 39 deletions

diff --git a/net/quic/congestion_control/channel_estimator.cc b/net/quic/congestion_control/channel_estimator.cc
index 54b96ae..a012b66 100644
--- a/net/quic/congestion_control/channel_estimator.cc
+++ b/net/quic/congestion_control/channel_estimator.cc
@@ -38,7 +38,7 @@ void ChannelEstimator::OnAcknowledgedPacket(
     return;
   }
   if (last_sequence_number_ != sequence_number - 1) {
-    DLOG(INFO) << "Skip channel estimator due to lost packet(s)";
+    DVLOG(1) << "Skip channel estimator due to lost packet(s)";
   } else if (last_send_time_.IsInitialized()) {
     QuicTime::Delta sent_delta = send_time.Subtract(last_send_time_);
     QuicTime::Delta received_delta = receive_time.Subtract(last_receive_time_);
@@ -88,7 +88,7 @@ ChannelEstimateState ChannelEstimator::GetChannelEstimate(
     }
   }
   *estimate = median_bitrate;
-  DLOG(INFO) << "Channel estimate is:"
+  DVLOG(1) << "Channel estimate is:"
              << median_bitrate.ToKBitsPerSecond() << " Kbit/s";
   // If the bitrates in our 25th to 75th percentile window varies more than
   // 25% of the median bitrate we consider the estimate to be uncertain.
diff --git a/net/quic/congestion_control/cubic.cc b/net/quic/congestion_control/cubic.cc
index 16bfd1b..ae6c58b 100644
--- a/net/quic/congestion_control/cubic.cc
+++ b/net/quic/congestion_control/cubic.cc
@@ -149,7 +149,7 @@ QuicTcpCongestionWindow Cubic::CongestionWindowAfterAck(
 
   if (!epoch_.IsInitialized()) {
     // First ACK after a loss event.
-    DLOG(INFO) << "Start of epoch";
+    DVLOG(1) << "Start of epoch";
     epoch_ = current_time;  // Start of epoch.
     acked_packets_count_ = 1;  // Reset count.
     // Reset estimated_tcp_congestion_window_ to be in sync with cubic.
@@ -193,7 +193,7 @@ QuicTcpCongestionWindow Cubic::CongestionWindowAfterAck(
   if (target_congestion_window < estimated_tcp_congestion_window_) {
     target_congestion_window = estimated_tcp_congestion_window_;
   }
-  DLOG(INFO) << "Target congestion_window:" << target_congestion_window;
+  DVLOG(1) << "Target congestion_window:" << target_congestion_window;
   return target_congestion_window;
 }
 
diff --git a/net/quic/congestion_control/fix_rate_sender.cc b/net/quic/congestion_control/fix_rate_sender.cc
index 4da69bd..344423f 100644
--- a/net/quic/congestion_control/fix_rate_sender.cc
+++ b/net/quic/congestion_control/fix_rate_sender.cc
@@ -25,7 +25,7 @@ FixRateSender::FixRateSender(const QuicClock* clock)
       paced_sender_(bitrate_, max_segment_size_),
       data_in_flight_(0),
       latest_rtt_(QuicTime::Delta::Zero()) {
-  DLOG(INFO) << "FixRateSender";
+  DVLOG(1) << "FixRateSender";
 }
 
 FixRateSender::~FixRateSender() {
diff --git a/net/quic/congestion_control/hybrid_slow_start.cc b/net/quic/congestion_control/hybrid_slow_start.cc
index d6edba8..0edb10e 100644
--- a/net/quic/congestion_control/hybrid_slow_start.cc
+++ b/net/quic/congestion_control/hybrid_slow_start.cc
@@ -34,7 +34,7 @@ void HybridSlowStart::Restart() {
 }
 
 void HybridSlowStart::Reset(QuicPacketSequenceNumber end_sequence_number) {
-  DLOG(INFO) << "Reset hybrid slow start @" << end_sequence_number;
+  DVLOG(1) << "Reset hybrid slow start @" << end_sequence_number;
   round_start_ = last_time_ = clock_->ApproximateNow();
   end_sequence_number_ = end_sequence_number;
   current_rtt_ = QuicTime::Delta::Zero();
diff --git a/net/quic/congestion_control/inter_arrival_bitrate_ramp_up.cc b/net/quic/congestion_control/inter_arrival_bitrate_ramp_up.cc
index 2327c5c..2438493 100644
--- a/net/quic/congestion_control/inter_arrival_bitrate_ramp_up.cc
+++ b/net/quic/congestion_control/inter_arrival_bitrate_ramp_up.cc
@@ -58,7 +58,7 @@ void InterArrivalBitrateRampUp::Reset(QuicBandwidth new_rate,
         new_rate.Subtract(available_channel_estimate_));
   }
   current_rate_ = new_rate;
-  DLOG(INFO) << "Reset; time to origin point:" << time_to_origin_point_;
+  DVLOG(1) << "Reset; time to origin point:" << time_to_origin_point_;
 }
 
 void InterArrivalBitrateRampUp::UpdateChannelEstimate(
@@ -79,7 +79,7 @@ void InterArrivalBitrateRampUp::UpdateChannelEstimate(
     channel_estimate_ = channel_estimate;
     halfway_point_ = available_channel_estimate_.Add(
         (channel_estimate_.Subtract(available_channel_estimate_).Scale(0.5f)));
-    DLOG(INFO) << "UpdateChannelEstimate; first usable value:"
+    DVLOG(1) << "UpdateChannelEstimate; first usable value:"
                << channel_estimate.ToKBitsPerSecond() << " Kbits/s";
     return;
   }
@@ -97,7 +97,7 @@ void InterArrivalBitrateRampUp::UpdateChannelEstimate(
   time_to_origin_point_ =
       CalcuateTimeToOriginPoint(channel_estimate_.Subtract(current_rate_));
 
-  DLOG(INFO) << "UpdateChannelEstimate; time to origin point:"
+  DVLOG(1) << "UpdateChannelEstimate; time to origin point:"
              << time_to_origin_point_;
 }
 
@@ -119,7 +119,7 @@ QuicBandwidth InterArrivalBitrateRampUp::GetNewBitrate(
     // Don't go up in bitrate when we are not sending.
     // We need to update the epoch to reflect this state.
     epoch_ = epoch_.Add(time_from_last_update);
-    DLOG(INFO) << "Don't increase; our sent bitrate is:"
+    DVLOG(1) << "Don't increase; our sent bitrate is:"
                << sent_bitrate.ToKBitsPerSecond() << " Kbits/s"
                << " current target rate is:"
                << current_rate_.ToKBitsPerSecond() << " Kbits/s";
@@ -156,7 +156,7 @@ QuicBandwidth InterArrivalBitrateRampUp::GetNewBitrate(
         time_to_origin_point_ =
             CalcuateTimeToOriginPoint(channel_estimate_.Subtract(current_rate));
       }
-      DLOG(INFO) << "Passed the halfway point; time to origin point:"
+      DVLOG(1) << "Passed the halfway point; time to origin point:"
                  << time_to_origin_point_;
     }
     current_rate_ = current_rate;
diff --git a/net/quic/congestion_control/inter_arrival_overuse_detector.cc b/net/quic/congestion_control/inter_arrival_overuse_detector.cc
index a2e3a0f..5e500b3 100644
--- a/net/quic/congestion_control/inter_arrival_overuse_detector.cc
+++ b/net/quic/congestion_control/inter_arrival_overuse_detector.cc
@@ -65,7 +65,7 @@ void InterArrivalOveruseDetector::OnAcknowledgedPacket(
     // This is an old packet and should be ignored.  Note that we are called
     // with a full 64 bit sequence number, even if the wire format may only
     // convey some low-order bits of that number.
-    DLOG(INFO) << "Skip old packet";
+    DVLOG(1) << "Skip old packet";
     return;
   }
 
@@ -156,7 +156,7 @@ void InterArrivalOveruseDetector::DetectDrift(int64 sigma_delta) {
   if (delta_overuse_counter_ > 0 &&
       accumulated_deltas_.ToMicroseconds() > kThresholdAccumulatedDeltasUs) {
     if (delta_estimate_ != kBandwidthDraining) {
-      DLOG(INFO) << "Bandwidth estimate drift: Draining buffer(s) "
+      DVLOG(1) << "Bandwidth estimate drift: Draining buffer(s) "
                  << accumulated_deltas_.ToMilliseconds() << " ms";
       delta_estimate_ = kBandwidthDraining;
     }
@@ -167,7 +167,7 @@ void InterArrivalOveruseDetector::DetectDrift(int64 sigma_delta) {
       (sigma_delta * kDetectDriftStandardDeviation >
           abs(accumulated_deltas_.ToMicroseconds()))) {
     if (delta_estimate_ != kBandwidthSteady) {
-      DLOG(INFO) << "Bandwidth estimate drift: Steady"
+      DVLOG(1) << "Bandwidth estimate drift: Steady"
                  << " mean:" << delta_mean_
                  << " sigma:" << sigma_delta
                  << " offset:" << send_receive_offset_.ToMicroseconds()
@@ -183,7 +183,7 @@ void InterArrivalOveruseDetector::DetectDrift(int64 sigma_delta) {
   if (accumulated_deltas_.ToMicroseconds() > 0) {
     if (delta_estimate_ != kBandwidthOverUsing) {
       ++delta_overuse_counter_;
-      DLOG(INFO) << "Bandwidth estimate drift: Over using"
+      DVLOG(1) << "Bandwidth estimate drift: Over using"
                  << " mean:" << delta_mean_
                  << " sigma:" << sigma_delta
                  << " offset:" << send_receive_offset_.ToMicroseconds()
@@ -194,7 +194,7 @@ void InterArrivalOveruseDetector::DetectDrift(int64 sigma_delta) {
   } else {
     if (delta_estimate_ != kBandwidthUnderUsing) {
       --delta_overuse_counter_;
-      DLOG(INFO) << "Bandwidth estimate drift: Under using"
+      DVLOG(1) << "Bandwidth estimate drift: Under using"
                  << " mean:" << delta_mean_
                  << " sigma:" << sigma_delta
                  << " offset:" << send_receive_offset_.ToMicroseconds()
@@ -219,14 +219,14 @@ void InterArrivalOveruseDetector::DetectSlope(int64 sigma_delta) {
   }
   if (slope_overuse_counter_ > 0 && delta_mean_ > 0) {
     if (slope_estimate_ != kBandwidthDraining) {
-      DLOG(INFO) << "Bandwidth estimate slope: Draining buffer(s)";
+      DVLOG(1) << "Bandwidth estimate slope: Draining buffer(s)";
     }
     slope_estimate_ = kBandwidthDraining;
     return;
   }
   if (sigma_delta > abs(delta_mean_) * kDetectSlopeFactor) {
     if (slope_estimate_ != kBandwidthSteady) {
-      DLOG(INFO) << "Bandwidth estimate slope: Steady"
+      DVLOG(1) << "Bandwidth estimate slope: Steady"
                  << " mean:" << delta_mean_
                  << " sigma:" << sigma_delta;
       slope_overuse_counter_ = 0;
@@ -237,7 +237,7 @@ void InterArrivalOveruseDetector::DetectSlope(int64 sigma_delta) {
   if (delta_mean_ > 0) {
     if (slope_estimate_ != kBandwidthOverUsing) {
       ++slope_overuse_counter_;
-      DLOG(INFO) << "Bandwidth estimate slope: Over using"
+      DVLOG(1) << "Bandwidth estimate slope: Over using"
                  << " mean:" << delta_mean_
                  << " sigma:" << sigma_delta;
       slope_estimate_ = kBandwidthOverUsing;
@@ -245,7 +245,7 @@ void InterArrivalOveruseDetector::DetectSlope(int64 sigma_delta) {
   } else {
     if (slope_estimate_ != kBandwidthUnderUsing) {
       --slope_overuse_counter_;
-      DLOG(INFO) << "Bandwidth estimate slope: Under using"
+      DVLOG(1) << "Bandwidth estimate slope: Under using"
                  << " mean:" << delta_mean_
                  << " sigma:" << sigma_delta;
       slope_estimate_ = kBandwidthUnderUsing;
diff --git a/net/quic/congestion_control/inter_arrival_probe.cc b/net/quic/congestion_control/inter_arrival_probe.cc
index d8fa2db..6d3af32 100644
--- a/net/quic/congestion_control/inter_arrival_probe.cc
+++ b/net/quic/congestion_control/inter_arrival_probe.cc
@@ -114,7 +114,7 @@ void InterArrivalProbe::OnIncomingFeedback(
   }
   estimate_available_ = true;
   available_channel_estimator_.reset(NULL);
-  DLOG(INFO) << "Probe estimate:"
+  DVLOG(1) << "Probe estimate:"
              << available_channel_estimate_.ToKBitsPerSecond()
              << " Kbits/s";
 }
diff --git a/net/quic/congestion_control/inter_arrival_sender.cc b/net/quic/congestion_control/inter_arrival_sender.cc
index 78a46f3..34223d2 100644
--- a/net/quic/congestion_control/inter_arrival_sender.cc
+++ b/net/quic/congestion_control/inter_arrival_sender.cc
@@ -109,7 +109,7 @@ void InterArrivalSender::OnIncomingQuicCongestionFeedbackFrame(
     SentPacketsMap::const_iterator sent_it = sent_packets.find(sequence_number);
     if (sent_it == sent_packets.end()) {
       // Too old data; ignore and move forward.
-      DLOG(INFO) << "Too old feedback move forward, sequence_number:"
+      DVLOG(1) << "Too old feedback move forward, sequence_number:"
                  << sequence_number;
       continue;
     }
@@ -200,7 +200,7 @@ bool InterArrivalSender::ProbingPhase(QuicTime feedback_receive_time) {
 
   current_bandwidth_ = new_rate;
   paced_sender_->UpdateBandwidthEstimate(feedback_receive_time, new_rate);
-  DLOG(INFO) << "Probe result; new rate:"
+  DVLOG(1) << "Probe result; new rate:"
              << new_rate.ToKBitsPerSecond() << " Kbits/s "
              << " available estimate:"
              << available_channel_estimate.ToKBitsPerSecond() << " Kbits/s "
@@ -366,7 +366,7 @@ void InterArrivalSender::EstimateNewBandwidth(QuicTime feedback_receive_time,
   }
   paced_sender_->UpdateBandwidthEstimate(feedback_receive_time,
                                          current_bandwidth_);
-  DLOG(INFO) << "New bandwidth estimate in steady state:"
+  DVLOG(1) << "New bandwidth estimate in steady state:"
              << current_bandwidth_.ToKBitsPerSecond()
              << " Kbits/s";
 }
@@ -378,12 +378,12 @@ void InterArrivalSender::EstimateNewBandwidthAfterDraining(
   if (current_bandwidth_ > back_down_bandwidth_) {
     // Do nothing, our current bandwidth is higher than our bandwidth at the
     // previous back down.
-    DLOG(INFO) << "Current bandwidth estimate is higher than before draining";
+    DVLOG(1) << "Current bandwidth estimate is higher than before draining";
     return;
   }
   if (estimated_congestion_delay >= back_down_congestion_delay_) {
     // Do nothing, our estimated delay have increased.
-    DLOG(INFO) << "Current delay estimate is higher than before draining";
+    DVLOG(1) << "Current delay estimate is higher than before draining";
     return;
   }
   DCHECK(back_down_time_.IsInitialized());
@@ -413,7 +413,7 @@ void InterArrivalSender::EstimateNewBandwidthAfterDraining(
       new_estimate = std::max(current_bandwidth_,
                               current_bandwidth_.Add(draining_rate).Scale(
                                   1.0f - kMinBitrateReduction));
-      DLOG(INFO) << "Draining calculation; current rate:"
+      DVLOG(1) << "Draining calculation; current rate:"
                  << current_bandwidth_.ToKBitsPerSecond() << " Kbits/s "
                  << "draining rate:"
                  << draining_rate.ToKBitsPerSecond() << " Kbits/s "
@@ -449,7 +449,7 @@ void InterArrivalSender::EstimateNewBandwidthAfterDraining(
   state_machine_->IncreaseBitrateDecision();
   paced_sender_->UpdateBandwidthEstimate(feedback_receive_time, new_estimate);
   current_bandwidth_ = new_estimate;
-  DLOG(INFO) << "New bandwidth estimate after draining:"
+  DVLOG(1) << "New bandwidth estimate after draining:"
              << new_estimate.ToKBitsPerSecond() << " Kbits/s";
 }
 
@@ -481,7 +481,7 @@ void InterArrivalSender::EstimateBandwidthAfterDelayEvent(
 
   ResetCurrentBandwidth(feedback_receive_time, new_target_bitrate);
 
-  DLOG(INFO) << "New bandwidth estimate after delay event:"
+  DVLOG(1) << "New bandwidth estimate after delay event:"
       << current_bandwidth_.ToKBitsPerSecond()
       << " Kbits/s min delay bitrate:"
       << min_delay_bitrate.ToKBitsPerSecond()
@@ -494,7 +494,7 @@ void InterArrivalSender::EstimateBandwidthAfterLossEvent(
     QuicTime feedback_receive_time) {
   ResetCurrentBandwidth(feedback_receive_time,
                         current_bandwidth_.Scale(kPacketLossBitrateReduction));
-  DLOG(INFO) << "New bandwidth estimate after loss event:"
+  DVLOG(1) << "New bandwidth estimate after loss event:"
              << current_bandwidth_.ToKBitsPerSecond()
              << " Kbits/s";
 }
diff --git a/net/quic/congestion_control/tcp_cubic_sender.cc b/net/quic/congestion_control/tcp_cubic_sender.cc
index 346cb73..3b15554 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender.cc
@@ -98,7 +98,7 @@ void TcpCubicSender::OnIncomingAck(
   CongestionAvoidance(acked_sequence_number);
   AckAccounting(rtt);
   if (end_sequence_number_ == acked_sequence_number) {
-    DLOG(INFO) << "Start update end sequence number @" << acked_sequence_number;
+    DVLOG(1) << "Start update end sequence number @" << acked_sequence_number;
     update_end_sequence_number_ = true;
   }
 }
@@ -108,7 +108,7 @@ void TcpCubicSender::OnIncomingLoss(QuicPacketSequenceNumber sequence_number,
   // TCP NewReno (RFC6582) says that once a loss occurs, any losses in packets
   // already sent should be treated as a single loss event, since it's expected.
   if (sequence_number <= largest_sent_at_last_cutback_) {
-    DLOG(INFO) << "Ignoring loss for largest_missing:" << sequence_number
+    DVLOG(1) << "Ignoring loss for largest_missing:" << sequence_number
                << " because it was sent prior to the last CWND cutback.";
     return;
   }
@@ -129,7 +129,7 @@ void TcpCubicSender::OnIncomingLoss(QuicPacketSequenceNumber sequence_number,
     congestion_window_ = kMinimumCongestionWindow;
   }
   largest_sent_at_last_cutback_ = largest_sent_sequence_number_;
-  DLOG(INFO) << "Incoming loss; congestion window:" << congestion_window_;
+  DVLOG(1) << "Incoming loss; congestion window:" << congestion_window_;
 }
 
 bool TcpCubicSender::OnPacketSent(QuicTime /*sent_time*/,
@@ -152,7 +152,7 @@ bool TcpCubicSender::OnPacketSent(QuicTime /*sent_time*/,
     end_sequence_number_ = sequence_number;
     if (AvailableSendWindow() == 0) {
       update_end_sequence_number_ = false;
-      DLOG(INFO) << "Stop update end sequence number @" << sequence_number;
+      DVLOG(1) << "Stop update end sequence number @" << sequence_number;
     }
   }
   return true;
@@ -258,7 +258,7 @@ void TcpCubicSender::CongestionAvoidance(QuicPacketSequenceNumber ack) {
       // TCP slow start, exponential growth, increase by one for each ACK.
       congestion_window_++;
     }
-    DLOG(INFO) << "Slow start; congestion window:" << congestion_window_;
+    DVLOG(1) << "Slow start; congestion window:" << congestion_window_;
   } else {
     if (congestion_window_ < max_tcp_congestion_window_) {
       if (reno_) {
@@ -269,12 +269,12 @@ void TcpCubicSender::CongestionAvoidance(QuicPacketSequenceNumber ack) {
         } else {
           congestion_window_count_++;
         }
-        DLOG(INFO) << "Reno; congestion window:" << congestion_window_;
+        DVLOG(1) << "Reno; congestion window:" << congestion_window_;
       } else {
         congestion_window_ = std::min(
             max_tcp_congestion_window_,
             cubic_.CongestionWindowAfterAck(congestion_window_, delay_min_));
-        DLOG(INFO) << "Cubic; congestion window:" << congestion_window_;
+        DVLOG(1) << "Cubic; congestion window:" << congestion_window_;
       }
     }
   }
@@ -287,7 +287,7 @@ void TcpCubicSender::OnRetransmissionTimeout() {
 
 void TcpCubicSender::AckAccounting(QuicTime::Delta rtt) {
   if (rtt.IsInfinite() || rtt.IsZero()) {
-    DLOG(INFO) << "Ignoring rtt, because it's "
+    DVLOG(1) << "Ignoring rtt, because it's "
                << (rtt.IsZero() ? "Zero" : "Infinite");
     return;
   }
@@ -313,7 +313,7 @@ void TcpCubicSender::AckAccounting(QuicTime::Delta rtt) {
     smoothed_rtt_ = QuicTime::Delta::FromMicroseconds(
         kOneMinusAlpha * smoothed_rtt_.ToMicroseconds() +
         kAlpha * rtt.ToMicroseconds());
-    DLOG(INFO) << "Cubic; smoothed_rtt_:" << smoothed_rtt_.ToMicroseconds()
+    DVLOG(1) << "Cubic; smoothed_rtt_:" << smoothed_rtt_.ToMicroseconds()
                << " mean_deviation_:" << mean_deviation_.ToMicroseconds();
   }