Add quic_logging

net/quic/core/quic_crypto_client_stream.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_crypto_client_stream.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/crypto_utils.h"
 #include "net/quic/core/crypto/null_encrypter.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_session.h"
 #include "net/quic/core/quic_utils.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 
 using std::string;
 
 namespace net {
 
 const int QuicCryptoClientStream::kMaxClientHellos;
 
 QuicCryptoClientStreamBase::QuicCryptoClientStreamBase(QuicSession* session)
     : QuicCryptoStream(session) {}
@@ skipping 269 matching lines @@
   if (!cached->IsComplete(session()->connection()->clock()->WallNow())) {
     crypto_config_->FillInchoateClientHello(
         server_id_, session()->connection()->supported_versions().front(),
         cached, session()->connection()->random_generator(),
         /* demand_x509_proof= */ true, crypto_negotiated_params_, &out);
     // Pad the inchoate client hello to fill up a packet.
     const QuicByteCount kFramingOverhead = 50;  // A rough estimate.
     const QuicByteCount max_packet_size =
         session()->connection()->max_packet_length();
     if (max_packet_size <= kFramingOverhead) {
-      DLOG(DFATAL) << "max_packet_length (" << max_packet_size
-                   << ") has no room for framing overhead.";
+      QUIC_DLOG(DFATAL) << "max_packet_length (" << max_packet_size
+                        << ") has no room for framing overhead.";
       CloseConnectionWithDetails(QUIC_INTERNAL_ERROR,
                                  "max_packet_size too smalll");
       return;
     }
     if (kClientHelloMinimumSize > max_packet_size - kFramingOverhead) {
-      DLOG(DFATAL) << "Client hello won't fit in a single packet.";
+      QUIC_DLOG(DFATAL) << "Client hello won't fit in a single packet.";
       CloseConnectionWithDetails(QUIC_INTERNAL_ERROR, "CHLO too large");
       return;
     }
     // TODO(rch): Remove this when we remove:
     // FLAGS_quic_use_chlo_packet_size
     out.set_minimum_size(
         static_cast<size_t>(max_packet_size - kFramingOverhead));
     next_state_ = STATE_RECV_REJ;
     CryptoUtils::HashHandshakeMessage(out, &chlo_hash_);
     SendHandshakeMessage(out);
@@ skipping 132 matching lines @@
   QuicAsyncStatus status = verifier->VerifyProof(
       server_id_.host(), server_id_.port(), cached->server_config(),
       session()->connection()->version(), chlo_hash_, cached->certs(),
       cached->cert_sct(), cached->signature(), verify_context_.get(),
       &verify_error_details_, &verify_details_,
       std::unique_ptr<ProofVerifierCallback>(proof_verify_callback));
 
   switch (status) {
     case QUIC_PENDING:
       proof_verify_callback_ = proof_verify_callback;
-      DVLOG(1) << "Doing VerifyProof";
+      QUIC_DVLOG(1) << "Doing VerifyProof";
       break;
     case QUIC_FAILURE:
       break;
     case QUIC_SUCCESS:
       verify_ok_ = true;
       break;
   }
   return status;
 }
 
@@ skipping 46 matching lines @@
   }
 
   ChannelIDSourceCallbackImpl* channel_id_source_callback =
       new ChannelIDSourceCallbackImpl(this);
   QuicAsyncStatus status = crypto_config_->channel_id_source()->GetChannelIDKey(
       server_id_.host(), &channel_id_key_, channel_id_source_callback);
 
   switch (status) {
     case QUIC_PENDING:
       channel_id_source_callback_ = channel_id_source_callback;
-      DVLOG(1) << "Looking up channel ID";
+      QUIC_DVLOG(1) << "Looking up channel ID";
       break;
     case QUIC_FAILURE:
       next_state_ = STATE_NONE;
       delete channel_id_source_callback;
       CloseConnectionWithDetails(QUIC_INVALID_CHANNEL_ID_SIGNATURE,
                                  "Channel ID lookup failed");
       break;
     case QUIC_SUCCESS:
       delete channel_id_source_callback;
       break;
@@ skipping 123 matching lines @@
   }
   for (size_t i = 0; i < num_their_proof_demands; i++) {
     if (their_proof_demands[i] == kCHID) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net