Deprecate FLAGS_quic_stream_sequencer_buffer_debug.

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 62 matching lines @@
   num_bytes_buffered_ = 0;
   // Reset gaps_ so that buffer is in a state as if all data before
   // total_bytes_read_ has been consumed, and those after total_bytes_read_
   // has never arrived.
   gaps_ = std::list<Gap>(
       1, Gap(total_bytes_read_, std::numeric_limits<QuicStreamOffset>::max())),
   frame_arrival_time_map_.clear();
 }
 
 bool QuicStreamSequencerBuffer::RetireBlock(size_t idx) {
-  if (FLAGS_quic_stream_sequencer_buffer_debug && blocks_[idx] == nullptr) {
+  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;
   return true;
 }
 
 QuicErrorCode QuicStreamSequencerBuffer::OnStreamData(
@@ skipping 87 matching lines @@
       bytes_avail = total_bytes_read_ + max_buffer_capacity_bytes_ - offset;
     }
 
     if (reduce_sequencer_buffer_memory_life_time_ && blocks_ == nullptr) {
       blocks_.reset(new BufferBlock*[blocks_count_]());
       for (size_t i = 0; i < blocks_count_; ++i) {
         blocks_[i] = nullptr;
       }
     }
 
-    if (FLAGS_quic_stream_sequencer_buffer_debug &&
-        write_block_num >= blocks_count_) {
+    if (write_block_num >= blocks_count_) {
       *error_details = StringPrintf(
           "QuicStreamSequencerBuffer error: OnStreamData() exceed array bounds."
           "write offset = %" PRIu64 " write_block_num = %" PRIuS
           " blocks_count_ = %" PRIuS,
           offset, write_block_num, blocks_count_);
       return QUIC_STREAM_SEQUENCER_INVALID_STATE;
     }
     if (blocks_ == nullptr) {
       *error_details =
           "QuicStreamSequencerBuffer error: OnStreamData() blocks_ is null";
       return QUIC_STREAM_SEQUENCER_INVALID_STATE;
     }
     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 = 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;
 
-    if (FLAGS_quic_stream_sequencer_buffer_debug &&
-        (dest == nullptr || source == nullptr)) {
+    if (dest == nullptr || source == nullptr) {
       *error_details = StringPrintf(
           "QuicStreamSequencerBuffer error: OnStreamData()"
           " dest == nullptr: %s"
           " source == nullptr: %s"
           " Writing at offset %" PRIu64
           " Gaps: %s"
           " Remaining frames: %s"
           " total_bytes_read_ = %" PRIu64,
           (dest == nullptr ? "true" : "false"),
           (source == nullptr ? "true" : "false"), offset,
@@ skipping 58 matching lines @@
     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);
       size_t bytes_available_in_block =
           min<size_t>(ReadableBytes(), block_capacity - start_offset_in_block);
       size_t bytes_to_copy =
           min<size_t>(bytes_available_in_block, dest_remaining);
       DCHECK_GT(bytes_to_copy, 0UL);
-      if (FLAGS_quic_stream_sequencer_buffer_debug &&
-          (blocks_[block_idx] == nullptr || dest == nullptr)) {
+      if (blocks_[block_idx] == nullptr || dest == nullptr) {
         *error_details = StringPrintf(
             "QuicStreamSequencerBuffer error:"
             " Readv() dest == nullptr: %s"
             " blocks_[%" PRIuS "] == nullptr: %s",
             (dest == nullptr ? "true" : "false"), block_idx,
             (blocks_[block_idx] == nullptr ? "true" : "false"));
         return QUIC_STREAM_SEQUENCER_INVALID_STATE;
       }
       memcpy(dest, blocks_[block_idx]->buffer + start_offset_in_block,
              bytes_to_copy);
       dest += bytes_to_copy;
       dest_remaining -= bytes_to_copy;
       num_bytes_buffered_ -= bytes_to_copy;
       total_bytes_read_ += bytes_to_copy;
       *bytes_read += bytes_to_copy;
 
       // Retire the block if all the data is read out and no other data is
       // stored in this block.
       // In case of failing to retire a block which is ready to retire, return
       // immediately.
       if (bytes_to_copy == bytes_available_in_block) {
         bool retire_successfully = RetireBlockIfEmpty(block_idx);
-        if (FLAGS_quic_stream_sequencer_buffer_debug && !retire_successfully) {
+        if (!retire_successfully) {
           *error_details = StringPrintf(
               "QuicStreamSequencerBuffer error: fail to retire block %" PRIuS
               " as the block is already released + total_bytes_read_ = %" PRIu64
               " Gaps: %s",
               block_idx, total_bytes_read_, GapsDebugString().c_str());
           return QUIC_STREAM_SEQUENCER_INVALID_STATE;
         }
       }
     }
   }
@@ skipping 255 matching lines @@
   }
   return current_gaps_string;
 }
 
 string QuicStreamSequencerBuffer::ReceivedFramesDebugString() {
   string current_frames_string;
   for (auto it : frame_arrival_time_map_) {
     QuicStreamOffset current_frame_begin_offset = it.first;
     QuicStreamOffset current_frame_end_offset =
         it.second.length + current_frame_begin_offset;
-    if (FLAGS_quic_stream_sequencer_buffer_debug) {
-      current_frames_string = string(StringPrintf(
-          "%s[%" PRIu64 ", %" PRIu64 ") receiving time %" PRId64 " ",
-          current_frames_string.c_str(), current_frame_begin_offset,
-          current_frame_end_offset, it.second.timestamp.ToDebuggingValue()));
-    } else {
-      current_frames_string = string(StringPrintf(
-          "%s[%" PRIu64 ", %" PRIu64 ") ", current_frames_string.c_str(),
-          current_frame_begin_offset, current_frame_end_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