Add quic_logging

net/tools/quic/quic_time_wait_list_manager.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/tools/quic/quic_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include <memory>
 
-#include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_server_session_base.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_clock.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 
 using base::StringPiece;
 
 namespace net {
 
 // A very simple alarm that just informs the QuicTimeWaitListManager to clean
 // up old connection_ids. This alarm should be cancelled and deleted before
 // the QuicTimeWaitListManager is deleted.
 class ConnectionIdCleanUpAlarm : public QuicAlarm::Delegate {
@@ skipping 113 matching lines @@
   }
 }
 
 void QuicTimeWaitListManager::ProcessPacket(
     const QuicSocketAddress& server_address,
     const QuicSocketAddress& client_address,
     QuicConnectionId connection_id,
     QuicPacketNumber packet_number,
     const QuicEncryptedPacket& /*packet*/) {
   DCHECK(IsConnectionIdInTimeWait(connection_id));
-  DVLOG(1) << "Processing " << connection_id << " in time wait state.";
+  QUIC_DLOG(INFO) << "Processing " << connection_id << " in time wait state.";
   // TODO(satyamshekhar): Think about handling packets from different client
   // addresses.
   ConnectionIdMap::iterator it = connection_id_map_.find(connection_id);
   DCHECK(it != connection_id_map_.end());
   // Increment the received packet count.
   ConnectionIdData* connection_data = &it->second;
   ++(connection_data->num_packets);
 
   if (!ShouldSendResponse(connection_data->num_packets)) {
     return;
   }
 
   if (!connection_data->termination_packets.empty()) {
     if (connection_data->connection_rejected_statelessly) {
-      DVLOG(3) << "Time wait list sending previous stateless reject response "
-               << "for connection " << connection_id;
+      QUIC_DVLOG(3)
+          << "Time wait list sending previous stateless reject response "
+          << "for connection " << connection_id;
     }
     for (const auto& packet : connection_data->termination_packets) {
       SendOrQueuePacket(base::MakeUnique<QueuedPacket>(
           server_address, client_address, packet->Clone()));
     }
     return;
   }
 
   SendPublicReset(server_address, client_address, connection_id, packet_number);
 }
@@ skipping 57 matching lines @@
   WriteResult result = writer_->WritePacket(
       queued_packet->packet()->data(), queued_packet->packet()->length(),
       queued_packet->server_address().host(), queued_packet->client_address(),
       nullptr);
   if (result.status == WRITE_STATUS_BLOCKED) {
     // If blocked and unbuffered, return false to retry sending.
     DCHECK(writer_->IsWriteBlocked());
     visitor_->OnWriteBlocked(this);
     return writer_->IsWriteBlockedDataBuffered();
   } else if (result.status == WRITE_STATUS_ERROR) {
-    LOG(WARNING) << "Received unknown error while sending reset packet to "
-                 << queued_packet->client_address().ToString() << ": "
-                 << strerror(result.error_code);
+    QUIC_LOG_FIRST_N(WARNING, 1)
+        << "Received unknown error while sending reset packet to "
+        << queued_packet->client_address().ToString() << ": "
+        << strerror(result.error_code);
   }
   return true;
 }
 
 void QuicTimeWaitListManager::SetConnectionIdCleanUpAlarm() {
   QuicTime::Delta next_alarm_interval = QuicTime::Delta::Zero();
   if (!connection_id_map_.empty()) {
     QuicTime oldest_connection_id =
         connection_id_map_.begin()->second.time_added;
     QuicTime now = clock_->ApproximateNow();
     if (now - oldest_connection_id < time_wait_period_) {
       next_alarm_interval = oldest_connection_id + time_wait_period_ - now;
     } else {
-      LOG(ERROR) << "ConnectionId lingered for longer than time_wait_period_";
+      QUIC_LOG(ERROR)
+          << "ConnectionId lingered for longer than time_wait_period_";
     }
   } else {
     // No connection_ids added so none will expire before time_wait_period_.
     next_alarm_interval = time_wait_period_;
   }
 
   connection_id_clean_up_alarm_->Update(
       clock_->ApproximateNow() + next_alarm_interval, QuicTime::Delta::Zero());
 }
 
@@ skipping 42 matching lines @@
       version(version_),
       time_added(time_added_),
       connection_rejected_statelessly(connection_rejected_statelessly) {}
 
 QuicTimeWaitListManager::ConnectionIdData::ConnectionIdData(
     ConnectionIdData&& other) = default;
 
 QuicTimeWaitListManager::ConnectionIdData::~ConnectionIdData() {}
 
 }  // namespace net