Add quic_logging

net/quic/core/quic_spdy_stream.cc

 // Copyright 2013 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_spdy_stream.h"
 
 #include <utility>
 
-#include "base/logging.h"
 #include "net/base/parse_number.h"
 #include "net/quic/core/quic_spdy_session.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/quic_write_blocked_list.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 
 using base::IntToString;
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 #define ENDPOINT                                                               \
   (session()->perspective() == Perspective::IS_SERVER ? "Server: " : "Client:" \
@@ skipping 19 matching lines @@
   if (spdy_session_ != nullptr) {
     spdy_session_->UnregisterStreamPriority(id());
   }
 }
 
 void QuicSpdyStream::StopReading() {
   if (!fin_received() && !rst_received() && write_side_closed() &&
       !rst_sent()) {
     DCHECK(fin_sent());
     // Tell the peer to stop sending further data.
-    DVLOG(1) << ENDPOINT << "Send QUIC_STREAM_NO_ERROR on stream " << id();
+    QUIC_DVLOG(1) << ENDPOINT << "Send QUIC_STREAM_NO_ERROR on stream " << id();
     Reset(QUIC_STREAM_NO_ERROR);
   }
   QuicStream::StopReading();
 }
 
 size_t QuicSpdyStream::WriteHeaders(
     SpdyHeaderBlock header_block,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   size_t bytes_written = spdy_session_->WriteHeaders(
@@ skipping 16 matching lines @@
 size_t QuicSpdyStream::WriteTrailers(
     SpdyHeaderBlock trailer_block,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (fin_sent()) {
     QUIC_BUG << "Trailers cannot be sent after a FIN.";
     return 0;
   }
 
   // The header block must contain the final offset for this stream, as the
   // trailers may be processed out of order at the peer.
-  DVLOG(1) << "Inserting trailer: (" << kFinalOffsetHeaderKey << ", "
-           << stream_bytes_written() + queued_data_bytes() << ")";
+  QUIC_DLOG(INFO) << "Inserting trailer: (" << kFinalOffsetHeaderKey << ", "
+                  << stream_bytes_written() + queued_data_bytes() << ")";
   trailer_block.insert(
       std::make_pair(kFinalOffsetHeaderKey,
                      QuicTextUtils::Uint64ToString(stream_bytes_written() +
                                                    queued_data_bytes())));
 
   // Write the trailing headers with a FIN, and close stream for writing:
   // trailers are the last thing to be sent on a stream.
   const bool kFin = true;
   size_t bytes_written = spdy_session_->WriteHeaders(
       id(), std::move(trailer_block), kFin, priority_, std::move(ack_listener));
@@ skipping 108 matching lines @@
       ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   return;
 }
 
 void QuicSpdyStream::OnTrailingHeadersComplete(
     bool fin,
     size_t /*frame_len*/,
     const QuicHeaderList& header_list) {
   DCHECK(!trailers_decompressed_);
   if (fin_received()) {
-    DLOG(ERROR) << "Received Trailers after FIN, on stream: " << id();
+    QUIC_DLOG(ERROR) << "Received Trailers after FIN, on stream: " << id();
     session()->connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "Trailers after fin",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
   if (!fin) {
-    DLOG(ERROR) << "Trailers must have FIN set, on stream: " << id();
+    QUIC_DLOG(ERROR) << "Trailers must have FIN set, on stream: " << id();
     session()->connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "Fin missing from trailers",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
 
   size_t final_byte_offset = 0;
   if (!SpdyUtils::CopyAndValidateTrailers(header_list, &final_byte_offset,
                                           &received_trailers_)) {
-    DLOG(ERROR) << "Trailers are malformed: " << id();
+    QUIC_DLOG(ERROR) << "Trailers are malformed: " << id();
     session()->connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "Trailers are malformed",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
   trailers_decompressed_ = true;
   OnStreamFrame(QuicStreamFrame(id(), fin, final_byte_offset, StringPiece()));
 }
 
 void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
   if (frame.error_code != QUIC_STREAM_NO_ERROR) {
     QuicStream::OnStreamReset(frame);
     return;
   }
-  DVLOG(1) << "Received QUIC_STREAM_NO_ERROR, not discarding response";
+  QUIC_DVLOG(1) << "Received QUIC_STREAM_NO_ERROR, not discarding response";
   set_rst_received(true);
   MaybeIncreaseHighestReceivedOffset(frame.byte_offset);
   set_stream_error(frame.error_code);
   CloseWriteSide();
 }
 
 void QuicSpdyStream::OnClose() {
   QuicStream::OnClose();
 
   if (visitor_) {
@@ skipping 70 matching lines @@
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (spdy_session_->headers_stream() != nullptr &&
       spdy_session_->force_hol_blocking()) {
     return spdy_session_->WritevStreamData(id(), iov, offset, fin,
                                            std::move(ack_listener));
   }
   return QuicStream::WritevDataInner(iov, offset, fin, std::move(ack_listener));
 }
 
 }  // namespace net