Add QuicStrCat.

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.
@@ skipping 164 matching lines @@
     }
 
     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 (write_block_num >= blocks_count_) {
-      *error_details = StringPrintf(
+      *error_details = QuicStrCat(
           "QuicStreamSequencerBuffer error: OnStreamData() exceed array bounds."
-          "write offset = %" PRIu64 " write_block_num = %" PRIuS
-          " blocks_count_ = %" PRIuS,
-          offset, write_block_num, blocks_count_);
+          "write offset = ",
+          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().
       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;
 
     if (dest == nullptr || source == nullptr) {
-      *error_details = StringPrintf(
+      *error_details = QuicStrCat(
           "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,
-          GapsDebugString().c_str(), ReceivedFramesDebugString().c_str(),
-          total_bytes_read_);
+          " 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;
     }
     memcpy(dest, source, bytes_to_copy);
     source += bytes_to_copy;
     source_remaining -= bytes_to_copy;
     offset += bytes_to_copy;
     total_written += bytes_to_copy;
   }
 
   DCHECK_GT(total_written, 0u);
@@ skipping 50 matching lines @@
     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 = 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 = StringPrintf(
+        *error_details = QuicStrCat(
             "QuicStreamSequencerBuffer error:"
-            " Readv() dest == nullptr: %s"
-            " blocks_[%" PRIuS "] == nullptr: %s",
-            (dest == nullptr ? "true" : "false"), block_idx,
-            (blocks_[block_idx] == nullptr ? "true" : "false"));
+            " Readv() dest == nullptr: ",
+            (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;
       *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 (!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());
+          *error_details = QuicStrCat(
+              "QuicStreamSequencerBuffer error: fail to retire block ",
+              block_idx,
+              " as the block is already released, total_bytes_read_ = ",
+              total_bytes_read_, " Gaps: ", GapsDebugString());
           return QUIC_STREAM_SEQUENCER_INVALID_STATE;
         }
       }
     }
   }
 
   if (*bytes_read > 0) {
     UpdateFrameArrivalMap(total_bytes_read_);
   }
   return QUIC_NO_ERROR;
@@ skipping 264 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