Add quic_logging

net/tools/quic/quic_dispatcher.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_dispatcher.h"
 
 #include <utility>
 
 #include "base/debug/stack_trace.h"
-#include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
-
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/tools/quic/chlo_extractor.h"
 #include "net/tools/quic/quic_per_connection_packet_writer.h"
 #include "net/tools/quic/quic_simple_server_session.h"
 #include "net/tools/quic/quic_simple_server_session.h"
 #include "net/tools/quic/quic_time_wait_list_manager.h"
 #include "net/tools/quic/stateless_rejector.h"
 
 using base::StringPiece;
 using std::string;
 
@@ skipping 342 matching lines @@
       ProcessChlo();
       break;
     }
     case kFateTimeWait:
       // MaybeRejectStatelessly or OnExpiredPackets might have already added the
       // connection to time wait, in which case it should not be added again.
       if (!FLAGS_quic_reloadable_flag_quic_use_cheap_stateless_rejects ||
           !time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
         // Add this connection_id to the time-wait state, to safely reject
         // future packets.
-        DVLOG(1) << "Adding connection ID " << connection_id
-                 << "to time-wait list.";
+        QUIC_DLOG(INFO) << "Adding connection ID " << connection_id
+                        << "to time-wait list.";
         time_wait_list_manager_->AddConnectionIdToTimeWait(
             connection_id, framer_.version(),
             /*connection_rejected_statelessly=*/false, nullptr);
       }
       DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
       time_wait_list_manager_->ProcessPacket(
           current_server_address_, current_client_address_, connection_id,
           packet_number, *current_packet_);
 
       if (FLAGS_quic_reloadable_flag_enable_async_get_proof) {
@@ skipping 26 matching lines @@
 
   // Checks that return kFateDrop.
 
   // Checks that return kFateTimeWait.
 
   // All packets within a connection sent by a client before receiving a
   // response from the server are required to have the version negotiation flag
   // set.  Since this may be a client continuing a connection we lost track of
   // via server restart, send a rejection to fast-fail the connection.
   if (!header.public_header.version_flag) {
-    DVLOG(1) << "Packet without version arrived for unknown connection ID "
-             << header.public_header.connection_id;
+    QUIC_DLOG(INFO)
+        << "Packet without version arrived for unknown connection ID "
+        << header.public_header.connection_id;
     return kFateTimeWait;
   }
 
   // Check that the sequence number is within the range that the client is
   // expected to send before receiving a response from the server.
   const int kInvalidPacketNumber = 0;
   if (header.packet_number == kInvalidPacketNumber ||
       header.packet_number > kMaxReasonableInitialPacketNumber) {
     return kFateTimeWait;
   }
@@ skipping 85 matching lines @@
                 "not blocked.";
     // Return without adding the connection to the blocked list, to avoid
     // infinite loops in OnCanWrite.
     return;
   }
   write_blocked_list_.insert(std::make_pair(blocked_writer, true));
 }
 
 void QuicDispatcher::OnConnectionAddedToTimeWaitList(
     QuicConnectionId connection_id) {
-  DVLOG(1) << "Connection " << connection_id << " added to time wait list.";
+  QUIC_DLOG(INFO) << "Connection " << connection_id
+                  << " added to time wait list.";
 }
 
 void QuicDispatcher::OnPacket() {}
 
 void QuicDispatcher::OnError(QuicFramer* framer) {
   QuicErrorCode error = framer->error();
   SetLastError(error);
-  DVLOG(1) << QuicErrorCodeToString(error);
+  QUIC_DLOG(INFO) << QuicErrorCodeToString(error);
 }
 
 bool QuicDispatcher::ShouldCreateSessionForUnknownVersion(QuicTag version_tag) {
   return false;
 }
 
 bool QuicDispatcher::OnProtocolVersionMismatch(
     QuicVersion /*received_version*/) {
   QUIC_BUG_IF(!time_wait_list_manager_->IsConnectionIdInTimeWait(
                   current_connection_id_) &&
@@ skipping 99 matching lines @@
   for (; new_sessions_allowed_per_event_loop_ > 0;
        --new_sessions_allowed_per_event_loop_) {
     QuicConnectionId connection_id;
     std::list<BufferedPacket> packets =
         buffered_packets_.DeliverPacketsForNextConnection(&connection_id);
     if (packets.empty()) {
       return;
     }
     QuicSession* session =
         CreateQuicSession(connection_id, packets.front().client_address);
-    DVLOG(1) << "Created new session for " << connection_id;
+    QUIC_DLOG(INFO) << "Created new session for " << connection_id;
     session_map_.insert(
         std::make_pair(connection_id, base::WrapUnique(session)));
     DeliverPacketsToSession(packets, session);
   }
 }
 
 bool QuicDispatcher::HasChlosBuffered() const {
   return buffered_packets_.HasChlosBuffered();
 }
 
 bool QuicDispatcher::ShouldCreateOrBufferPacketForConnection(
     QuicConnectionId connection_id) {
   VLOG(1) << "Received packet from new connection " << connection_id;
   return true;
 }
 
 // Return true if there is any packet buffered in the store.
 bool QuicDispatcher::HasBufferedPackets(QuicConnectionId connection_id) {
   return buffered_packets_.HasBufferedPackets(connection_id);
 }
 
 void QuicDispatcher::OnBufferPacketFailure(EnqueuePacketResult result,
                                            QuicConnectionId connection_id) {
-  DVLOG(1) << "Fail to buffer packet on connection " << connection_id
-           << " because of " << result;
+  QUIC_DLOG(INFO) << "Fail to buffer packet on connection " << connection_id
+                  << " because of " << result;
 }
 
 void QuicDispatcher::OnConnectionRejectedStatelessly() {}
 
 void QuicDispatcher::OnConnectionClosedStatelessly(QuicErrorCode error) {}
 
 bool QuicDispatcher::ShouldAttemptCheapStatelessRejection() {
   return true;
 }
 
@@ skipping 46 matching lines @@
           !FLAGS_quic_reloadable_flag_quic_create_session_after_insertion &&
           is_new_connection) {
         ShouldCreateOrBufferPacketForConnection(current_connection_id_);
       }
     }
     return;
   }
   // Creates a new session and process all buffered packets for this connection.
   QuicSession* session =
       CreateQuicSession(current_connection_id_, current_client_address_);
-  DVLOG(1) << "Created new session for " << current_connection_id_;
+  QUIC_DLOG(INFO) << "Created new session for " << current_connection_id_;
   session_map_.insert(
       std::make_pair(current_connection_id_, base::WrapUnique(session)));
   std::list<BufferedPacket> packets =
       buffered_packets_.DeliverPackets(current_connection_id_);
   // Check if CHLO is the first packet arrived on this connection.
   if (!FLAGS_quic_reloadable_flag_quic_create_session_after_insertion &&
       packets.empty()) {
     ShouldCreateOrBufferPacketForConnection(current_connection_id_);
   }
   // Process CHLO at first.
@@ skipping 229 matching lines @@
 void QuicDispatcher::DeliverPacketsToSession(
     const std::list<BufferedPacket>& packets,
     QuicSession* session) {
   for (const BufferedPacket& packet : packets) {
     session->ProcessUdpPacket(packet.server_address, packet.client_address,
                               *(packet.packet));
   }
 }
 
 }  // namespace net