// services/tracing/public/mojom/perfetto_service.mojom-shared-internal.h is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef SERVICES_TRACING_PUBLIC_MOJOM_PERFETTO_SERVICE_MOJOM_SHARED_INTERNAL_H_
#define SERVICES_TRACING_PUBLIC_MOJOM_PERFETTO_SERVICE_MOJOM_SHARED_INTERNAL_H_
#include "mojo/public/cpp/bindings/lib/array_internal.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/message_fragment.h"
#include "mojo/public/mojom/base/byte_string.mojom-shared-internal.h"
#include "mojo/public/mojom/base/file.mojom-shared-internal.h"
#include "mojo/public/mojom/base/shared_memory.mojom-shared-internal.h"
#include "mojo/public/mojom/base/token.mojom-shared-internal.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-shared-internal.h"
#include "mojo/public/cpp/bindings/lib/native_enum_data.h"
#include "mojo/public/interfaces/bindings/native_struct.mojom-shared-internal.h"
#include "base/component_export.h"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace tracing::mojom {
namespace internal {
class ChunksToMove_Data;
class ChunkPatch_Data;
class ChunksToPatch_Data;
class CommitDataRequest_Data;
class ChromeConfig_Data;
class ConsoleConfig_Data;
class InterceptorConfig_Data;
class DataSourceConfig_Data;
class DataSourceRegistration_Data;
class BufferConfig_Data;
class DataSource_Data;
class PerfettoBuiltinDataSource_Data;
class IncrementalStateConfig_Data;
class TraceConfig_Data;

struct ConsoleOutput_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct BufferFillPolicy_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct TracingClientPriority_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

#pragma pack(push, 1)
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) ChunksToMove_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t page;
  uint32_t chunk;
  uint32_t target_buffer;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<ChunksToMove_Data>;

  ChunksToMove_Data();
  ~ChunksToMove_Data() = delete;
};
static_assert(sizeof(ChunksToMove_Data) == 24,
              "Bad sizeof(ChunksToMove_Data)");
// Used by ChunksToMove::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ChunksToMove_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ChunksToMove_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ChunksToMove_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ChunksToMove_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ChunksToMove_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) ChunkPatch_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t offset;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> data;

 private:
  friend class mojo::internal::MessageFragment<ChunkPatch_Data>;

  ChunkPatch_Data();
  ~ChunkPatch_Data() = delete;
};
static_assert(sizeof(ChunkPatch_Data) == 24,
              "Bad sizeof(ChunkPatch_Data)");
// Used by ChunkPatch::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ChunkPatch_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ChunkPatch_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ChunkPatch_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ChunkPatch_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ChunkPatch_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) ChunksToPatch_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t target_buffer;
  uint32_t writer_id;
  uint32_t chunk_id;
  uint8_t has_more_patches : 1;
  uint8_t pad3_[3];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::ChunkPatch_Data>>> patches;

 private:
  friend class mojo::internal::MessageFragment<ChunksToPatch_Data>;

  ChunksToPatch_Data();
  ~ChunksToPatch_Data() = delete;
};
static_assert(sizeof(ChunksToPatch_Data) == 32,
              "Bad sizeof(ChunksToPatch_Data)");
// Used by ChunksToPatch::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ChunksToPatch_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ChunksToPatch_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ChunksToPatch_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ChunksToPatch_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ChunksToPatch_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) CommitDataRequest_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::ChunksToMove_Data>>> chunks_to_move;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::ChunksToPatch_Data>>> chunks_to_patch;
  uint64_t flush_request_id;

 private:
  friend class mojo::internal::MessageFragment<CommitDataRequest_Data>;

  CommitDataRequest_Data();
  ~CommitDataRequest_Data() = delete;
};
static_assert(sizeof(CommitDataRequest_Data) == 32,
              "Bad sizeof(CommitDataRequest_Data)");
// Used by CommitDataRequest::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct CommitDataRequest_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  CommitDataRequest_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~CommitDataRequest_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<CommitDataRequest_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    CommitDataRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) ChromeConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> trace_config;
  uint8_t privacy_filtering_enabled : 1;
  uint8_t convert_to_legacy_json : 1;
  uint8_t event_package_name_filter_enabled : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<ChromeConfig_Data>;

  ChromeConfig_Data();
  ~ChromeConfig_Data() = delete;
};
static_assert(sizeof(ChromeConfig_Data) == 24,
              "Bad sizeof(ChromeConfig_Data)");
// Used by ChromeConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ChromeConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ChromeConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ChromeConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ChromeConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ChromeConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) ConsoleConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t output;
  uint8_t enable_colors : 1;
  uint8_t padfinal_[3];

 private:
  friend class mojo::internal::MessageFragment<ConsoleConfig_Data>;

  ConsoleConfig_Data();
  ~ConsoleConfig_Data() = delete;
};
static_assert(sizeof(ConsoleConfig_Data) == 16,
              "Bad sizeof(ConsoleConfig_Data)");
// Used by ConsoleConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ConsoleConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ConsoleConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ConsoleConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ConsoleConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ConsoleConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) InterceptorConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  mojo::internal::Pointer<internal::ConsoleConfig_Data> console_config;

 private:
  friend class mojo::internal::MessageFragment<InterceptorConfig_Data>;

  InterceptorConfig_Data();
  ~InterceptorConfig_Data() = delete;
};
static_assert(sizeof(InterceptorConfig_Data) == 24,
              "Bad sizeof(InterceptorConfig_Data)");
