Add quic_logging

net/quic/core/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 "net/quic/core/quic_framer.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
-#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "net/quic/core/crypto/null_decrypter.h"
 #include "net/quic/core/crypto/null_encrypter.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_packets.h"
 #include "net/quic/core/quic_utils.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::string;
 using testing::Return;
 using testing::Truly;
 using testing::_;
 
@@ skipping 164 matching lines @@
         version_mismatch_(0),
         packet_count_(0),
         frame_count_(0),
         complete_packets_(0),
         accept_packet_(true),
         accept_public_header_(true) {}
 
   ~TestQuicVisitor() override {}
 
   void OnError(QuicFramer* f) override {
-    DVLOG(1) << "QuicFramer Error: " << QuicErrorCodeToString(f->error())
-             << " (" << f->error() << ")";
+    QUIC_DLOG(INFO) << "QuicFramer Error: " << QuicErrorCodeToString(f->error())
+                    << " (" << f->error() << ")";
     ++error_count_;
   }
 
   void OnPacket() override {}
 
   void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
 
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) override {
     version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
   }
 
   bool OnProtocolVersionMismatch(QuicVersion version) override {
-    DVLOG(1) << "QuicFramer Version Mismatch, version: " << version;
+    QUIC_DLOG(INFO) << "QuicFramer Version Mismatch, version: " << version;
     ++version_mismatch_;
     return true;
   }
 
   bool OnUnauthenticatedPublicHeader(
       const QuicPacketPublicHeader& header) override {
     public_header_.reset(new QuicPacketPublicHeader(header));
     return accept_public_header_;
   }
 
