Add mojo struct traits for perfetto::DataSourceConfig and perfetto::ChromeConfig.

This allows chromium code to use the native perfetto::DataSourceConfig
everywhere rather then having to convert it to a mojo IPC
representation.

We ignore the other config protos in DataSourceConfig because this is
just a mapping inside chromium code so only the chromium proto should be
in use.

In addition we drop the test_config since this typemap is used in
production and we don't need to spend time parsing a test config.

Change-Id: I043a93925a5f31e05a46d7d1b0cc594191d7b726
Reviewed-on: https://chromium-review.googlesource.com/c/1425615Reviewed-by: Yusuke Sato <yusukes@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: oysteine <oysteine@chromium.org>
Reviewed-by: Sami Kyöstilä <skyostil@chromium.org>
Commit-Queue: Stephen Nusko <nuskos@chromium.org>
Auto-Submit: Stephen Nusko <nuskos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#629569}

chrome/browser/chromeos/arc/tracing/arc_tracing_bridge.cc

@@ -88,7 +88,7 @@ class ArcTracingDataSource : public tracing::ProducerClient::DataSourceBase {
       // We're currently tracing, so start the new bridge, too.
       // |this| never gets destructed, so it's OK to bind an unretained pointer.
       bridge->StartTracing(
-          data_source_config_.trace_config,
+          data_source_config_.chrome_config().trace_config(),
           base::BindOnce(&ArcTracingDataSource::OnTracingStartedOnUI,
                          base::Unretained(this)));
     }