// Used by InterceptorConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct InterceptorConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  InterceptorConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~InterceptorConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<InterceptorConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    InterceptorConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) DataSourceConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  uint32_t target_buffer;
  uint32_t trace_duration_ms;
  uint64_t tracing_session_id;
  mojo::internal::Pointer<internal::ChromeConfig_Data> chrome_config;
  mojo::internal::Pointer<internal::InterceptorConfig_Data> interceptor_config;
  mojo::internal::Pointer<mojo::internal::String_Data> legacy_config;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> track_event_config_raw;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> etw_config_raw;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> system_metrics_config_raw;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> histogram_samples_config_raw;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> chromium_sampling_heap_profiler_raw;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> chromium_stack_sampling_profiler_raw;

 private:
  friend class mojo::internal::MessageFragment<DataSourceConfig_Data>;

  DataSourceConfig_Data();
  ~DataSourceConfig_Data() = delete;
};
static_assert(sizeof(DataSourceConfig_Data) == 104,
              "Bad sizeof(DataSourceConfig_Data)");
// Used by DataSourceConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct DataSourceConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  DataSourceConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~DataSourceConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<DataSourceConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    DataSourceConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) DataSourceRegistration_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  uint64_t id;
  uint8_t will_notify_on_start : 1;
  uint8_t will_notify_on_stop : 1;
  uint8_t handles_incremental_state_clear : 1;
  uint8_t pad4_[7];
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> track_event_descriptor_raw;

 private:
  friend class mojo::internal::MessageFragment<DataSourceRegistration_Data>;

  DataSourceRegistration_Data();
  ~DataSourceRegistration_Data() = delete;
};
static_assert(sizeof(DataSourceRegistration_Data) == 40,
              "Bad sizeof(DataSourceRegistration_Data)");
// Used by DataSourceRegistration::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct DataSourceRegistration_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  DataSourceRegistration_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~DataSourceRegistration_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<DataSourceRegistration_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    DataSourceRegistration_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) BufferConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t size_kb;
  int32_t fill_policy;

 private:
  friend class mojo::internal::MessageFragment<BufferConfig_Data>;

  BufferConfig_Data();
  ~BufferConfig_Data() = delete;
};
static_assert(sizeof(BufferConfig_Data) == 16,
              "Bad sizeof(BufferConfig_Data)");
// Used by BufferConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct BufferConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  BufferConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~BufferConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<BufferConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    BufferConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) DataSource_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::DataSourceConfig_Data> config;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> producer_name_filter;

 private:
  friend class mojo::internal::MessageFragment<DataSource_Data>;

  DataSource_Data();
  ~DataSource_Data() = delete;
};
static_assert(sizeof(DataSource_Data) == 24,
              "Bad sizeof(DataSource_Data)");
// Used by DataSource::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct DataSource_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  DataSource_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~DataSource_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<DataSource_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    DataSource_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) PerfettoBuiltinDataSource_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t disable_clock_snapshotting : 1;
  uint8_t disable_trace_config : 1;
  uint8_t disable_system_info : 1;
  uint8_t disable_service_events : 1;
  uint8_t pad3_[3];
  int32_t primary_trace_clock_id;

 private:
  friend class mojo::internal::MessageFragment<PerfettoBuiltinDataSource_Data>;

  PerfettoBuiltinDataSource_Data();
  ~PerfettoBuiltinDataSource_Data() = delete;
};
static_assert(sizeof(PerfettoBuiltinDataSource_Data) == 16,
              "Bad sizeof(PerfettoBuiltinDataSource_Data)");
// Used by PerfettoBuiltinDataSource::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct PerfettoBuiltinDataSource_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  PerfettoBuiltinDataSource_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~PerfettoBuiltinDataSource_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<PerfettoBuiltinDataSource_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    PerfettoBuiltinDataSource_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) IncrementalStateConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t clear_period_ms;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<IncrementalStateConfig_Data>;

  IncrementalStateConfig_Data();
  ~IncrementalStateConfig_Data() = delete;
};
static_assert(sizeof(IncrementalStateConfig_Data) == 16,
              "Bad sizeof(IncrementalStateConfig_Data)");
// Used by IncrementalStateConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct IncrementalStateConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  IncrementalStateConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~IncrementalStateConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<IncrementalStateConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    IncrementalStateConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(TRACING_MOJOM_SHARED) TraceConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::DataSource_Data>>> data_sources;
  mojo::internal::Pointer<internal::PerfettoBuiltinDataSource_Data> perfetto_builtin_data_source;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::BufferConfig_Data>>> buffers;
  mojo::internal::Pointer<internal::IncrementalStateConfig_Data> incremental_state_config;
  uint32_t duration_ms;
  uint8_t write_into_file : 1;
  uint8_t pad5_[3];
  mojo::internal::Pointer<::mojo_base::mojom::internal::Token_Data> trace_uuid;
  mojo::internal::Pointer<::mojo_base::mojom::internal::UnguessableToken_Data> unique_session_name;

 private:
  friend class mojo::internal::MessageFragment<TraceConfig_Data>;

  TraceConfig_Data();
  ~TraceConfig_Data() = delete;
};
static_assert(sizeof(TraceConfig_Data) == 64,
              "Bad sizeof(TraceConfig_Data)");
// Used by TraceConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct TraceConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  TraceConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~TraceConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<TraceConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    TraceConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};

#pragma pack(pop)

}  // namespace internal

}  // tracing::mojom

#endif  // SERVICES_TRACING_PUBLIC_MOJOM_PERFETTO_SERVICE_MOJOM_SHARED_INTERNAL_H_