tbV2: fix write_wrap_count under-counting natural wraps

write_wrap_count was only being incremented on the "panic wrap" path
(when the incoming chunk is too big for the remaining tail space and
unread chunks must be evicted to make room). The "natural wrap" path
where wr_ reaches size_ exactly and silently resets to 0 was not
counted. Consequently traces could legitimately show bytes_written
much greater than buffer_size with write_wrap_count = 0, making the
stat unreliable for ring-buffer-pressure diagnostics. V1 counts both
paths; V2 had regressed this.

Fix: introduce a local |wrapped| flag in CopyChunkUntrusted, set it
in both wrap branches, and increment write_wrap_count once at the
end if wrapped is true.

Why a flag instead of incrementing in both places directly: when the
incoming chunk is exactly the buffer size, the panic-wrap path resets
wr_ to 0, the chunk is then written, wr_ advances back to size_, and
the natural-wrap branch fires too. With direct increments in both
places this single CopyChunkUntrusted call would double-count one
logical wrap. The flag collapses both branches into a single
increment per call, matching the proto contract:
  // Num. times the ring buffer wrapped around.

Adds a regression test that exercises both wrap paths and asserts the
counter increments correctly.

Author: sashwinbalaji

src/tracing/service/trace_buffer_v2.cc

@@ -777,6 +777,7 @@ void TraceBufferV2::CopyChunkUntrusted(
   // If there isn't enough room from the given write position: write a padding
   // record to clear the end of the buffer, wrap and start at offset 0.
   const size_t cached_size_to_end = size_to_end();
+  bool wrapped = false;
   if (PERFETTO_UNLIKELY(tbchunk_outer_size > cached_size_to_end)) {
     // If we reached the end of the buffer and we are using discard policy,
     // this is where we stop. This buffer will no longer accept data.
@@ -785,7 +786,7 @@ void TraceBufferV2::CopyChunkUntrusted(
 
     DeleteNextChunksFor(cached_size_to_end);
     wr_ = 0;
-    stats_.set_write_wrap_count(stats_.write_wrap_count() + 1);
+    wrapped = true;
     PERFETTO_DCHECK(size_to_end() >= tbchunk_outer_size);
   }
 
@@ -880,10 +881,15 @@ void TraceBufferV2::CopyChunkUntrusted(
 
   wr_ += tbchunk_outer_size;
   PERFETTO_DCHECK(wr_ <= size_ && wr_ <= used_size_);
-  wr_ = wr_ >= size_ ? 0 : wr_;
+  if (wr_ >= size_) {
+    wr_ = 0;
+    wrapped = true;
+  }
 
   stats_.set_chunks_written(stats_.chunks_written() + 1);
   stats_.set_bytes_written(stats_.bytes_written() + tbchunk_outer_size);
+  if (wrapped)
+    stats_.set_write_wrap_count(stats_.write_wrap_count() + 1);
 
   // We purge SequenceStates(s) only here, because other parts of the readback
   // code (BeginRead()/ReadNextTracePacket()) need to cache SequenceState*

src/tracing/service/trace_buffer_v2_unittest.cc

@@ -2092,6 +2092,42 @@ TEST_F(TraceBufferV2Test, Alignment_ExactBufferBoundaryFragmentation) {
   ASSERT_THAT(ReadPacket(), IsEmpty());
 }
 
+// Verify that write_wrap_count increments on both wrap paths:
+//  - natural wrap: chunk exactly fills to the end of the buffer.
+//  - panic wrap: incoming chunk doesn't fit in the remaining tail space.
+// Packet sizes are chosen so the in-buffer outer_size aligns to the desired
+// values (16-byte alignment; ~2 bytes of varint overhead per fragment).
+TEST_F(TraceBufferV2Test, WriteWrapCount_CountsBothWrapPaths) {
+  // Buffer is aligned up to 4096 bytes minimum by Initialize().
+  ResetBuffer(4096);
+  EXPECT_EQ(0u, trace_buffer()->stats().write_wrap_count());
+
+  // Two 2048-byte chunks fill the buffer exactly. The second one triggers a
+  // natural wrap (wr_ reaches size_ and resets to 0).
+  CreateChunk(ProducerID(1), WriterID(1), ChunkID(0))
+      .AddPacket(2030, 'a')
+      .CopyIntoTraceBuffer();
+  EXPECT_EQ(0u, trace_buffer()->stats().write_wrap_count());
+
+  CreateChunk(ProducerID(1), WriterID(1), ChunkID(1))
+      .AddPacket(2030, 'b')
+      .CopyIntoTraceBuffer();
+  EXPECT_EQ(1u, trace_buffer()->stats().write_wrap_count());
+
+  // Third chunk of 3072 bytes at wr_=0 fits without wrap.
+  CreateChunk(ProducerID(1), WriterID(1), ChunkID(2))
+      .AddPacket(3054, 'c')
+      .CopyIntoTraceBuffer();
+  EXPECT_EQ(1u, trace_buffer()->stats().write_wrap_count());
+
+  // Fourth chunk of 2048 bytes at wr_=3072: doesn't fit (size_to_end=1024),
+  // triggers panic wrap.
+  CreateChunk(ProducerID(1), WriterID(1), ChunkID(3))
+      .AddPacket(2030, 'd')
+      .CopyIntoTraceBuffer();
+  EXPECT_EQ(2u, trace_buffer()->stats().write_wrap_count());
+}
+
 // Test out-of-order patch application with fragmentation
 TEST_F(TraceBufferV2Test, Patching_OutOfOrderPatchesWithFragmentation) {
   ResetBuffer(4096);