Use QuicStrCat instead of strings::Substitute and strings::SubstituteAndAppend which do not exist i…

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"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 
 using base::StringPrintf;
 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.
 const size_t kMaxNumGapsAllowed = 2 * kMaxPacketGap;
 
 }  // namespace
 
-namespace {
-
-string RangeDebugString(QuicStreamOffset start, QuicStreamOffset end) {
-  return std::string("[") + base::Uint64ToString(start) + ", " +
-         base::Uint64ToString(end) + ") ";
-}
-
-}  // namespace
-
 QuicStreamSequencerBuffer::Gap::Gap(QuicStreamOffset begin_offset,
                                     QuicStreamOffset end_offset)
     : begin_offset(begin_offset), end_offset(end_offset) {}
 
 QuicStreamSequencerBuffer::FrameInfo::FrameInfo()
     : length(1), timestamp(QuicTime::Zero()) {}
 
 QuicStreamSequencerBuffer::FrameInfo::FrameInfo(size_t length,
                                                 QuicTime timestamp)
     : length(length), timestamp(timestamp) {}
@@ skipping 77 matching lines @@
   // 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;
     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 =
-        string("Beginning of received data overlaps with buffered data.\n") +
-        "New frame range " + RangeDebugString(offset, offset + size) +
-        " with first 128 bytes: " +
-        string(data.data(), data.length() < 128 ? data.length() : 128) +
-        "\nCurrently received frames: " + ReceivedFramesDebugString() +
-        "\nCurrent gaps: " + GapsDebugString();
+        QuicStrCat("Beginning of received data overlaps with buffered data.\n",
+                   "New frame range [", offset, ", ", offset + size,
+                   ") with first 128 bytes: ", prefix, "\n",
+                   "Currently received frames: ", GapsDebugString(), "\n",
+                   "Current gaps: ", ReceivedFramesDebugString());
     return QUIC_OVERLAPPING_STREAM_DATA;
   }
   if (offset + size > current_gap->end_offset) {
     // End of new data overlaps with data after current gap.
-    *error_details =
-        string("End of received data overlaps with buffered data.\n") +
-        "New frame range " + RangeDebugString(offset, offset + size) +
-        " with first 128 bytes: " +
-        string(data.data(), data.length() < 128 ? data.length() : 128) +
-        "\nCurrently received frames: " + ReceivedFramesDebugString() +
-        "\nCurrent gaps: " + GapsDebugString();
+    string prefix(data.data(), data.length() < 128 ? data.length() : 128);
+    *error_details = QuicStrCat(
+        "End of received data overlaps with buffered data.\nNew frame range [",
+        offset, ", ", offset + size, ") with first 128 bytes: ", prefix, "\n",
+        "Currently received frames: ", ReceivedFramesDebugString(), "\n",
+        "Current gaps: ", GapsDebugString());
     return QUIC_OVERLAPPING_STREAM_DATA;
   }
 
   // Write beyond the current range this buffer is covering.
   if (offset + size > total_bytes_read_ + max_buffer_capacity_bytes_) {
     *error_details = "Received data beyond available range.";
     return QUIC_INTERNAL_ERROR;
   }
 
   if (current_gap->begin_offset != starting_offset &&
@@ skipping 29 matching lines @@
       blocks_.reset(new BufferBlock*[blocks_count_]());
       for (size_t i = 0; i < blocks_count_; ++i) {
         blocks_[i] = nullptr;
       }
     }
 
     if (write_block_num >= blocks_count_) {
       *error_details = QuicStrCat(
           "QuicStreamSequencerBuffer error: OnStreamData() exceed array bounds."
           "write offset = ",
-          offset, " write_block_num = ", write_block_num, " blocks_count_ = ",
-          blocks_count_);
+          offset, " write_block_num = ", write_block_num,
+          " blocks_count_ = ", 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().
@@ skipping 79 matching lines @@
       size_t block_capacity = GetBlockCapacity(block_idx);
       size_t bytes_available_in_block = std::min<size_t>(
           ReadableBytes(), block_capacity - start_offset_in_block);
       size_t bytes_to_copy =
           std::min<size_t>(bytes_available_in_block, dest_remaining);
       DCHECK_GT(bytes_to_copy, 0UL);
       if (blocks_[block_idx] == nullptr || dest == nullptr) {
         *error_details = QuicStrCat(
             "QuicStreamSequencerBuffer error:"
             " Readv() dest == nullptr: ",
-            (dest == nullptr), " blocks_[", block_idx, "] == nullptr: ",
-            (blocks_[block_idx] == nullptr), " Gaps: ", GapsDebugString(),
+            (dest == nullptr), " blocks_[", block_idx,
+            "] == nullptr: ", (blocks_[block_idx] == nullptr),
+            " Gaps: ", GapsDebugString(),
             " Remaining frames: ", ReceivedFramesDebugString(),
             " total_bytes_read_ = ", total_bytes_read_);
         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;
@@ skipping 269 matching lines @@
       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;
-    current_gaps_string += RangeDebugString(current_gap_begin, current_gap_end);
+    current_gaps_string.append(
+        QuicStrCat("[", current_gap_begin, ", ", current_gap_end, ") "));
   }
   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;
-    current_frames_string = string(StringPrintf(
-        "%s[%" PRIu64 ", %" PRIu64 ") ", current_frames_string.c_str(),
-        current_frame_begin_offset, current_frame_end_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