Add quic_logging

net/quic/core/quic_stream_sequencer_buffer.cc

 // Copyright (c) 2015 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_sequencer_buffer.h"
 
 #include "base/format_macros.h"
-#include "base/logging.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 
 using std::string;
 
 namespace net {
 namespace {
 
 // Upper limit of how many gaps allowed in buffer, which ensures a reasonable
 // number of iterations needed to find the right gap to fill when a frame
 // arrives.
@@ skipping 51 matching lines @@
   frame_arrival_time_map_.clear();
 }
 
 bool QuicStreamSequencerBuffer::RetireBlock(size_t idx) {
   if (blocks_[idx] == nullptr) {
     QUIC_BUG << "Try to retire block twice";
     return false;
   }
   delete blocks_[idx];
   blocks_[idx] = nullptr;
-  DVLOG(1) << "Retired block with index: " << idx;
+  QUIC_DVLOG(1) << "Retired block with index: " << idx;
   return true;
 }
 
 QuicErrorCode QuicStreamSequencerBuffer::OnStreamData(
     QuicStreamOffset starting_offset,
     base::StringPiece data,
     QuicTime timestamp,
     size_t* const bytes_buffered,
     std::string* error_details) {
   CHECK_EQ(destruction_indicator_, 123456) << "This object has been destructed";
@@ skipping 13 matching lines @@
   }
 
   DCHECK(current_gap != gaps_.end());
 
   // "duplication": might duplicate with data alread filled,but also might
   // overlap across different base::StringPiece objects already written.
   // In both cases, don't write the data,
   // and allow the caller of this method to handle the result.
   if (offset < current_gap->begin_offset &&
       offset + size <= current_gap->begin_offset) {
-    DVLOG(1) << "Duplicated data at offset: " << offset << " length: " << size;
+    QUIC_DVLOG(1) << "Duplicated data at offset: " << offset
+                  << " length: " << size;
     return QUIC_NO_ERROR;
   }
   if (offset < current_gap->begin_offset &&
       offset + size > current_gap->begin_offset) {
     // Beginning of new data overlaps data before current gap.
     string prefix(data.data(), data.length() < 128 ? data.length() : 128);
     *error_details =
         QuicStrCat("Beginning of received data overlaps with buffered data.\n",
                    "New frame range [", offset, ", ", offset + size,
                    ") with first 128 bytes: ", prefix, "\n",
@@ skipping 69 matching lines @@
     }
     if (blocks_[write_block_num] == nullptr) {
       // TODO(danzh): Investigate if using a freelist would improve performance.
       // Same as RetireBlock().
       blocks_[write_block_num] = new BufferBlock();
     }
 
     const size_t bytes_to_copy =
         std::min<size_t>(bytes_avail, source_remaining);
     char* dest = blocks_[write_block_num]->buffer + write_block_offset;
-    DVLOG(1) << "Write at offset: " << offset << " length: " << bytes_to_copy;
+    QUIC_DVLOG(1) << "Write at offset: " << offset
+                  << " length: " << bytes_to_copy;
 
     if (dest == nullptr || source == nullptr) {
       *error_details = QuicStrCat(
           "QuicStreamSequencerBuffer error: OnStreamData()"
           " dest == nullptr: ",
           (dest == nullptr), " source == nullptr: ", (source == nullptr),
           " Writing at offset ", offset, " Gaps: ", GapsDebugString(),
           " Remaining frames: ", ReceivedFramesDebugString(),
           " total_bytes_read_ = ", total_bytes_read_);
       return QUIC_STREAM_SEQUENCER_INVALID_STATE;
@@ skipping 124 matching lines @@
   size_t start_block_idx = NextBlockToRead();
   QuicStreamOffset readable_offset_end = gaps_.front().begin_offset - 1;
   DCHECK_GE(readable_offset_end + 1, total_bytes_read_);
   size_t end_block_offset = GetInBlockOffset(readable_offset_end);
   size_t end_block_idx = GetBlockIndex(readable_offset_end);
 
   // If readable region is within one block, deal with it seperately.
   if (start_block_idx == end_block_idx && ReadOffset() <= end_block_offset) {
     iov[0].iov_base = blocks_[start_block_idx]->buffer + ReadOffset();
     iov[0].iov_len = ReadableBytes();
-    DVLOG(1) << "Got only a single block with index: " << start_block_idx;
+    QUIC_DVLOG(1) << "Got only a single block with index: " << start_block_idx;
     return 1;
   }
 
   // Get first block
   iov[0].iov_base = blocks_[start_block_idx]->buffer + ReadOffset();
   iov[0].iov_len = GetBlockCapacity(start_block_idx) - ReadOffset();
-  DVLOG(1) << "Got first block " << start_block_idx << " with len "
-           << iov[0].iov_len;
+  QUIC_DVLOG(1) << "Got first block " << start_block_idx << " with len "
+                << iov[0].iov_len;
   DCHECK_GT(readable_offset_end + 1, total_bytes_read_ + iov[0].iov_len)
       << "there should be more available data";
 
   // Get readable regions of the rest blocks till either 2nd to last block
   // before gap is met or |iov| is filled. For these blocks, one whole block is
   // a region.
   int iov_used = 1;
   size_t block_idx = (start_block_idx + iov_used) % blocks_count_;
   while (block_idx != end_block_idx && iov_used < iov_count) {
     DCHECK_NE(static_cast<BufferBlock*>(nullptr), blocks_[block_idx]);
     iov[iov_used].iov_base = blocks_[block_idx]->buffer;
     iov[iov_used].iov_len = GetBlockCapacity(block_idx);
-    DVLOG(1) << "Got block with index: " << block_idx;
+    QUIC_DVLOG(1) << "Got block with index: " << block_idx;
     ++iov_used;
     block_idx = (start_block_idx + iov_used) % blocks_count_;
   }
 
   // Deal with last block if |iov| can hold more.
   if (iov_used < iov_count) {
     DCHECK_NE(static_cast<BufferBlock*>(nullptr), blocks_[block_idx]);
     iov[iov_used].iov_base = blocks_[end_block_idx]->buffer;
     iov[iov_used].iov_len = end_block_offset + 1;
-    DVLOG(1) << "Got last block with index: " << end_block_idx;
+    QUIC_DVLOG(1) << "Got last block with index: " << end_block_idx;
     ++iov_used;
   }
   return iov_used;
 }
 
 bool QuicStreamSequencerBuffer::GetReadableRegion(iovec* iov,
                                                   QuicTime* timestamp) const {
   CHECK_EQ(destruction_indicator_, 123456) << "This object has been destructed";
 
   if (ReadableBytes() == 0) {
     iov[0].iov_base = nullptr;
     iov[0].iov_len = 0;
     return false;
   }
 
   size_t start_block_idx = NextBlockToRead();
   iov->iov_base = blocks_[start_block_idx]->buffer + ReadOffset();
   size_t readable_bytes_in_block = std::min<size_t>(
       GetBlockCapacity(start_block_idx) - ReadOffset(), ReadableBytes());
   size_t region_len = 0;
   auto iter = frame_arrival_time_map_.begin();
   *timestamp = iter->second.timestamp;
-  DVLOG(1) << "Readable bytes in block: " << readable_bytes_in_block;
+  QUIC_DVLOG(1) << "Readable bytes in block: " << readable_bytes_in_block;
   for (; iter != frame_arrival_time_map_.end() &&
          region_len + iter->second.length <= readable_bytes_in_block;
        ++iter) {
     if (iter->second.timestamp != *timestamp) {
       // If reaches a frame arrive at another timestamp, stop expanding current
       // region.
-      DVLOG(1) << "Meet frame with different timestamp.";
+      QUIC_DVLOG(1) << "Meet frame with different timestamp.";
       break;
     }
     region_len += iter->second.length;
-    DVLOG(1) << "Added bytes to region: " << iter->second.length;
+    QUIC_DVLOG(1) << "Added bytes to region: " << iter->second.length;
   }
   if (iter == frame_arrival_time_map_.end() ||
       iter->second.timestamp == *timestamp) {
     // If encountered the end of readable bytes before reaching a different
     // timestamp.
-    DVLOG(1) << "Got all readable bytes in first block.";
+    QUIC_DVLOG(1) << "Got all readable bytes in first block.";
     region_len = readable_bytes_in_block;
   }
   iov->iov_len = region_len;
   return true;
 }
 
 bool QuicStreamSequencerBuffer::MarkConsumed(size_t bytes_used) {
   CHECK_EQ(destruction_indicator_, 123456) << "This object has been destructed";
 
   if (bytes_used > ReadableBytes()) {
@@ skipping 118 matching lines @@
 }
 
 void QuicStreamSequencerBuffer::UpdateFrameArrivalMap(QuicStreamOffset offset) {
   // Get the frame before which all frames should be removed.
   auto next_frame = frame_arrival_time_map_.upper_bound(offset);
   DCHECK(next_frame != frame_arrival_time_map_.begin());
   auto iter = frame_arrival_time_map_.begin();
   while (iter != next_frame) {
     auto erased = *iter;
     iter = frame_arrival_time_map_.erase(iter);
-    DVLOG(1) << "Removed FrameInfo with offset: " << erased.first
-             << " and length: " << erased.second.length;
+    QUIC_DVLOG(1) << "Removed FrameInfo with offset: " << erased.first
+                  << " and length: " << erased.second.length;
     if (erased.first + erased.second.length > offset) {
       // If last frame is partially read out, update this FrameInfo and insert
       // it back.
       auto updated = std::make_pair(
           offset, FrameInfo(erased.first + erased.second.length - offset,
                             erased.second.timestamp));
-      DVLOG(1) << "Inserted FrameInfo with offset: " << updated.first
-               << " and length: " << updated.second.length;
+      QUIC_DVLOG(1) << "Inserted FrameInfo with offset: " << updated.first
+                    << " and length: " << updated.second.length;
       frame_arrival_time_map_.insert(updated);
     }
   }
 }
 
 string QuicStreamSequencerBuffer::GapsDebugString() {
   string current_gaps_string;
   for (const Gap& gap : gaps_) {
     QuicStreamOffset current_gap_begin = gap.begin_offset;
     QuicStreamOffset current_gap_end = gap.end_offset;
@@ skipping 10 matching lines @@
     QuicStreamOffset current_frame_end_offset =
         it.second.length + current_frame_begin_offset;
     current_frames_string.append(QuicStrCat(
         "[", current_frame_begin_offset, ", ", current_frame_end_offset,
         ") receiving time ", it.second.timestamp.ToDebuggingValue()));
   }
   return current_frames_string;
 }
 
 }  //  namespace net