Downgrade some DLOG(INFO) and DLOG(WARNING) in quic_framer.cc to be DVLOG(1) to make the test log l…

net/quic/core/quic_framer.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/core/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
@@ skipping 524 matching lines @@
 }
 
 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
   QuicDataReader reader(packet.data(), packet.length());
 
   visitor_->OnPacket();
 
   // First parse the public header.
   QuicPacketPublicHeader public_header;
   if (!ProcessPublicHeader(&reader, &public_header)) {
-    DLOG(WARNING) << "Unable to process public header.";
+    DVLOG(1) << "Unable to process public header.";
     DCHECK_NE("", detailed_error_);
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (!visitor_->OnUnauthenticatedPublicHeader(public_header)) {
     // The visitor suppresses further processing of the packet.
     return true;
   }
 
   if (perspective_ == Perspective::IS_SERVER && public_header.version_flag &&
@@ skipping 46 matching lines @@
   return true;
 }
 
 bool QuicFramer::ProcessDataPacket(QuicDataReader* encrypted_reader,
                                    const QuicPacketPublicHeader& public_header,
                                    const QuicEncryptedPacket& packet,
                                    char* decrypted_buffer,
                                    size_t buffer_length) {
   QuicPacketHeader header(public_header);
   if (!ProcessUnauthenticatedHeader(encrypted_reader, &header)) {
-    DLOG(WARNING) << "Unable to process packet header.  Stopping parsing.";
+    DVLOG(1) << "Unable to process packet header.  Stopping parsing.";
     return false;
   }
 
   size_t decrypted_length = 0;
   if (!DecryptPayload(encrypted_reader, header, packet, decrypted_buffer,
                       buffer_length, &decrypted_length)) {
     set_detailed_error("Unable to decrypt payload.");
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
 
   QuicDataReader reader(decrypted_buffer, decrypted_length);
   if (quic_version_ <= QUIC_VERSION_33) {
     if (!ProcessAuthenticatedHeader(&reader, &header)) {
-      DLOG(WARNING) << "Unable to process packet header.  Stopping parsing.";
+      DVLOG(1) << "Unable to process packet header.  Stopping parsing.";
       return false;
     }
   }
 
   // Set the last packet number after we have decrypted the packet
   // so we are confident is not attacker controlled.
   SetLastPacketNumber(header);
 
   if (!visitor_->OnPacketHeader(header)) {
     // The visitor suppresses further processing of the packet.
@@ skipping 1249 matching lines @@
         // Switch the alternative decrypter so that we use it first next time.
         decrypter_.swap(alternative_decrypter_);
         EncryptionLevel level = alternative_decrypter_level_;
         alternative_decrypter_level_ = decrypter_level_;
         decrypter_level_ = level;
       }
     }
   }
 
   if (!success) {
-    DLOG(WARNING) << "DecryptPacket failed for packet_number:"
-                  << header.packet_number;
+    DVLOG(1) << "DecryptPacket failed for packet_number:"
+             << header.packet_number;
     return false;
   }
 
   return true;
 }
 
 size_t QuicFramer::GetAckFrameTimeStampSize(const QuicAckFrame& ack) {
   if (ack.received_packet_times.empty()) {
     return 0;
   }
@@ skipping 665 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net