tracing v2: minor refactoring to TraceRingBuffer test helpers

components/tracing/core/trace_ring_buffer.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_TRACE_RING_BUFFER_H_
 #define COMPONENTS_TRACING_CORE_TRACE_RING_BUFFER_H_
 
+#include <memory>
+
 #include "base/atomicops.h"
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
-#include "base/threading/thread.h"
 #include "components/tracing/tracing_export.h"
 
 namespace tracing {
 namespace v2 {
 
+static const uint32_t kNoChunkOwner = 0;
+
 class TRACING_EXPORT TraceRingBuffer {
  public:
   class Chunk {
    public:
     using Header = base::subtle::Atomic32;
     static constexpr size_t kSize = 32 * 1024;
 
     Chunk();
     ~Chunk();
 
     void Initialize(uint8_t* begin);
     void Clear();
 
     uint8_t* begin() const { return begin_; }
     Header* header() const { return reinterpret_cast<Header*>(begin_); }
     uint8_t* payload() const { return begin_ + sizeof(Header); }
     uint8_t* end() const { return begin_ + kSize; }
 
     void set_used_size(uint32_t size) {
       base::subtle::NoBarrier_Store(header(), size);
     }
     uint32_t used_size() const {
       return base::subtle::NoBarrier_Load(header());
     }
 
+    void set_next_in_owner_list(Chunk* next) { next_in_owner_list_ = next; }
+    Chunk* next_in_owner_list() const { return next_in_owner_list_; }
+
+    // Owner is a flag matching the id of the TraceBufferWriter, 0 if not owned.
     // Accesses to |owner_| must happen under the buffer |lock_|.
-    bool is_owned() const { return owner_ != base::kInvalidThreadId; }
-    void clear_owner() { owner_ = base::kInvalidThreadId; }
-    void set_owner(base::PlatformThreadId tid) { owner_ = tid; }
+    bool is_owned() const { return owner_ != kNoChunkOwner; }
+    uint32_t owner() const { return owner_; }
+    void clear_owner() { owner_ = kNoChunkOwner; }
+    void set_owner(uint32_t owner) {
+      DCHECK_NE(kNoChunkOwner, owner);
+      owner_ = owner;
+    }
 
    private:
     uint8_t* begin_;
-    base::PlatformThreadId owner_;  // kInvalidThreadId -> Chunk is not owned.
+    uint32_t owner_;
+
+    // When a chunk is owned, this is the next pointer to keep track of all
+    // owned chunks in a singly linked list.
+    Chunk* next_in_owner_list_;
 
     DISALLOW_COPY_AND_ASSIGN(Chunk);
   };
 
   TraceRingBuffer(uint8_t* begin, size_t size);
   ~TraceRingBuffer();
 
-  Chunk* TakeChunk();
-  void ReturnChunk(Chunk* chunk, uint32_t used_size);
+  Chunk* TakeChunk(uint32_t writer_id);
+  void ReturnChunk(Chunk* chunk);
+
+  size_t num_chunks() const { return num_chunks_; }
+
+  // Returns the number of chunks taken and not returned, without counting any
+  // bankrupcy chunk obtained when the ring buffer was full.
+  size_t GetNumChunksTaken() const;
+
+  const Chunk* chunks_for_testing() const { return chunks_.get(); }
+  bool IsBankrupcyChunkForTesting(const Chunk*) const;
 
  private:
-  base::Lock lock_;
+  mutable base::Lock lock_;
   std::unique_ptr<Chunk[]> chunks_;
   const size_t num_chunks_;
+  size_t num_chunks_taken_;
   size_t current_chunk_idx_;
 
   // An emergency chunk used in the rare case in which all chunks are in flight.
   // This chunk is not part of the ring buffer and its contents are always
   // discarded. Its only purpose is to avoid a crash (due to TakeChunk returning
   // nullptr) in the case of a thread storm.
   Chunk bankrupcy_chunk_;
   std::unique_ptr<uint8_t[]> bankrupcy_chunk_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceRingBuffer);
 };
 
 }  // namespace v2
 }  // namespace tracing
 
 #endif  // COMPONENTS_TRACING_CORE_TRACE_RING_BUFFER_H_