@@ skipping 126 matching lines @@
   // tens place of the current QUIC version number.
   unsigned char GetQuicVersionDigitTens() {
     return static_cast<unsigned char>('0' + (version_ / 10) % 10);
   }
 
   bool CheckEncryption(QuicPathId path_id,
                        QuicPacketNumber packet_number,
                        QuicPacket* packet) {
     EXPECT_EQ(version_, encrypter_->version_);
     if (packet_number != encrypter_->packet_number_) {
-      LOG(ERROR) << "Encrypted incorrect packet number.  expected "
-                 << packet_number << " actual: " << encrypter_->packet_number_;
+      QUIC_LOG(ERROR) << "Encrypted incorrect packet number.  expected "
+                      << packet_number
+                      << " actual: " << encrypter_->packet_number_;
       return false;
     }
     if (packet->AssociatedData(framer_.version()) !=
         encrypter_->associated_data_) {
-      LOG(ERROR) << "Encrypted incorrect associated data.  expected "
-                 << packet->AssociatedData(framer_.version())
-                 << " actual: " << encrypter_->associated_data_;
+      QUIC_LOG(ERROR) << "Encrypted incorrect associated data.  expected "
+                      << packet->AssociatedData(framer_.version())
+                      << " actual: " << encrypter_->associated_data_;
       return false;
     }
     if (packet->Plaintext(framer_.version()) != encrypter_->plaintext_) {
-      LOG(ERROR) << "Encrypted incorrect plaintext data.  expected "
-                 << packet->Plaintext(framer_.version())
-                 << " actual: " << encrypter_->plaintext_;
+      QUIC_LOG(ERROR) << "Encrypted incorrect plaintext data.  expected "
+                      << packet->Plaintext(framer_.version())
+                      << " actual: " << encrypter_->plaintext_;
       return false;
     }
     return true;
   }
 
   bool CheckDecryption(const QuicEncryptedPacket& encrypted,
                        bool includes_version,
                        bool includes_path_id,
                        bool includes_diversification_nonce) {
     EXPECT_EQ(version_, decrypter_->version_);
     if (visitor_.header_->packet_number != decrypter_->packet_number_) {
-      LOG(ERROR) << "Decrypted incorrect packet number.  expected "
-                 << visitor_.header_->packet_number
-                 << " actual: " << decrypter_->packet_number_;
+      QUIC_LOG(ERROR) << "Decrypted incorrect packet number.  expected "
+                      << visitor_.header_->packet_number
+                      << " actual: " << decrypter_->packet_number_;
       return false;
     }
     if (QuicFramer::GetAssociatedDataFromEncryptedPacket(
             framer_.version(), encrypted, PACKET_8BYTE_CONNECTION_ID,
             includes_version, includes_path_id, includes_diversification_nonce,
             PACKET_6BYTE_PACKET_NUMBER) != decrypter_->associated_data_) {
-      LOG(ERROR) << "Decrypted incorrect associated data.  expected "
-                 << QuicFramer::GetAssociatedDataFromEncryptedPacket(
-                        framer_.version(), encrypted,
-                        PACKET_8BYTE_CONNECTION_ID, includes_version,
-                        includes_path_id, includes_diversification_nonce,
-                        PACKET_6BYTE_PACKET_NUMBER)
-                 << " actual: " << decrypter_->associated_data_;
+      QUIC_LOG(ERROR) << "Decrypted incorrect associated data.  expected "
+                      << QuicFramer::GetAssociatedDataFromEncryptedPacket(
+                             framer_.version(), encrypted,
+                             PACKET_8BYTE_CONNECTION_ID, includes_version,
+                             includes_path_id, includes_diversification_nonce,
+                             PACKET_6BYTE_PACKET_NUMBER)
+                      << " actual: " << decrypter_->associated_data_;
       return false;
     }
     StringPiece ciphertext(
         encrypted.AsStringPiece().substr(GetStartOfEncryptedData(
             framer_.version(), PACKET_8BYTE_CONNECTION_ID, includes_version,
             includes_path_id, includes_diversification_nonce,
             PACKET_6BYTE_PACKET_NUMBER)));
     if (ciphertext != decrypter_->ciphertext_) {
-      LOG(ERROR) << "Decrypted incorrect ciphertext data.  expected "
-                 << ciphertext << " actual: " << decrypter_->ciphertext_;
+      QUIC_LOG(ERROR) << "Decrypted incorrect ciphertext data.  expected "
+                      << ciphertext << " actual: " << decrypter_->ciphertext_;
       return false;
     }
     return true;
   }
 
   char* AsChars(unsigned char* data) { return reinterpret_cast<char*>(data); }
 
   void CheckProcessingFails(unsigned char* packet,
                             size_t len,
                             string expected_error,
@@ skipping 1843 matching lines @@
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
   EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
   EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number);
   EXPECT_EQ(
       IpAddressFamily::IP_UNSPEC,
       visitor_.public_reset_packet_->client_address.host().address_family());
 
   // Now test framing boundaries.
   for (size_t i = 0; i < arraysize(packet); ++i) {
     string expected_error;
-    DVLOG(1) << "iteration: " << i;
+    QUIC_DLOG(INFO) << "iteration: " << i;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
       CheckProcessingFails(packet, i, expected_error,
                            QUIC_INVALID_PACKET_HEADER);
     } else if (i < kPublicResetPacketMessageTagOffset) {
       expected_error = "Unable to read ConnectionId.";
       CheckProcessingFails(packet, i, expected_error,
                            QUIC_INVALID_PACKET_HEADER);
     } else {
       expected_error = "Unable to read reset message.";
@@ skipping 44 matching lines @@
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
   EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
   EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number);
   EXPECT_EQ(
       IpAddressFamily::IP_UNSPEC,
       visitor_.public_reset_packet_->client_address.host().address_family());
 
   // Now test framing boundaries.
   for (size_t i = 0; i < arraysize(packet); ++i) {
     string expected_error;
-    DVLOG(1) << "iteration: " << i;
+    QUIC_DLOG(INFO) << "iteration: " << i;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
       CheckProcessingFails(packet, i, expected_error,
                            QUIC_INVALID_PACKET_HEADER);
     } else if (i < kPublicResetPacketMessageTagOffset) {
       expected_error = "Unable to read ConnectionId.";
       CheckProcessingFails(packet, i, expected_error,
                            QUIC_INVALID_PACKET_HEADER);
     } else {
       expected_error = "Unable to read reset message.";
@@ skipping 86 matching lines @@
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
   EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
   EXPECT_EQ(0u, visitor_.public_reset_packet_->rejected_packet_number);
   EXPECT_EQ("4.31.198.44",
             visitor_.public_reset_packet_->client_address.host().ToString());
   EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port());
 
   // Now test framing boundaries.
   for (size_t i = 0; i < arraysize(packet); ++i) {
     string expected_error;
-    DVLOG(1) << "iteration: " << i;
+    QUIC_DLOG(INFO) << "iteration: " << i;
     if (i < kConnectionIdOffset) {
       expected_error = "Unable to read public flags.";
       CheckProcessingFails(packet, i, expected_error,
                            QUIC_INVALID_PACKET_HEADER);
     } else if (i < kPublicResetPacketMessageTagOffset) {
       expected_error = "Unable to read ConnectionId.";
       CheckProcessingFails(packet, i, expected_error,
                            QUIC_INVALID_PACKET_HEADER);
     } else {
       expected_error = "Unable to read reset message.";
@@ skipping 1717 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicFramerFuzzFunc(packet, arraysize(packet));
 }
 
 }  // namespace test
 }  // namespace net