Add quic_logging

net/quic/test_tools/fake_proof_source.cc

 // Copyright (c) 2016 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/platform/api/quic_logging.h"
 #include "net/quic/test_tools/fake_proof_source.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 
 using std::string;
 
 namespace net {
 namespace test {
 
 FakeProofSource::FakeProofSource()
     : delegate_(CryptoTestUtils::ProofSourceForTesting()) {}
@@ skipping 28 matching lines @@
 
 bool FakeProofSource::GetProof(
     const QuicSocketAddress& server_address,
     const string& hostname,
     const string& server_config,
     QuicVersion quic_version,
     StringPiece chlo_hash,
     const QuicTagVector& connection_options,
     QuicReferenceCountedPointer<ProofSource::Chain>* out_chain,
     QuicCryptoProof* out_proof) {
-  LOG(WARNING) << "Synchronous GetProof called";
+  QUIC_LOG(WARNING) << "Synchronous GetProof called";
   return delegate_->GetProof(server_address, hostname, server_config,
                              quic_version, chlo_hash, connection_options,
                              out_chain, out_proof);
 }
 
 void FakeProofSource::GetProof(
     const QuicSocketAddress& server_address,
     const string& hostname,
     const string& server_config,
     QuicVersion quic_version,
     StringPiece chlo_hash,
     const QuicTagVector& connection_options,
     std::unique_ptr<ProofSource::Callback> callback) {
   if (!active_) {
     QuicReferenceCountedPointer<Chain> chain;
     QuicCryptoProof proof;
     const bool ok =
         GetProof(server_address, hostname, server_config, quic_version,
                  chlo_hash, connection_options, &chain, &proof);
     callback->Run(ok, chain, proof, /* details = */ nullptr);
     return;
   }
 
-  LOG(WARNING) << "Asynchronous GetProof called";
+  QUIC_LOG(WARNING) << "Asynchronous GetProof called";
   params_.push_back(Params{server_address, hostname, server_config,
                            quic_version, chlo_hash.as_string(),
                            connection_options, std::move(callback)});
 }
 
 int FakeProofSource::NumPendingCallbacks() const {
   return params_.size();
 }
 
 void FakeProofSource::InvokePendingCallback(int n) {
   CHECK(NumPendingCallbacks() > n);
 
   const Params& params = params_[n];
 
   QuicReferenceCountedPointer<ProofSource::Chain> chain;
   QuicCryptoProof proof;
   const bool ok = delegate_->GetProof(
       params.server_address, params.hostname, params.server_config,
       params.quic_version, params.chlo_hash, params.connection_options, &chain,
       &proof);
 
   params.callback->Run(ok, chain, proof, /* details = */ nullptr);
   auto it = params_.begin() + n;
   params_.erase(it);
 }
 
 }  // namespace test
 }  // namespace net