Include extension descriptor into the trace

Change-Id: I23657194899a2258e39596056b03a53b2082aa2c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2403484
Commit-Queue: Andrew Shulaev <ddrone@google.com>
Reviewed-by: Eric Seckler <eseckler@chromium.org>
Cr-Commit-Position: refs/heads/master@{#818436}

base/tracing/protos/resources.grd

@@ -1,7 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <grit base_dir="." latest_public_release="0" current_release="1">
   <outputs>
-    <output filename="grit/tracing_proto_resources.h" type="rc_header" />
+    <output filename="grit/tracing_proto_resources.h" type="rc_header">
+      <emit emit_type="prepend"></emit>
+    </output>
     <output filename="tracing_proto_resources.pak" type="data_package" />
   </outputs>
   <release seq="1">

chrome/chrome_paks.gni

@@ -89,6 +89,7 @@ template("chrome_extra_paks") {
                            ])
     output = "${invoker.output_dir}/resources.pak"
     sources = [
+      "$root_gen_dir/base/tracing/protos/tracing_proto_resources.pak",
       "$root_gen_dir/chrome/browser_resources.pak",
       "$root_gen_dir/chrome/chrome_unscaled_resources.pak",
       "$root_gen_dir/chrome/common_resources.pak",
@@ -104,6 +105,7 @@ template("chrome_extra_paks") {
       "$root_gen_dir/ui/resources/webui_resources.pak",
     ]
     deps = [
+      "//base/tracing/protos:chrome_track_event_resources",
       "//chrome/app/theme:chrome_unscaled_resources",
       "//chrome/browser:resources",
       "//chrome/common:resources",

content/browser/BUILD.gn

@@ -48,6 +48,7 @@ source_set("browser") {
     "//base:base_static",
     "//base:clang_profiling_buildflags",
     "//base/third_party/dynamic_annotations",
+    "//base/tracing/protos:chrome_track_event_resources",
     "//build:branding_buildflags",
     "//build:chromecast_buildflags",
     "//build:chromeos_buildflags",

content/browser/tracing/tracing_controller_impl.cc

@@ -22,6 +22,7 @@
 #include "base/system/sys_info.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_config.h"
+#include "base/tracing/protos/grit/tracing_proto_resources.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/tracing/common/trace_startup_config.h"
@@ -42,10 +43,14 @@
 #include "net/base/network_change_notifier.h"
 #include "services/tracing/public/cpp/perfetto/perfetto_config.h"
 #include "services/tracing/public/cpp/perfetto/perfetto_traced_process.h"
+#include "services/tracing/public/cpp/perfetto/trace_event_data_source.h"
 #include "services/tracing/public/cpp/trace_event_agent.h"
 #include "services/tracing/public/cpp/traced_process_impl.h"
 #include "services/tracing/public/cpp/tracing_features.h"
 #include "services/tracing/public/mojom/constants.mojom.h"
+#include "third_party/perfetto/include/perfetto/protozero/message.h"
+#include "third_party/perfetto/protos/perfetto/trace/extension_descriptor.pbzero.h"
+#include "third_party/perfetto/protos/perfetto/trace/trace_packet.pbzero.h"
 #include "v8/include/v8-version-string.h"
 
 #if defined(OS_CHROMEOS)
@@ -219,6 +224,9 @@ void TracingControllerImpl::AddAgents() {
         base::BindRepeating(&TracingDelegate::GenerateMetadataDict,
                             base::Unretained(delegate_.get())));
   }
+  tracing::TraceEventMetadataSource::GetInstance()->AddGeneratorFunction(
+      base::BindRepeating(&TracingControllerImpl::GenerateMetadataPacket,
+                          base::Unretained(this)));
 #if defined(OS_ANDROID)
   tracing::PerfettoTracedProcess::Get()->AddDataSource(
       tracing::JavaHeapProfiler::GetInstance());
@@ -233,6 +241,23 @@ void TracingControllerImpl::ConnectToServiceIfNeeded() {
   }
 }
 
+void TracingControllerImpl::GenerateMetadataPacket(
+    perfetto::protos::pbzero::TracePacket* handle,
+    bool privacy_filtering_enabled) {
+  if (privacy_filtering_enabled)
+    return;
+
+  auto* extension_descriptor = handle->BeginNestedMessage<protozero::Message>(
+      perfetto::protos::pbzero::TracePacket::kExtensionDescriptorFieldNumber);
+  scoped_refptr<base::RefCountedMemory> descriptor_bytes(
+      GetContentClient()->GetDataResourceBytes(chrome_track_event_descriptor));
+  if (!descriptor_bytes)
+    return;
+  extension_descriptor->AppendBytes(
+      perfetto::protos::pbzero::ExtensionDescriptor::kExtensionSetFieldNumber,
+      descriptor_bytes->data(), descriptor_bytes->size());
+}
+
 // Can be called on any thread.
 std::unique_ptr<base::DictionaryValue>
 TracingControllerImpl::GenerateMetadataDict() {

content/browser/tracing/tracing_controller_impl.h

@@ -21,6 +21,14 @@
 #include "mojo/public/cpp/system/data_pipe_drainer.h"
 #include "services/tracing/public/mojom/perfetto_service.mojom.h"
 
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+class TracePacket;
+}  // namespace pbzero
+}  // namespace protos
+}  // namespace perfetto
+
 namespace base {
 
 namespace trace_event {
@@ -100,6 +108,8 @@ class TracingControllerImpl : public TracingController,
   void AddAgents();
   void ConnectToServiceIfNeeded();
   std::unique_ptr<base::DictionaryValue> GenerateMetadataDict();
+  void GenerateMetadataPacket(perfetto::protos::pbzero::TracePacket* packet,
+                              bool privacy_filtering_enabled);
 
   // mojo::DataPipeDrainer::Client
   void OnDataAvailable(const void* data, size_t num_bytes) override;

services/tracing/public/cpp/perfetto/trace_event_data_source.cc

@@ -48,6 +48,7 @@
 #include "services/tracing/public/mojom/constants.mojom.h"
 #include "third_party/perfetto/include/perfetto/ext/tracing/core/shared_memory_arbiter.h"
 #include "third_party/perfetto/include/perfetto/ext/tracing/core/trace_writer.h"
+#include "third_party/perfetto/include/perfetto/protozero/message.h"
 #include "third_party/perfetto/include/perfetto/tracing/track.h"
 #include "third_party/perfetto/include/perfetto/tracing/track_event_interned_data_index.h"
 #include "third_party/perfetto/protos/perfetto/trace/chrome/chrome_metadata.pbzero.h"
@@ -170,6 +171,13 @@ void TraceEventMetadataSource::AddGeneratorFunction(
   GenerateMetadataFromGenerator(generator);
 }
 
+void TraceEventMetadataSource::AddGeneratorFunction(
+    PacketGeneratorFunction generator) {
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
+  packet_generator_functions_.push_back(generator);
+  GenerateMetadataPacket(generator);
+}
+
 std::unique_ptr<base::DictionaryValue>
 TraceEventMetadataSource::GenerateTraceConfigMetadataDict() {
   AutoLockWithDeferredTaskPosting lock(lock_);
@@ -211,6 +219,22 @@ void TraceEventMetadataSource::GenerateMetadataFromGenerator(
   generator.Run(chrome_metadata, privacy_filtering_enabled_);
 }
 
+void TraceEventMetadataSource::GenerateMetadataPacket(
+    const TraceEventMetadataSource::PacketGeneratorFunction& generator) {
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
+  perfetto::TraceWriter::TracePacketHandle trace_packet;
+  {
+    AutoLockWithDeferredTaskPosting lock(lock_);
+    if (!emit_metadata_at_start_ || !trace_writer_)
+      return;
+    trace_packet = trace_writer_->NewTracePacket();
+  }
+  trace_packet->set_timestamp(
+      TRACE_TIME_TICKS_NOW().since_origin().InNanoseconds());
+  trace_packet->set_timestamp_clock_id(kTraceClockId);
+  generator.Run(trace_packet.get(), privacy_filtering_enabled_);
+}
+
 void TraceEventMetadataSource::GenerateJsonMetadataFromGenerator(
     const TraceEventMetadataSource::JsonMetadataGeneratorFunction& generator,
     ChromeEventBundle* event_bundle) {
@@ -288,16 +312,29 @@ void TraceEventMetadataSource::GenerateMetadata(
         json_generators,
     std::unique_ptr<
         std::vector<TraceEventMetadataSource::MetadataGeneratorFunction>>
-        proto_generators) {
+        proto_generators,
+    std::unique_ptr<
+        std::vector<TraceEventMetadataSource::PacketGeneratorFunction>>
+        packet_generators) {
   DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
-  TracePacketHandle trace_packet;
+
+  perfetto::TraceWriter* trace_writer;
   bool privacy_filtering_enabled;
   {
     AutoLockWithDeferredTaskPosting lock(lock_);
-    trace_packet = trace_writer_->NewTracePacket();
+    trace_writer = trace_writer_.get();
     privacy_filtering_enabled = privacy_filtering_enabled_;
   }
 
+  for (auto& generator : *packet_generators) {
+    TracePacketHandle generator_trace_packet = trace_writer->NewTracePacket();
+    generator_trace_packet->set_timestamp(
+        TRACE_TIME_TICKS_NOW().since_origin().InNanoseconds());
+    generator_trace_packet->set_timestamp_clock_id(kTraceClockId);
+    generator.Run(generator_trace_packet.get(), privacy_filtering_enabled);
+  }
+
+  TracePacketHandle trace_packet = trace_writer_->NewTracePacket();
   trace_packet->set_timestamp(
       TRACE_TIME_TICKS_NOW().since_origin().InNanoseconds());
   trace_packet->set_timestamp_clock_id(kTraceClockId);
@@ -324,6 +361,8 @@ void TraceEventMetadataSource::StartTracing(
       std::make_unique<std::vector<JsonMetadataGeneratorFunction>>();
   auto proto_generators =
       std::make_unique<std::vector<MetadataGeneratorFunction>>();
+  auto packet_generators =
+      std::make_unique<std::vector<PacketGeneratorFunction>>();
   {
     AutoLockWithDeferredTaskPosting lock(lock_);
     privacy_filtering_enabled_ =
@@ -338,6 +377,7 @@ void TraceEventMetadataSource::StartTracing(
         emit_metadata_at_start_ = true;
         *json_generators = json_generator_functions_;
         *proto_generators = generator_functions_;
+        *packet_generators = packet_generator_functions_;
         break;
       }
       case TraceRecordMode::RECORD_CONTINUOUSLY:
@@ -353,7 +393,8 @@ void TraceEventMetadataSource::StartTracing(
       FROM_HERE,
       base::BindOnce(&TraceEventMetadataSource::GenerateMetadata,
                      base::Unretained(this), std::move(json_generators),
-                     std::move(proto_generators)));
+                     std::move(proto_generators),
+                     std::move(packet_generators)));
 }
 
 void TraceEventMetadataSource::StopTracing(
@@ -371,9 +412,13 @@ void TraceEventMetadataSource::StopTracing(
       auto proto_generators =
           std::make_unique<std::vector<MetadataGeneratorFunction>>();
       *proto_generators = generator_functions_;
+      auto packet_generators =
+          std::make_unique<std::vector<PacketGeneratorFunction>>();
+      *packet_generators = packet_generator_functions_;
       maybe_generate_task = base::BindOnce(
           &TraceEventMetadataSource::GenerateMetadata, base::Unretained(this),
-          std::move(json_generators), std::move(proto_generators));
+          std::move(json_generators), std::move(proto_generators),
+          std::move(packet_generators));
     }
   }
   // Even when not generating metadata, make sure the metadata generate task

services/tracing/public/cpp/perfetto/trace_event_data_source.h

@@ -71,12 +71,17 @@ class COMPONENT_EXPORT(TRACING_CPP) TraceEventMetadataSource
       perfetto::protos::pbzero::ChromeMetadataPacket*,
       bool /* privacy_filtering_enabled */)>;
 
+  using PacketGeneratorFunction =
+      base::RepeatingCallback<void(perfetto::protos::pbzero::TracePacket*,
+                                   bool /* privacy_filtering_enabled */)>;
+
   // Any callbacks passed here will be called when tracing. Note that if tracing
   // is enabled while calling this method, the callback may be invoked
   // directly.
   void AddGeneratorFunction(JsonMetadataGeneratorFunction generator);
   // Same as above, but for filling in proto format.
   void AddGeneratorFunction(MetadataGeneratorFunction generator);
+  void AddGeneratorFunction(PacketGeneratorFunction generator);
   // For background tracing, the legacy crash uploader needs
   // metadata fields to be uploaded as POST args in addition to being
   // embedded in the trace. TODO(oysteine): Remove when only the
@@ -102,18 +107,26 @@ class COMPONENT_EXPORT(TRACING_CPP) TraceEventMetadataSource
   void GenerateMetadata(
       std::unique_ptr<std::vector<JsonMetadataGeneratorFunction>>
           json_generators,
-      std::unique_ptr<std::vector<MetadataGeneratorFunction>> proto_generators);
+      std::unique_ptr<std::vector<MetadataGeneratorFunction>> proto_generators,
+      std::unique_ptr<std::vector<PacketGeneratorFunction>> packet_generators);
   void GenerateMetadataFromGenerator(
       const MetadataGeneratorFunction& generator);
   void GenerateJsonMetadataFromGenerator(
       const JsonMetadataGeneratorFunction& generator,
       perfetto::protos::pbzero::ChromeEventBundle* event_bundle);
+  void GenerateMetadataPacket(
+      const TraceEventMetadataSource::PacketGeneratorFunction& generator);
   std::unique_ptr<base::DictionaryValue> GenerateTraceConfigMetadataDict();
 
   // All members are protected by |lock_|.
+  // TODO(crbug.com/1138893): Change annotations to GUARDED_BY
   base::Lock lock_;
-  std::vector<JsonMetadataGeneratorFunction> json_generator_functions_;
-  std::vector<MetadataGeneratorFunction> generator_functions_;
+  std::vector<JsonMetadataGeneratorFunction> json_generator_functions_
+      GUARDED_BY_FIXME(lock_);
+  std::vector<MetadataGeneratorFunction> generator_functions_
+      GUARDED_BY_FIXME(lock_);
+  std::vector<PacketGeneratorFunction> packet_generator_functions_
+      GUARDED_BY_FIXME(lock_);
 
   const scoped_refptr<base::SequencedTaskRunner> origin_task_runner_;