Add quic_logging

net/quic/core/quic_sent_packet_manager.cc

 // Copyright 2013 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/core/quic_sent_packet_manager.h"
 
 #include <algorithm>
 #include <string>
 
-#include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/chromium/quic_utils_chromium.h"
 #include "net/quic/core/congestion_control/general_loss_algorithm.h"
 #include "net/quic/core/congestion_control/pacing_sender.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/quic/core/quic_connection_stats.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_pending_retransmission.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_logging.h"
 
 namespace net {
 
 namespace {
 static const int64_t kDefaultRetransmissionTimeMs = 500;
 static const int64_t kMaxRetransmissionTimeMs = 60000;
 // Maximum number of exponential backoffs used for RTO timeouts.
 static const size_t kMaxRetransmissions = 10;
 // Maximum number of packets retransmitted upon an RTO.
 static const size_t kMaxRetransmissionsOnTimeout = 2;
@@ skipping 304 matching lines @@
     if (packet_number > ack_frame.largest_observed) {
       // These packets are still in flight.
       break;
     }
 
     if (!ack_frame.packets.Contains(packet_number)) {
       // Packet is still missing.
       continue;
     }
     // Packet was acked, so remove it from our unacked packet list.
-    DVLOG(1) << ENDPOINT << "Got an ack for packet " << packet_number;
+    QUIC_DVLOG(1) << ENDPOINT << "Got an ack for packet " << packet_number;
     // If data is associated with the most recent transmission of this
     // packet, then inform the caller.
     if (it->in_flight) {
       packets_acked_.push_back(std::make_pair(packet_number, it->bytes_sent));
     } else if (!it->is_unackable) {
       // Packets are marked unackable after they've been acked once.
       largest_newly_acked_ = packet_number;
     }
     MarkPacketHandled(packet_number, &(*it), ack_delay_time);
   }
@@ skipping 293 matching lines @@
   QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it, ++packet_number) {
     // Only retransmit frames which are in flight, and therefore have been sent.
     if (!it->in_flight || it->retransmittable_frames.empty()) {
       continue;
     }
     MarkForRetransmission(packet_number, TLP_RETRANSMISSION);
     return true;
   }
-  DLOG(ERROR)
+  QUIC_DLOG(ERROR)
       << "No retransmittable packets, so RetransmitOldestPacket failed.";
   return false;
 }
 
 void QuicSentPacketManager::RetransmitRtoPackets() {
   QUIC_BUG_IF(pending_timer_transmission_count_ > 0)
       << "Retransmissions already queued:" << pending_timer_transmission_count_;
   // Mark two packets for retransmission.
   QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
@@ skipping 87 matching lines @@
     QUIC_BUG << "Acked packet has zero sent time, largest_observed:"
              << ack_frame.largest_observed;
     return false;
   }
 
   QuicTime::Delta send_delta = ack_receive_time - transmission_info.sent_time;
   const int kMaxSendDeltaSeconds = 30;
   if (!FLAGS_quic_reloadable_flag_quic_allow_large_send_deltas &&
       send_delta.ToSeconds() > kMaxSendDeltaSeconds) {
     // send_delta can be very high if local clock is changed mid-connection.
-    LOG(WARNING) << "Excessive send delta: " << send_delta.ToSeconds()
-                 << ", setting to: " << kMaxSendDeltaSeconds
-                 << " largest_observed:" << ack_frame.largest_observed
-                 << " ack_receive_time:" << ack_receive_time.ToDebuggingValue()
-                 << " sent_time:"
-                 << transmission_info.sent_time.ToDebuggingValue();
+    QUIC_LOG_FIRST_N(WARNING, 10)
+        << "Excessive send delta: " << send_delta.ToSeconds()
+        << ", setting to: " << kMaxSendDeltaSeconds
+        << " largest_observed:" << ack_frame.largest_observed
+        << " ack_receive_time:" << ack_receive_time.ToDebuggingValue()
+        << " sent_time:" << transmission_info.sent_time.ToDebuggingValue();
     return false;
   }
   rtt_stats_.UpdateRtt(send_delta, ack_frame.ack_delay_time, ack_receive_time);
 
   return true;
 }
 
 QuicTime::Delta QuicSentPacketManager::TimeUntilSend(QuicTime now,
                                                      QuicPathId* path_id) {
   QuicTime::Delta delay = QuicTime::Delta::Infinite();
@@ skipping 236 matching lines @@
 
 void QuicSentPacketManager::OnApplicationLimited() {
   send_algorithm_->OnApplicationLimited(unacked_packets_.bytes_in_flight());
 }
 
 const SendAlgorithmInterface* QuicSentPacketManager::GetSendAlgorithm() const {
   return send_algorithm_.get();
 }
 
 }  // namespace net