tracing v2: minor refactoring to TraceRingBuffer test helpers

components/tracing/core/scattered_stream_writer.h

 // Copyright 2016 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.
 
 #ifndef COMPONENTS_TRACING_CORE_SCATTERED_STREAM_WRITER_H_
 #define COMPONENTS_TRACING_CORE_SCATTERED_STREAM_WRITER_H_
 
 #include <stdint.h>
 
+#include "base/logging.h"
 #include "base/macros.h"
 #include "components/tracing/tracing_export.h"
 
 namespace tracing {
 namespace v2 {
 
 struct ContiguousMemoryRange {
   uint8_t* begin;
   uint8_t* end;  // STL style: one byte past the end of the buffer.
 
@@ skipping 25 matching lines @@
   explicit ScatteredStreamWriter(Delegate* delegate);
   ~ScatteredStreamWriter();
 
   void WriteByte(uint8_t value);
   void WriteBytes(const uint8_t* src, size_t size);
 
   // Reserves a fixed amount of bytes to be backfilled later. The reserved range
   // is guaranteed to be contiguous and not span across chunks.
   ContiguousMemoryRange ReserveBytes(size_t size);
 
+  // Fast (but unsafe) version of the above. The caller must have previously
+  // checked that there are at least |size| contiguos bytes available.
+  // Returns only the start pointer of the reservation.
+  template <size_t size> uint8_t* ReserveBytesUnsafe() {

[alph, 2016/07/30 07:41:14]

Why it needs to be a template?
Won't a simple function with a const parameter once inlined produce the same
result?

[Primiano Tucci (use gerrit), 2016/08/04 15:26:54]

Fair point. I think I was just thinking to our previous conversation on some
other function, but here makes total sense just an arg. I checked and gets
effectively inlined on release (at least without dheck_is_on)

+    uint8_t* begin = write_ptr_;
+    write_ptr_ += size;
+    DCHECK_LE(write_ptr_, cur_range_.end);
+    return begin;
+  }
+
   // Resets the buffer boundaries and the write pointer to the given |range|.
   // Subsequent WriteByte(s) will write into |range|.
   void Reset(ContiguousMemoryRange range);
 
   // Number of contiguous free bytes in |cur_range_| that can be written without
   // requesting a new buffer.
   size_t bytes_available() const {
     return static_cast<size_t>(cur_range_.end - write_ptr_);
   }
 
   uint8_t* write_ptr() const { return write_ptr_; }
 
  private:
   void Extend();
 
   Delegate* const delegate_;
   ContiguousMemoryRange cur_range_;
   uint8_t* write_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(ScatteredStreamWriter);
 };
 
 }  // namespace v2
 }  // namespace tracing
 
 #endif  // COMPONENTS_TRACING_CORE_SCATTERED_STREAM_WRITER_H_