tracing v2: Add TraceRingBuffer class.

components/tracing/core/trace_ring_buffer_unittest.cc

Index: components/tracing/core/trace_ring_buffer_unittest.cc
diff --git a/components/tracing/core/trace_ring_buffer_unittest.cc b/components/tracing/core/trace_ring_buffer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6551476387f89274fb1a1713c6e1a388c2a35463
--- /dev/null
+++ b/components/tracing/core/trace_ring_buffer_unittest.cc
@@ -0,0 +1,83 @@
+// 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.
+
+#include "components/tracing/core/trace_ring_buffer.h"
+
+#include "base/bit_cast.h"

[petrcermak, 2016/06/28 10:22:30]

I don't think you're actually using this.

[Primiano Tucci (use gerrit), 2016/06/28 14:52:11]

Good spot. I think this is going to be introduced in the future and I mistakenly
cherry-picked this line too early.

+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace tracing {
+namespace v2 {
+
+namespace {
+
+const size_t kChunkSize = TraceRingBuffer::Chunk::kSize;
+
+bool overlap(uint8_t* start1, uint8_t* end1, uint8_t* start2, uint8_t* end2) {
+  return start1 < end2 && start2 < end1;
+}
+
+TEST(TraceRingBufferTest, BasicChunkWrapping) {
+  const size_t kNumChunks = 5;
+  const size_t kBufferSize = kChunkSize * kNumChunks;
+  std::unique_ptr<uint8_t[]> storage(new uint8_t[kBufferSize]);
+  TraceRingBuffer ring_buffer(storage.get(), kBufferSize);
+
+  uint8_t* last_chunk_end = nullptr;
+  // Fill the buffer twice to test wrapping logic.
+  for (size_t i = 0; i < kNumChunks * 2; ++i) {
+    TraceRingBuffer::Chunk* chunk = ring_buffer.TakeChunk();
+    ASSERT_NE(nullptr, chunk);
+    const size_t chunk_idx = i % kNumChunks;
+    EXPECT_EQ(chunk_idx == 0 ? storage.get() : last_chunk_end, chunk->begin());
+    const size_t kPayloadSize = (chunk_idx + 1) * 8;
+    memset(chunk->payload(), chunk_idx + 1, kPayloadSize);
+    last_chunk_end = chunk->end();
+    ring_buffer.ReturnChunk(chunk, /* used_size = */ kPayloadSize);
+  }
+
+  // Now scrape the |storage| buffer and check its contents.
+  for (size_t chunk_idx = 0; chunk_idx < kNumChunks; ++chunk_idx) {
+    uint8_t* chunk_start = storage.get() + (chunk_idx * kChunkSize);
+    const size_t kPayloadSize = (chunk_idx + 1) * 8;
+    EXPECT_EQ(kPayloadSize, *reinterpret_cast<uint32_t*>(chunk_start));
+    for (size_t i = 0; i < kPayloadSize; ++i) {

[petrcermak, 2016/06/28 10:22:30]

do you need the braces here?

[Primiano Tucci (use gerrit), 2016/06/28 14:52:11]

Technically it's not mandatory to omit them, but yes, minimizing the numers of
line is the goal of my life :P

+      EXPECT_EQ(chunk_idx + 1, *(chunk_start + sizeof(uint32_t) + i));
+    }
+  }
+}
+
+TEST(TraceRingBufferTest, ChunkBankrupcyDoesNotCrash) {
+  const size_t kNumChunks = 2;
+  const size_t kBufferSize = TraceRingBuffer::Chunk::kSize * kNumChunks;
+  std::unique_ptr<uint8_t[]> storage(new uint8_t[kBufferSize]);
+  TraceRingBuffer ring_buffer(storage.get(), kBufferSize);
+
+  TraceRingBuffer::Chunk* chunk1 = ring_buffer.TakeChunk();
+  ASSERT_NE(nullptr, chunk1);
+
+  TraceRingBuffer::Chunk* chunk2 = ring_buffer.TakeChunk();
+  ASSERT_NE(nullptr, chunk2);
+
+  for (int i = 0; i < 3; ++i) {
+    TraceRingBuffer::Chunk* bankrupcy_chunk = ring_buffer.TakeChunk();
+    ASSERT_NE(nullptr, bankrupcy_chunk);
+    ASSERT_FALSE(overlap(bankrupcy_chunk->begin(), bankrupcy_chunk->end(),
+                         storage.get(), storage.get() + kBufferSize));
+
+    // Make sure that the memory of the bankrupty chunk can be dereferenced.
+    memset(bankrupcy_chunk->begin(), 0, kChunkSize);
+  }
+
+  // Return a chunk and check that the ring buffer is not bankrupt anymore.
+  ring_buffer.ReturnChunk(chunk2, 42);
+  TraceRingBuffer::Chunk* chunk = ring_buffer.TakeChunk();
+  ASSERT_NE(nullptr, chunk);
+  ASSERT_TRUE(overlap(chunk->begin(), chunk->end(), storage.get(),
+                      storage.get() + kBufferSize));
+}
+
+}  // namespace
+}  // namespace v2
+}  // namespace tracing