Add quic_logging

net/quic/core/quic_client_promised_info.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/core/quic_client_promised_info.h"
 
-#include "base/logging.h"
 #include "net/quic/core/spdy_utils.h"
+#include "net/quic/platform/api/quic_logging.h"
 
 using net::SpdyHeaderBlock;
 using net::kPushPromiseTimeoutSecs;
 using std::string;
 
 namespace net {
 
 QuicClientPromisedInfo::QuicClientPromisedInfo(QuicClientSessionBase* session,
                                                QuicStreamId id,
                                                string url)
     : session_(session),
       id_(id),
       url_(std::move(url)),
       client_request_delegate_(nullptr) {}
 
 QuicClientPromisedInfo::~QuicClientPromisedInfo() {}
 
 void QuicClientPromisedInfo::CleanupAlarm::OnAlarm() {
-  DVLOG(1) << "self GC alarm for stream " << promised_->id_;
+  QUIC_DVLOG(1) << "self GC alarm for stream " << promised_->id_;
   promised_->session()->OnPushStreamTimedOut(promised_->id_);
   promised_->Reset(QUIC_PUSH_STREAM_TIMED_OUT);
 }
 
 void QuicClientPromisedInfo::Init() {
   cleanup_alarm_.reset(session_->connection()->alarm_factory()->CreateAlarm(
       new QuicClientPromisedInfo::CleanupAlarm(this)));
   cleanup_alarm_->Set(
       session_->connection()->helper()->GetClock()->ApproximateNow() +
       QuicTime::Delta::FromSeconds(kPushPromiseTimeoutSecs));
 }
 
 void QuicClientPromisedInfo::OnPromiseHeaders(const SpdyHeaderBlock& headers) {
   // RFC7540, Section 8.2, requests MUST be safe [RFC7231], Section
   // 4.2.1.  GET and HEAD are the methods that are safe and required.
   SpdyHeaderBlock::const_iterator it = headers.find(":method");
   DCHECK(it != headers.end());
   if (!(it->second == "GET" || it->second == "HEAD")) {
-    DVLOG(1) << "Promise for stream " << id_ << " has invalid method "
-             << it->second;
+    QUIC_DVLOG(1) << "Promise for stream " << id_ << " has invalid method "
+                  << it->second;
     Reset(QUIC_INVALID_PROMISE_METHOD);
     return;
   }
   if (!SpdyUtils::UrlIsValid(headers)) {
-    DVLOG(1) << "Promise for stream " << id_ << " has invalid URL " << url_;
+    QUIC_DVLOG(1) << "Promise for stream " << id_ << " has invalid URL "
+                  << url_;
     Reset(QUIC_INVALID_PROMISE_URL);
     return;
   }
   if (!session_->IsAuthorized(SpdyUtils::GetHostNameFromHeaderBlock(headers))) {
     Reset(QUIC_UNAUTHORIZED_PROMISE_URL);
     return;
   }
   request_headers_.reset(new SpdyHeaderBlock(headers.Clone()));
 }
 
@@ skipping 61 matching lines @@
   return FinalValidation();
 }
 
 void QuicClientPromisedInfo::Cancel() {
   // Don't fire OnRendezvousResult() for client initiated cancel.
   client_request_delegate_ = nullptr;
   Reset(QUIC_STREAM_CANCELLED);
 }
 
 }  // namespace net