base: Remove the string logging from CHECK().

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 "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 33 matching lines @@
                                                 QuicTime timestamp)
     : length(length), timestamp(timestamp) {}
 
 QuicStreamSequencerBuffer::QuicStreamSequencerBuffer(size_t max_capacity_bytes)
     : max_buffer_capacity_bytes_(max_capacity_bytes),
       blocks_count_(
           ceil(static_cast<double>(max_capacity_bytes) / kBlockSizeBytes)),
       total_bytes_read_(0),
       blocks_(nullptr),
       destruction_indicator_(123456) {
-  CHECK_GT(blocks_count_, 1u)
-      << "blocks_count_ = " << blocks_count_
-      << ", max_buffer_capacity_bytes_ = " << max_buffer_capacity_bytes_;
+  // blocks_count_ = |blocks_count_|, max_buffer_capacity_bytes_ =
+  // |max_buffer_capacity_bytes_|
+  CHECK_GT(blocks_count_, 1u);
   Clear();
 }
 
 QuicStreamSequencerBuffer::~QuicStreamSequencerBuffer() {
   Clear();
   destruction_indicator_ = 654321;
 }
 
 void QuicStreamSequencerBuffer::Clear() {
   if (blocks_ != nullptr) {
@@ skipping 22 matching lines @@
   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";
+  // This object has been destructed
+  CHECK_EQ(destruction_indicator_, 123456);
   *bytes_buffered = 0;
   QuicStreamOffset offset = starting_offset;
   size_t size = data.size();
   if (size == 0) {
     *error_details = "Received empty stream frame without FIN.";
     return QUIC_EMPTY_STREAM_FRAME_NO_FIN;
   }
 
   // Find the first gap not ending before |offset|. This gap maybe the gap to
   // fill if the arriving frame doesn't overlaps with previous ones.
@@ skipping 162 matching lines @@
                  start_offset + bytes_written) {
     // This gap has been filled with new data. So it's no longer a gap.
     gaps_.erase(gap_with_new_data_written);
   }
 }
 
 QuicErrorCode QuicStreamSequencerBuffer::Readv(const iovec* dest_iov,
                                                size_t dest_count,
                                                size_t* bytes_read,
                                                string* error_details) {
-  CHECK_EQ(destruction_indicator_, 123456) << "This object has been destructed";
+  // This object has been destructed
+  CHECK_EQ(destruction_indicator_, 123456);
 
   *bytes_read = 0;
   for (size_t i = 0; i < dest_count && ReadableBytes() > 0; ++i) {
     char* dest = reinterpret_cast<char*>(dest_iov[i].iov_base);
     CHECK_NE(dest, nullptr);
     size_t dest_remaining = dest_iov[i].iov_len;
     while (dest_remaining > 0 && ReadableBytes() > 0) {
       size_t block_idx = NextBlockToRead();
       size_t start_offset_in_block = ReadOffset();
       size_t block_capacity = GetBlockCapacity(block_idx);
@@ skipping 38 matching lines @@
   }
 
   if (*bytes_read > 0) {
     UpdateFrameArrivalMap(total_bytes_read_);
   }
   return QUIC_NO_ERROR;
 }
 
 int QuicStreamSequencerBuffer::GetReadableRegions(struct iovec* iov,
                                                   int iov_count) const {
-  CHECK_EQ(destruction_indicator_, 123456) << "This object has been destructed";
+  // This object has been destructed
+  CHECK_EQ(destruction_indicator_, 123456);
 
   DCHECK(iov != nullptr);
   DCHECK_GT(iov_count, 0);
 
   if (ReadableBytes() == 0) {
     iov[0].iov_base = nullptr;
     iov[0].iov_len = 0;
     return 0;
   }
 
@@ skipping 39 matching lines @@
     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;
     ++iov_used;
   }
   return iov_used;
 }
 
 bool QuicStreamSequencerBuffer::GetReadableRegion(iovec* iov,
                                                   QuicTime* timestamp) const {
-  CHECK_EQ(destruction_indicator_, 123456) << "This object has been destructed";
+  // This object has been destructed
+  CHECK_EQ(destruction_indicator_, 123456);
 
   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>(
@@ skipping 19 matching lines @@
     // If encountered the end of readable bytes before reaching a different
     // timestamp.
     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";
+  // This object has been destructed
+  CHECK_EQ(destruction_indicator_, 123456);
 
   if (bytes_used > ReadableBytes()) {
     return false;
   }
   size_t bytes_to_consume = bytes_used;
   while (bytes_to_consume > 0) {
     size_t block_idx = NextBlockToRead();
     size_t offset_in_block = ReadOffset();
     size_t bytes_available = std::min<size_t>(
         ReadableBytes(), GetBlockCapacity(block_idx) - offset_in_block);
@@ skipping 145 matching lines @@
     QuicStreamOffset current_frame_end_offset =
         it.second.length + current_frame_begin_offset;
     current_frames_string = string(StringPrintf(
         "%s[%" PRIu64 ", %" PRIu64 ") ", current_frames_string.c_str(),
         current_frame_begin_offset, current_frame_end_offset));
   }
   return current_frames_string;
 }
 
 }  //  namespace net