LOG(INFO) tidying in net/

net/quic/quic_framer_test.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 <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 181 matching lines @@
   }
 
   virtual ~TestQuicVisitor() {
     STLDeleteElements(&stream_frames_);
     STLDeleteElements(&ack_frames_);
     STLDeleteElements(&congestion_feedback_frames_);
     STLDeleteElements(&fec_data_);
   }
 
   virtual void OnError(QuicFramer* f) OVERRIDE {
-    DLOG(INFO) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
+    DVLOG(0) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
                << " (" << f->error() << ")";
     error_count_++;
   }
 
   virtual void OnPacket() OVERRIDE {}
 
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) OVERRIDE {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
 
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) OVERRIDE {
     version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
   }
 
   virtual void OnRevivedPacket() OVERRIDE {
     revived_packets_++;
   }
 
   virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
-    DLOG(INFO) << "QuicFramer Version Mismatch, version: " << version;
+    DVLOG(0) << "QuicFramer Version Mismatch, version: " << version;
     version_mismatch_++;
     return true;
   }
 
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
     packet_count_++;
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
@@ skipping 2229 matching lines @@
   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
   EXPECT_EQ(GG_UINT64_C(0xABCDEF0123456789),
             visitor_.public_reset_packet_->nonce_proof);
   EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
             visitor_.public_reset_packet_->rejected_sequence_number);
 
   // Now test framing boundaries
   for (size_t i = 0; i < GetPublicResetPacketSize(); ++i) {
     string expected_error;
-    DLOG(INFO) << "iteration: " << i;
+    DVLOG(0) << "iteration: " << i;
     if (i < kGuidOffset) {
       expected_error = "Unable to read public flags.";
       CheckProcessingFails(packet, i, expected_error,
                            QUIC_INVALID_PACKET_HEADER);
     } else if (i < kPublicResetPacketNonceProofOffset) {
       expected_error = "Unable to read GUID.";
       CheckProcessingFails(packet, i, expected_error,
                            QUIC_INVALID_PACKET_HEADER);
     } else if (i < kPublicResetPacketRejectedSequenceNumberOffset) {
       expected_error = "Unable to read nonce proof.";
@@ skipping 1479 matching lines @@
   EXPECT_CALL(visitor, OnConnectionCloseFrame(_)).Times(0);
   EXPECT_CALL(visitor, OnPacketComplete());
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
 }
 
 }  // namespace test
 }  // namespace net