@@ -120,7 +120,7 @@ class ArcTracingDataSource : public tracing::ProducerClient::DataSourceBase {
   // tracing::ProducerClient::DataSourceBase.
   void StartTracing(
       tracing::ProducerClient* producer_client,
-      const tracing::mojom::DataSourceConfig& data_source_config) override {
+      const perfetto::DataSourceConfig& data_source_config) override {
     // |this| never gets destructed, so it's OK to bind an unretained pointer.
     // |producer_client| is a singleton that is never destroyed.
     base::PostTaskWithTraits(
@@ -145,9 +145,8 @@ class ArcTracingDataSource : public tracing::ProducerClient::DataSourceBase {
   }
 
   // Starts all registered bridges.
-  void StartTracingOnUI(
-      tracing::ProducerClient* producer_client,
-      const tracing::mojom::DataSourceConfig& data_source_config) {
+  void StartTracingOnUI(tracing::ProducerClient* producer_client,
+                        const perfetto::DataSourceConfig& data_source_config) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
     DCHECK(!producer_client_);
@@ -157,7 +156,7 @@ class ArcTracingDataSource : public tracing::ProducerClient::DataSourceBase {
     for (ArcTracingBridge* bridge : bridges_) {
       // |this| never gets destructed, so it's OK to bind an unretained pointer.
       bridge->StartTracing(
-          data_source_config_.trace_config,
+          data_source_config_.chrome_config().trace_config(),
           base::BindOnce(&ArcTracingDataSource::OnTracingStartedOnUI,
                          base::Unretained(this)));
     }
@@ -223,7 +222,7 @@ class ArcTracingDataSource : public tracing::ProducerClient::DataSourceBase {
     if (!data.empty()) {
       std::unique_ptr<perfetto::TraceWriter> trace_writer =
           producer_client_->CreateTraceWriter(
-              data_source_config_.target_buffer);
+              data_source_config_.target_buffer());
       DCHECK(trace_writer);
       perfetto::TraceWriter::TracePacketHandle trace_packet_handle =
           trace_writer->NewTracePacket();
@@ -267,7 +266,7 @@ class ArcTracingDataSource : public tracing::ProducerClient::DataSourceBase {
   // Called when all bridges have completed stopping, notifying ProducerClient.
   base::OnceClosure stop_complete_callback_;
   tracing::ProducerClient* producer_client_ = nullptr;
-  tracing::mojom::DataSourceConfig data_source_config_;
+  perfetto::DataSourceConfig data_source_config_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcTracingDataSource);
 };

content/browser/tracing/cast_tracing_agent.cc

@@ -165,14 +165,14 @@ class CastDataSource : public tracing::ProducerClient::DataSourceBase {
   // Called from the tracing::ProducerClient on its sequence.
   void StartTracing(
       tracing::ProducerClient* producer_client,
-      const tracing::mojom::DataSourceConfig& data_source_config) override {
+      const perfetto::DataSourceConfig& data_source_config) override {
     DCHECK_CALLED_ON_VALID_SEQUENCE(perfetto_sequence_checker_);
     DCHECK(!producer_client_);
     DCHECK(!session_);
     producer_client_ = producer_client;
-    target_buffer_ = data_source_config.target_buffer;
+    target_buffer_ = data_source_config.target_buffer();
     session_ = std::make_unique<CastSystemTracingSession>(worker_task_runner_);
-    session_->StartTracing(data_source_config.trace_config,
+    session_->StartTracing(data_source_config.chrome_config().trace_config(),
                            base::BindOnce(&CastDataSource::SystemTracerStarted,
                                           base::Unretained(this)));
   }

content/browser/tracing/cros_tracing_agent.cc

@@ -102,7 +102,7 @@ class CrOSDataSource : public tracing::ProducerClient::DataSourceBase {
   // Called from the tracing::ProducerClient on its sequence.
   void StartTracing(
       tracing::ProducerClient* producer_client,
-      const tracing::mojom::DataSourceConfig& data_source_config) override {
+      const perfetto::DataSourceConfig& data_source_config) override {
     base::PostTaskWithTraits(
         FROM_HERE, {BrowserThread::UI},
         base::BindOnce(&CrOSDataSource::StartTracingOnUI,
@@ -131,17 +131,16 @@ class CrOSDataSource : public tracing::ProducerClient::DataSourceBase {
     DETACH_FROM_SEQUENCE(ui_sequence_checker_);
   }
 
-  void StartTracingOnUI(
-      tracing::ProducerClient* producer_client,
-      const tracing::mojom::DataSourceConfig& data_source_config) {
+  void StartTracingOnUI(tracing::ProducerClient* producer_client,
+                        const perfetto::DataSourceConfig& data_source_config) {
     DCHECK_CALLED_ON_VALID_SEQUENCE(ui_sequence_checker_);
     DCHECK(!producer_client_);
     DCHECK(!session_);
     producer_client_ = producer_client;
-    target_buffer_ = data_source_config.target_buffer;
+    target_buffer_ = data_source_config.target_buffer();
     session_ = std::make_unique<CrOSSystemTracingSession>();
     session_->StartTracing(
-        data_source_config.trace_config,
+        data_source_config.chrome_config().trace_config(),
         base::BindOnce(&CrOSDataSource::SystemTracerStartedOnUI,
                        base::Unretained(this)));
   }

services/tracing/perfetto/producer_host.cc

@@ -68,14 +68,9 @@ void ProducerHost::SetupDataSource(perfetto::DataSourceInstanceID,
 
 void ProducerHost::StartDataSource(perfetto::DataSourceInstanceID id,
                                    const perfetto::DataSourceConfig& config) {
-  // TODO(oysteine): Send full DataSourceConfig, not just the name/target_buffer
-  // and Chrome Tracing string.
-  auto data_source_config = mojom::DataSourceConfig::New();
-  data_source_config->name = config.name();
-  data_source_config->target_buffer = config.target_buffer();
-
-  data_source_config->trace_config = config.chrome_config().trace_config();
-  producer_client_->StartDataSource(id, std::move(data_source_config));
+  // The type traits will send the base fields in the DataSourceConfig and also
+  // the ChromeConfig other configs are dropped.
+  producer_client_->StartDataSource(id, config);
 }
 
 void ProducerHost::StopDataSource(perfetto::DataSourceInstanceID id) {

services/tracing/perfetto/test_utils.cc

@@ -39,9 +39,9 @@ void TestDataSource::WritePacketBigly() {
 
 void TestDataSource::StartTracing(
     ProducerClient* producer_client,
-    const mojom::DataSourceConfig& data_source_config) {
+    const perfetto::DataSourceConfig& data_source_config) {
   producer_client_ = producer_client;
-  target_buffer_ = data_source_config.target_buffer;
+  target_buffer_ = data_source_config.target_buffer();
 
   if (send_packet_count_ > 0) {
     std::unique_ptr<perfetto::TraceWriter> writer =
@@ -82,7 +82,7 @@ void MockProducerClient::SetupDataSource(const std::string& data_source_name) {
 
 void MockProducerClient::StartDataSource(
     uint64_t id,
-    mojom::DataSourceConfigPtr data_source_config) {
+    const perfetto::DataSourceConfig& data_source_config) {
   ProducerClient::StartDataSource(id, std::move(data_source_config));
 
   if (client_enabled_callback_) {

services/tracing/perfetto/test_utils.h

@@ -29,8 +29,9 @@ class TestDataSource : public ProducerClient::DataSourceBase {
   void WritePacketBigly();
 
   // DataSourceBase implementation
-  void StartTracing(ProducerClient* producer_client,
-                    const mojom::DataSourceConfig& data_source_config) override;
+  void StartTracing(
+      ProducerClient* producer_client,
+      const perfetto::DataSourceConfig& data_source_config) override;
   void StopTracing(
       base::OnceClosure stop_complete_callback = base::OnceClosure()) override;
   void Flush(base::RepeatingClosure flush_complete_callback) override;
@@ -51,8 +52,9 @@ class MockProducerClient : public ProducerClient {
 
   void SetupDataSource(const std::string& data_source_name);
 
-  void StartDataSource(uint64_t id,
-                       mojom::DataSourceConfigPtr data_source_config) override;
+  void StartDataSource(
+      uint64_t id,
+      const perfetto::DataSourceConfig& data_source_config) override;
 
   void StopDataSource(uint64_t id, StopDataSourceCallback callback) override;
 

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

@@ -45,7 +45,7 @@ ProducerClient::DataSourceBase::~DataSourceBase() = default;
 void ProducerClient::DataSourceBase::StartTracingWithID(
     uint64_t data_source_id,
     ProducerClient* producer_client,
-    const mojom::DataSourceConfig& data_source_config) {
+    const perfetto::DataSourceConfig& data_source_config) {
   data_source_id_ = data_source_id;
   StartTracing(producer_client, data_source_config);
 }
@@ -180,14 +180,13 @@ void ProducerClient::OnTracingStart(
 
 void ProducerClient::StartDataSource(
     uint64_t id,
-    mojom::DataSourceConfigPtr data_source_config) {
+    const perfetto::DataSourceConfig& data_source_config) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  DCHECK(data_source_config);
 
   // TODO(oysteine): Support concurrent tracing sessions.
   for (auto* data_source : data_sources_) {
-    if (data_source->name() == data_source_config->name) {
-      data_source->StartTracingWithID(id, this, *data_source_config);
+    if (data_source->name() == data_source_config.name()) {
+      data_source->StartTracingWithID(id, this, data_source_config);
       return;
     }
   }

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

@@ -50,13 +50,14 @@ class COMPONENT_EXPORT(TRACING_CPP) ProducerClient
     explicit DataSourceBase(const std::string& name);
     virtual ~DataSourceBase();
 
-    void StartTracingWithID(uint64_t data_source_id,
+    void StartTracingWithID(
+        uint64_t data_source_id,
         ProducerClient* producer_client,
-                            const mojom::DataSourceConfig& data_source_config);
+        const perfetto::DataSourceConfig& data_source_config);
 
     virtual void StartTracing(
         ProducerClient* producer_client,
-        const mojom::DataSourceConfig& data_source_config) = 0;
+        const perfetto::DataSourceConfig& data_source_config) = 0;
     virtual void StopTracing(
         base::OnceClosure stop_complete_callback = base::OnceClosure()) = 0;
 
@@ -108,8 +109,9 @@ class COMPONENT_EXPORT(TRACING_CPP) ProducerClient
   // Called through Mojo by the ProducerHost on the service-side to control
   // tracing and toggle specific DataSources.
   void OnTracingStart(mojo::ScopedSharedBufferHandle shared_memory) override;
-  void StartDataSource(uint64_t id,
-                       mojom::DataSourceConfigPtr data_source_config) override;
+  void StartDataSource(
+      uint64_t id,
+      const perfetto::DataSourceConfig& data_source_config) override;
 
   void StopDataSource(uint64_t id, StopDataSourceCallback callback) override;
   void Flush(uint64_t flush_request_id,

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

@@ -98,11 +98,11 @@ void TraceEventMetadataSource::GenerateMetadata(
 
 void TraceEventMetadataSource::StartTracing(
     ProducerClient* producer_client,
-    const mojom::DataSourceConfig& data_source_config) {
+    const perfetto::DataSourceConfig& data_source_config) {
   // TODO(eseckler): Once we support streaming of trace data, it would make
   // sense to emit the metadata on startup, so the UI can display it right away.
   trace_writer_ =
-      producer_client->CreateTraceWriter(data_source_config.target_buffer);
+      producer_client->CreateTraceWriter(data_source_config.target_buffer());
 }
 
 void TraceEventMetadataSource::StopTracing(
@@ -497,26 +497,27 @@ void TraceEventDataSource::SetupStartupTracing() {
 
 void TraceEventDataSource::StartTracing(
     ProducerClient* producer_client,
-    const mojom::DataSourceConfig& data_source_config) {
+    const perfetto::DataSourceConfig& data_source_config) {
   std::unique_ptr<perfetto::StartupTraceWriterRegistry> unbound_writer_registry;
   {
     base::AutoLock lock(lock_);
 
     DCHECK(!producer_client_);
     producer_client_ = producer_client;
-    target_buffer_ = data_source_config.target_buffer;
+    target_buffer_ = data_source_config.target_buffer();
     // Reduce lock contention by binding the registry without holding the lock.
     unbound_writer_registry = std::move(startup_writer_registry_);
   }
 
   if (unbound_writer_registry) {
     producer_client->BindStartupTraceWriterRegistry(
-        std::move(unbound_writer_registry), data_source_config.target_buffer);
+        std::move(unbound_writer_registry), data_source_config.target_buffer());
   } else {
     RegisterWithTraceLog();
   }
 
-  auto trace_config = TraceConfig(data_source_config.trace_config);
+  auto trace_config =
+      TraceConfig(data_source_config.chrome_config().trace_config());
   TraceLog::GetInstance()->SetEnabled(trace_config, TraceLog::RECORDING_MODE);
   ResetHistograms(trace_config);
 }

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

@@ -39,8 +39,9 @@ class COMPONENT_EXPORT(TRACING_CPP) TraceEventMetadataSource
 
   // ProducerClient::DataSourceBase implementation, called by
   // ProducerClent.
-  void StartTracing(ProducerClient* producer_client,
-                    const mojom::DataSourceConfig& data_source_config) override;
+  void StartTracing(
+      ProducerClient* producer_client,
+      const perfetto::DataSourceConfig& data_source_config) override;
   void StopTracing(base::OnceClosure stop_complete_callback) override;
   void Flush(base::RepeatingClosure flush_complete_callback) override;
 
@@ -78,8 +79,9 @@ class COMPONENT_EXPORT(TRACING_CPP) TraceEventDataSource
   // which will clear the stored pointer to it, before it
   // gets destroyed. ProducerClient::CreateTraceWriter can be
   // called by the TraceEventDataSource on any thread.
-  void StartTracing(ProducerClient* producer_client,
-                    const mojom::DataSourceConfig& data_source_config) override;
+  void StartTracing(
+      ProducerClient* producer_client,
+      const perfetto::DataSourceConfig& data_source_config) override;
 
   // Called from the ProducerClient.
   void StopTracing(base::OnceClosure stop_complete_callback) override;

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

@@ -224,9 +224,8 @@ class TraceEventDataSourceTest : public testing::Test {
     producer_client_ = std::make_unique<MockProducerClient>(
         scoped_task_environment_.GetMainThreadTaskRunner());
 
-    auto data_source_config = mojom::DataSourceConfig::New();
-    TraceEventDataSource::GetInstance()->StartTracing(producer_client(),
-                                                      *data_source_config);
+    TraceEventDataSource::GetInstance()->StartTracing(
+        producer_client(), perfetto::DataSourceConfig());
   }
 
   MockProducerClient* producer_client() { return producer_client_.get(); }
@@ -295,8 +294,8 @@ TEST_F(TraceEventDataSourceTest, MetadataSourceBasicTypes) {
 
   CreateTraceEventDataSource();
 
-  auto data_source_config = mojom::DataSourceConfig::New();
-  metadata_source->StartTracing(producer_client(), *data_source_config);
+  metadata_source->StartTracing(producer_client(),
+                                perfetto::DataSourceConfig());
 
   base::RunLoop wait_for_stop;
   metadata_source->StopTracing(wait_for_stop.QuitClosure());

services/tracing/public/mojom/chrome_config_struct_traits.cc

+// Copyright 2019 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 "services/tracing/public/mojom/chrome_config_struct_traits.h"
+
+#include <utility>
+
+namespace mojo {
+// static
+bool StructTraits<
+    tracing::mojom::ChromeConfigDataView,
+    perfetto::ChromeConfig>::Read(tracing::mojom::ChromeConfigDataView data,
+                                  perfetto::ChromeConfig* out) {
+  std::string config;
+  if (!data.ReadTraceConfig(&config)) {
+    return false;
+  }
+  out->set_trace_config(std::move(config));
+  return true;
+}
+}  // namespace mojo

services/tracing/public/mojom/chrome_config_struct_traits.h

+// Copyright 2019 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.
+
+// This defines mappings from mojom IPC representations to their native perfetto
+// equivalents.
+
+#ifndef SERVICES_TRACING_PUBLIC_MOJOM_CHROME_CONFIG_STRUCT_TRAITS_H_
+#define SERVICES_TRACING_PUBLIC_MOJOM_CHROME_CONFIG_STRUCT_TRAITS_H_
+
+#include <string>
+
+#include "mojo/public/cpp/bindings/struct_traits.h"
+#include "services/tracing/public/mojom/perfetto_service.mojom.h"
+#include "third_party/perfetto/include/perfetto/tracing/core/chrome_config.h"
+
+namespace mojo {
+template <>
+class StructTraits<tracing::mojom::ChromeConfigDataView,
+                   perfetto::ChromeConfig> {
+ public:
+  static const std::string& trace_config(const perfetto::ChromeConfig& src) {
+    return src.trace_config();
+  }
+
+  static bool Read(tracing::mojom::ChromeConfigDataView data,
+                   perfetto::ChromeConfig* out);
+};
+}  // namespace mojo
+#endif  // SERVICES_TRACING_PUBLIC_MOJOM_CHROME_CONFIG_STRUCT_TRAITS_H_

services/tracing/public/mojom/data_source_config_struct_traits.cc

+// Copyright 2019 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 "services/tracing/public/mojom/data_source_config_struct_traits.h"
+
+#include <utility>
+
+#include "services/tracing/public/mojom/chrome_config_struct_traits.h"
+
+namespace mojo {
+bool StructTraits<tracing::mojom::DataSourceConfigDataView,
+                  perfetto::DataSourceConfig>::
+    Read(tracing::mojom::DataSourceConfigDataView data,
+         perfetto::DataSourceConfig* out) {
+  std::string name, legacy_config;
+  perfetto::ChromeConfig config;
+  if (!data.ReadName(&name) || !data.ReadChromeConfig(&config) ||
+      !data.ReadLegacyConfig(&legacy_config)) {
+    return false;
+  }
+  out->set_name(name);
+  out->set_target_buffer(data.target_buffer());
+  out->set_trace_duration_ms(data.trace_duration_ms());
+  out->set_tracing_session_id(data.tracing_session_id());
+  *out->mutable_chrome_config() = std::move(config);
+  out->set_legacy_config(legacy_config);
+  return true;
+}
+}  // namespace mojo

services/tracing/public/mojom/data_source_config_struct_traits.h

+// Copyright 2019 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.
+
+// This defines mappings from mojom IPC representations to their native perfetto
+// equivalents.
+
+#ifndef SERVICES_TRACING_PUBLIC_MOJOM_DATA_SOURCE_CONFIG_STRUCT_TRAITS_H_
+#define SERVICES_TRACING_PUBLIC_MOJOM_DATA_SOURCE_CONFIG_STRUCT_TRAITS_H_
+
+#include <string>
+
+#include "mojo/public/cpp/bindings/struct_traits.h"
+#include "services/tracing/public/mojom/perfetto_service.mojom.h"
+#include "third_party/perfetto/include/perfetto/tracing/core/chrome_config.h"
+#include "third_party/perfetto/include/perfetto/tracing/core/data_source_config.h"
+
+namespace mojo {
+template <>
+class StructTraits<tracing::mojom::DataSourceConfigDataView,
+                   perfetto::DataSourceConfig> {
+ public:
+  static const std::string& name(const perfetto::DataSourceConfig& src) {
+    return src.name();
+  }
+  static uint32_t target_buffer(const perfetto::DataSourceConfig& src) {
+    return src.target_buffer();
+  }
+  static uint32_t trace_duration_ms(const perfetto::DataSourceConfig& src) {
+    return src.trace_duration_ms();
+  }
+  static uint64_t tracing_session_id(const perfetto::DataSourceConfig& src) {
+    return src.tracing_session_id();
+  }
+  static const perfetto::ChromeConfig& chrome_config(
+      const perfetto::DataSourceConfig& src) {
+    return src.chrome_config();
+  }
+  static const std::string& legacy_config(
+      const perfetto::DataSourceConfig& src) {
+    return src.legacy_config();
+  }
+
+  static bool Read(tracing::mojom::DataSourceConfigDataView data,
+                   perfetto::DataSourceConfig* out);
+};
+}  // namespace mojo
+#endif  // SERVICES_TRACING_PUBLIC_MOJOM_DATA_SOURCE_CONFIG_STRUCT_TRAITS_H_

services/tracing/public/mojom/perfetto_service.mojom

@@ -63,10 +63,22 @@ struct CommitDataRequest {
   uint64 flush_request_id;
 };
 
+// Passed as part of DataSourceConfig
+struct ChromeConfig {
+  // TODO(crbug/928687): Once we've completed removing the old IPC layer we
+  // should convert this into a struct that represents a
+  // base::trace_event::TraceConfig object rather then the json encoded string
+  // used currently.
+  string trace_config;
+};
+
 struct DataSourceConfig {
   string name;
-  string trace_config;
   uint32 target_buffer;
+  uint32 trace_duration_ms;
+  uint64 tracing_session_id;
+  ChromeConfig chrome_config;
+  string legacy_config;
 };
 
 struct DataSourceRegistration {

services/tracing/public/mojom/perfetto_service.typemap

 mojom = "//services/tracing/public/mojom/perfetto_service.mojom"
 public_headers = [
   "//third_party/perfetto/include/perfetto/tracing/core/commit_data_request.h",
+  "//third_party/perfetto/include/perfetto/tracing/core/data_source_config.h",
+  "//third_party/perfetto/include/perfetto/tracing/core/chrome_config.h",
+]
+traits_headers = [
+  "//services/tracing/public/mojom/commit_data_request_struct_traits.h",
+  "//services/tracing/public/mojom/data_source_config_struct_traits.h",
+  "//services/tracing/public/mojom/chrome_config_struct_traits.h",
 ]
-traits_headers =
-    [ "//services/tracing/public/mojom/commit_data_request_struct_traits.h" ]
 sources = [
+  "//services/tracing/public/mojom/chrome_config_struct_traits.cc",
+  "//services/tracing/public/mojom/chrome_config_struct_traits.h",
   "//services/tracing/public/mojom/commit_data_request_struct_traits.cc",
   "//services/tracing/public/mojom/commit_data_request_struct_traits.h",
+  "//services/tracing/public/mojom/data_source_config_struct_traits.cc",
+  "//services/tracing/public/mojom/data_source_config_struct_traits.h",
 ]
 public_deps = [
   "//third_party/perfetto:libperfetto",
@@ -16,4 +25,6 @@ type_mappings = [
   "tracing.mojom.ChunksToMove=perfetto::CommitDataRequest::ChunksToMove",
   "tracing.mojom.ChunkPatch=perfetto::CommitDataRequest::ChunkToPatch::Patch",
   "tracing.mojom.ChunkToPatch=perfetto::CommitDataRequest::ChunkToPatch",
+  "tracing.mojom.DataSourceConfig=perfetto::DataSourceConfig",
+  "tracing.mojom.ChromeConfig=perfetto::ChromeConfig",
 ]