Add quic_logging

net/quic/core/quic_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_stream.h"
 
-#include "base/logging.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_flow_controller.h"
 #include "net/quic/core/quic_session.h"
 #include "net/quic/core/quic_write_blocked_list.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_logging.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 #define ENDPOINT \
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
 namespace {
@@ skipping 66 matching lines @@
   DCHECK(!(read_side_closed_ && write_side_closed_));
 
   if (frame.fin) {
     fin_received_ = true;
     if (fin_sent_) {
       session_->StreamDraining(id_);
     }
   }
 
   if (read_side_closed_) {
-    DVLOG(1) << ENDPOINT << "Stream " << frame.stream_id
-             << " is closed for reading. Ignoring newly received stream data.";
+    QUIC_DLOG(INFO)
+        << ENDPOINT << "Stream " << frame.stream_id
+        << " is closed for reading. Ignoring newly received stream data.";
     // The subclass does not want to read data:  blackhole the data.
     return;
   }
 
   // This count includes duplicate data received.
   size_t frame_payload_size = frame.data_length;
   stream_bytes_read_ += frame_payload_size;
 
   // Flow control is interested in tracking highest received offset.
   // Only interested in received frames that carry data.
@@ skipping 75 matching lines @@
   if (data.empty() && !fin) {
     QUIC_BUG << "data.empty() && !fin";
     return;
   }
 
   if (fin_buffered_) {
     QUIC_BUG << "Fin already buffered";
     return;
   }
   if (write_side_closed_) {
-    DLOG(ERROR) << ENDPOINT << "Attempt to write when the write side is closed";
+    QUIC_DLOG(ERROR) << ENDPOINT
+                     << "Attempt to write when the write side is closed";
     return;
   }
 
   QuicConsumedData consumed_data(0, false);
   fin_buffered_ = fin;
 
   if (queued_data_.empty()) {
     struct iovec iov(MakeIovec(data));
     consumed_data = WritevData(&iov, 1, fin, ack_listener);
     DCHECK_LE(consumed_data.bytes_consumed, data.length());
@@ skipping 58 matching lines @@
     session_->MarkConnectionLevelWriteBlocked(id());
   }
 }
 
 QuicConsumedData QuicStream::WritevData(
     const struct iovec* iov,
     int iov_count,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (write_side_closed_) {
-    DLOG(ERROR) << ENDPOINT << "Attempt to write when the write side is closed";
+    QUIC_DLOG(ERROR) << ENDPOINT
+                     << "Attempt to write when the write side is closed";
     return QuicConsumedData(0, false);
   }
 
   // How much data was provided.
   size_t write_length = 0;
   if (iov != nullptr) {
     for (int i = 0; i < iov_count; ++i) {
       write_length += iov[i].iov_len;
     }
   }
@@ skipping 18 matching lines @@
     MaybeSendBlocked();
     return QuicConsumedData(0, false);
   }
 
   if (write_length > send_window) {
     // Don't send the FIN unless all the data will be sent.
     fin = false;
 
     // Writing more data would be a violation of flow control.
     write_length = static_cast<size_t>(send_window);
-    DVLOG(1) << "stream " << id() << " shortens write length to "
-             << write_length << " due to flow control";
+    QUIC_DVLOG(1) << "stream " << id() << " shortens write length to "
+                  << write_length << " due to flow control";
   }
 
   QuicConsumedData consumed_data =
       WritevDataInner(QuicIOVector(iov, iov_count, write_length),
                       stream_bytes_written_, fin, std::move(ack_listener));
   stream_bytes_written_ += consumed_data.bytes_consumed;
 
   AddBytesSent(consumed_data.bytes_consumed);
 
   // The write may have generated a write error causing this stream to be
@@ skipping 27 matching lines @@
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   return session()->WritevData(this, id(), iov, offset, fin,
                                std::move(ack_listener));
 }
 
 void QuicStream::CloseReadSide() {
   if (read_side_closed_) {
     return;
   }
-  DVLOG(1) << ENDPOINT << "Done reading from stream " << id();
+  QUIC_DLOG(INFO) << ENDPOINT << "Done reading from stream " << id();
 
   read_side_closed_ = true;
   sequencer_.ReleaseBuffer();
 
   if (write_side_closed_) {
-    DVLOG(1) << ENDPOINT << "Closing stream: " << id();
+    QUIC_DLOG(INFO) << ENDPOINT << "Closing stream: " << id();
     session_->CloseStream(id());
   }
 }
 
 void QuicStream::CloseWriteSide() {
   if (write_side_closed_) {
     return;
   }
-  DVLOG(1) << ENDPOINT << "Done writing to stream " << id();
+  QUIC_DLOG(INFO) << ENDPOINT << "Done writing to stream " << id();
 
   write_side_closed_ = true;
   if (read_side_closed_) {
-    DVLOG(1) << ENDPOINT << "Closing stream: " << id();
+    QUIC_DLOG(INFO) << ENDPOINT << "Closing stream: " << id();
     session_->CloseStream(id());
   }
 }
 
 bool QuicStream::HasBufferedData() const {
   return !queued_data_.empty();
 }
 
 QuicVersion QuicStream::version() const {
   return session_->connection()->version();
 }
 
 void QuicStream::StopReading() {
-  DVLOG(1) << ENDPOINT << "Stop reading from stream " << id();
+  QUIC_DLOG(INFO) << ENDPOINT << "Stop reading from stream " << id();
   sequencer_.StopReading();
 }
 
 const QuicSocketAddress& QuicStream::PeerAddressOfLatestPacket() const {
   return session_->connection()->last_packet_source_address();
 }
 
 void QuicStream::OnClose() {
   CloseReadSide();
   CloseWriteSide();
 
   if (!fin_sent_ && !rst_sent_) {
     // For flow control accounting, tell the peer how many bytes have been
     // written on this stream before termination. Done here if needed, using a
     // RST_STREAM frame.
-    DVLOG(1) << ENDPOINT << "Sending RST_STREAM in OnClose: " << id();
+    QUIC_DLOG(INFO) << ENDPOINT << "Sending RST_STREAM in OnClose: " << id();
     session_->SendRstStream(id(), QUIC_RST_ACKNOWLEDGEMENT,
                             stream_bytes_written_);
     rst_sent_ = true;
   }
 
   // The stream is being closed and will not process any further incoming bytes.
   // As there may be more bytes in flight, to ensure that both endpoints have
   // the same connection level flow control state, mark all unreceived or
   // buffered bytes as consumed.
   QuicByteCount bytes_to_consume =
@@ skipping 50 matching lines @@
   }
 }
 
 void QuicStream::UpdateSendWindowOffset(QuicStreamOffset new_window) {
   if (flow_controller_.UpdateSendWindowOffset(new_window)) {
     OnCanWrite();
   }
 }
 
 }  // namespace net