Tracing v2: wire up stubs generated by the protozero protoc plugin

components/tracing/core/trace_buffer_writer.cc

 // 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_buffer_writer.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "components/tracing/core/proto_utils.h"
+#include "components/tracing/proto/event.pbzero.h"
 #include "components/tracing/proto/events_chunk.pbzero.h"
 
 namespace tracing {
 namespace v2 {
 
 namespace {
 
 using ChunkProto = pbzero::tracing::proto::EventsChunk;
 
 const size_t kEventPreambleSize = 1 + proto::kMessageLengthFieldSize;
@@ skipping 49 matching lines @@
   // starting a partial event that will fragment immediately after.
   static_assert(kMinEventSize >= proto::kMessageLengthFieldSize + 1,
                 "kMinEventSize too small");
   if (stream_writer_.bytes_available() < kMinEventSize)
     stream_writer_.Reset(AcquireNewChunk(false /* is_fragmenting_event */));
 
   event_.Reset(&stream_writer_);
   WriteEventPreambleForNewChunk(
       stream_writer_.ReserveBytesUnsafe(kEventPreambleSize));
   DCHECK_EQ(stream_writer_.write_ptr(), event_data_start_in_current_chunk_);
-  return TraceEventHandle(static_cast<::tracing::proto::Event*>(&event_));
+  return TraceEventHandle(static_cast<pbzero::tracing::proto::Event*>(&event_));
 }
 
 // This is invoked by the ProtoZeroMessage write methods when reaching the
 // end of the current chunk during a write.
 ContiguousMemoryRange TraceBufferWriter::GetNewBuffer() {
   return AcquireNewChunk(true /* is_fragmenting_event */);
 }
 
 void TraceBufferWriter::FinalizeCurrentChunk(bool is_fragmenting_event) {
   DCHECK(!is_fragmenting_event || chunk_);
@@ skipping 53 matching lines @@
   // Write the protobuf for the chunk header. The generated C++ stub for
   // events_chunk.proto cannot be used here because that would re-enter this
   // class and make this code extremely hard to reason about.
   uint8_t* chunk_proto = new_chunk->payload();
 
   proto::StaticAssertSingleBytePreamble<ChunkProto::kWriterIdFieldNumber>();
   *chunk_proto++ = static_cast<uint8_t>(
       proto::MakeTagVarInt(ChunkProto::kWriterIdFieldNumber));
   chunk_proto = proto::WriteVarInt(writer_id_, chunk_proto);
 
-  proto::StaticAssertSingleBytePreamble<
-      ChunkProto::kSeqIdFieldNumber>();
-  *chunk_proto++ = static_cast<uint8_t>(
-      proto::MakeTagVarInt(ChunkProto::kSeqIdFieldNumber));
+  proto::StaticAssertSingleBytePreamble<ChunkProto::kSeqIdFieldNumber>();
+  *chunk_proto++ =
+      static_cast<uint8_t>(proto::MakeTagVarInt(ChunkProto::kSeqIdFieldNumber));
   chunk_proto = proto::WriteVarInt(chunk_seq_id_, chunk_proto);
 
   if (is_fragmenting_event) {
     proto::StaticAssertSingleBytePreamble<
         ChunkProto::kFirstEventContinuesFromPrevChunkFieldNumber>();
     *chunk_proto++ = static_cast<uint8_t>(proto::MakeTagVarInt(
         ChunkProto::kFirstEventContinuesFromPrevChunkFieldNumber));
     *chunk_proto++ = 1;  // = true.
   }
 
@@ skipping 20 matching lines @@
   proto::StaticAssertSingleBytePreamble<ChunkProto::kEventsFieldNumber>();
   *begin++ = static_cast<uint8_t>(
       proto::MakeTagLengthDelimited(ChunkProto::kEventsFieldNumber));
   ContiguousMemoryRange range = {begin, end};
   event_.set_size_field(range);
   event_data_start_in_current_chunk_ = end;
   return end;
 }
 
 void TraceBufferWriter::Flush() {
+  if (!chunk_)
+    return;
   FinalizeCurrentEvent();
   FinalizeCurrentChunk(false /* is_fragmenting_event */);
   trace_ring_buffer_->ReturnChunk(chunk_);
   chunk_ = nullptr;
 }
 
 }  // namespace v2
 }  // namespace tracing