tracing: split out ThreadLocalEventBuffer

base/trace_event/trace_buffer.h

 // Copyright 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.
 
 #ifndef BASE_TRACE_EVENT_TRACE_BUFFER_H_
 #define BASE_TRACE_EVENT_TRACE_BUFFER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <limits>
+
 #include "base/base_export.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_impl.h"
 
 namespace base {
 
 namespace trace_event {
 
 // TraceBufferChunk is the basic unit of TraceBuffer.
 class BASE_EXPORT TraceBufferChunk {
  public:
+  // These values must be kept consistent with the numbers of bits of
+  // chunk_index and event_index fields in TraceEventHandle
+  // (in trace_event_impl.h).
+  static const size_t kMaxChunkIndex = (1u << 26) - 1;
+  static const size_t kTraceBufferChunkSize = 64;
+
   explicit TraceBufferChunk(uint32_t seq);
   ~TraceBufferChunk();
 
   void Reset(uint32_t new_seq);
   TraceEvent* AddTraceEvent(size_t* event_index);
   bool IsFull() const { return next_free_ == kTraceBufferChunkSize; }
 
   uint32_t seq() const { return seq_; }
   size_t capacity() const { return kTraceBufferChunkSize; }
   size_t size() const { return next_free_; }
 
   TraceEvent* GetEventAt(size_t index) {
     DCHECK(index < size());
     return &chunk_[index];
   }
   const TraceEvent* GetEventAt(size_t index) const {
     DCHECK(index < size());
     return &chunk_[index];
   }
 
+  void MakeHandle(size_t chunk_index,
+                  size_t event_index,
+                  TraceEventHandle* handle) {
+    DCHECK(seq_);
+    DCHECK(chunk_index <= kMaxChunkIndex);
+    DCHECK(event_index < kTraceBufferChunkSize);
+    DCHECK(chunk_index <= std::numeric_limits<uint16_t>::max());
+    handle->chunk_seq = seq_;
+    handle->chunk_index = static_cast<uint16_t>(chunk_index);
+    handle->event_index = static_cast<uint16_t>(event_index);
+  }
+
   void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
 
-  // These values must be kept consistent with the numbers of bits of
-  // chunk_index and event_index fields in TraceEventHandle
-  // (in trace_event_impl.h).
-  static const size_t kMaxChunkIndex = (1u << 26) - 1;
-  static const size_t kTraceBufferChunkSize = 64;
-
  private:
   size_t next_free_;
   std::unique_ptr<TraceEventMemoryOverhead> cached_overhead_estimate_;
   TraceEvent chunk_[kTraceBufferChunkSize];
   uint32_t seq_;
 };
 
 // TraceBuffer holds the events as they are collected.
 class BASE_EXPORT TraceBuffer {
  public:
@@ skipping 61 matching lines @@
 
  private:
   OutputCallback output_callback_;
   bool append_comma_;
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_BUFFER_H_