// services/tracing/public/mojom/perfetto_service.mojom.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "services/tracing/public/mojom/perfetto_service.mojom.h"
#include <math.h>
#include <stdint.h>
#include <utility>
#include "base/debug/alias.h"
#include "base/notreached.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "services/tracing/public/mojom/perfetto_service.mojom-params-data.h"
#include "services/tracing/public/mojom/perfetto_service.mojom-shared-message-ids.h"

#include "services/tracing/public/mojom/perfetto_service.mojom-import-headers.h"
#include "services/tracing/public/mojom/perfetto_service.mojom-test-utils.h"
#include "services/tracing/public/mojom/chrome_config_mojom_traits.h"
#include "services/tracing/public/mojom/commit_data_request_mojom_traits.h"
#include "services/tracing/public/mojom/console_config_mojom_traits.h"
#include "services/tracing/public/mojom/data_source_config_mojom_traits.h"
#include "services/tracing/public/mojom/data_source_descriptor_mojom_traits.h"
#include "services/tracing/public/mojom/interceptor_config_mojom_traits.h"
#include "services/tracing/public/mojom/trace_config_mojom_traits.h"


namespace tracing::mojom {
ChunksToMove::ChunksToMove()
    : page(),
      chunk(),
      target_buffer() {}

ChunksToMove::ChunksToMove(
    uint32_t page_in,
    uint32_t chunk_in,
    uint32_t target_buffer_in)
    : page(std::move(page_in)),
      chunk(std::move(chunk_in)),
      target_buffer(std::move(target_buffer_in)) {}

ChunksToMove::~ChunksToMove() = default;

void ChunksToMove::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "page"), this->page,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "chunk"), this->chunk,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "target_buffer"), this->target_buffer,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ChunksToMove::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ChunkPatch::ChunkPatch()
    : offset(),
      data() {}

ChunkPatch::ChunkPatch(
    uint32_t offset_in,
    const std::string& data_in)
    : offset(std::move(offset_in)),
      data(std::move(data_in)) {}

ChunkPatch::~ChunkPatch() = default;

void ChunkPatch::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "offset"), this->offset,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "data"), this->data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ChunkPatch::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ChunksToPatch::ChunksToPatch()
    : target_buffer(),
      writer_id(),
      chunk_id(),
      patches(),
      has_more_patches() {}

ChunksToPatch::ChunksToPatch(
    uint32_t target_buffer_in,
    uint32_t writer_id_in,
    uint32_t chunk_id_in,
    std::vector<::perfetto::CommitDataRequest::ChunkToPatch::Patch> patches_in,
    bool has_more_patches_in)
    : target_buffer(std::move(target_buffer_in)),
      writer_id(std::move(writer_id_in)),
      chunk_id(std::move(chunk_id_in)),
      patches(std::move(patches_in)),
      has_more_patches(std::move(has_more_patches_in)) {}

ChunksToPatch::~ChunksToPatch() = default;

void ChunksToPatch::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "target_buffer"), this->target_buffer,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "writer_id"), this->writer_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "chunk_id"), this->chunk_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "patches"), this->patches,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::vector<::perfetto::CommitDataRequest::ChunkToPatch::Patch>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "has_more_patches"), this->has_more_patches,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ChunksToPatch::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
CommitDataRequest::CommitDataRequest()
    : chunks_to_move(),
      chunks_to_patch(),
      flush_request_id() {}

CommitDataRequest::CommitDataRequest(
    std::vector<::perfetto::CommitDataRequest::ChunksToMove> chunks_to_move_in,
    std::vector<::perfetto::CommitDataRequest::ChunkToPatch> chunks_to_patch_in,
    uint64_t flush_request_id_in)
    : chunks_to_move(std::move(chunks_to_move_in)),
      chunks_to_patch(std::move(chunks_to_patch_in)),
      flush_request_id(std::move(flush_request_id_in)) {}

CommitDataRequest::~CommitDataRequest() = default;

void CommitDataRequest::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "chunks_to_move"), this->chunks_to_move,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::vector<::perfetto::CommitDataRequest::ChunksToMove>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "chunks_to_patch"), this->chunks_to_patch,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::vector<::perfetto::CommitDataRequest::ChunkToPatch>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "flush_request_id"), this->flush_request_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint64_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool CommitDataRequest::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ChromeConfig::ChromeConfig()
    : trace_config(),
      privacy_filtering_enabled(),
      convert_to_legacy_json(),
      event_package_name_filter_enabled() {}

ChromeConfig::ChromeConfig(
    const std::string& trace_config_in,
    bool privacy_filtering_enabled_in,
    bool convert_to_legacy_json_in,
    bool event_package_name_filter_enabled_in)
    : trace_config(std::move(trace_config_in)),
      privacy_filtering_enabled(std::move(privacy_filtering_enabled_in)),
      convert_to_legacy_json(std::move(convert_to_legacy_json_in)),
      event_package_name_filter_enabled(std::move(event_package_name_filter_enabled_in)) {}

ChromeConfig::~ChromeConfig() = default;

void ChromeConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "trace_config"), this->trace_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "privacy_filtering_enabled"), this->privacy_filtering_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "convert_to_legacy_json"), this->convert_to_legacy_json,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "event_package_name_filter_enabled"), this->event_package_name_filter_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ChromeConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ConsoleConfig::ConsoleConfig()
    : output(),
      enable_colors() {}

ConsoleConfig::ConsoleConfig(
    ConsoleOutput output_in,
    bool enable_colors_in)
    : output(std::move(output_in)),
      enable_colors(std::move(enable_colors_in)) {}

ConsoleConfig::~ConsoleConfig() = default;
size_t ConsoleConfig::Hash(size_t seed) const {
  seed = mojo::internal::Hash(seed, this->output);
  seed = mojo::internal::Hash(seed, this->enable_colors);
  return seed;
}

void ConsoleConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "output"), this->output,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ConsoleOutput>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_colors"), this->enable_colors,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ConsoleConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
InterceptorConfig::InterceptorConfig()
    : name(),
      console_config() {}

InterceptorConfig::InterceptorConfig(
    const std::string& name_in,
    ConsoleConfigPtr console_config_in)
    : name(std::move(name_in)),
      console_config(std::move(console_config_in)) {}

InterceptorConfig::~InterceptorConfig() = default;

void InterceptorConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "console_config"), this->console_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ConsoleConfigPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool InterceptorConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DataSourceConfig::DataSourceConfig()
    : name(),
      target_buffer(),
      trace_duration_ms(),
      tracing_session_id(),
      chrome_config(),
      interceptor_config(),
      legacy_config(),
      track_event_config_raw(),
      etw_config_raw(),
      system_metrics_config_raw(),
      histogram_samples_config_raw(),
      chromium_sampling_heap_profiler_raw(),
      chromium_stack_sampling_profiler_raw() {}

DataSourceConfig::DataSourceConfig(
    const std::string& name_in,
    uint32_t target_buffer_in,
    uint32_t trace_duration_ms_in,
    uint64_t tracing_session_id_in,
    const ::perfetto::ChromeConfig& chrome_config_in,
    InterceptorConfigPtr interceptor_config_in,
    const std::string& legacy_config_in,
    const std::string& track_event_config_raw_in,
    const std::string& etw_config_raw_in,
    const std::string& system_metrics_config_raw_in,
    const std::string& histogram_samples_config_raw_in,
    const std::string& chromium_sampling_heap_profiler_raw_in,
    const std::string& chromium_stack_sampling_profiler_raw_in)
    : name(std::move(name_in)),
      target_buffer(std::move(target_buffer_in)),
      trace_duration_ms(std::move(trace_duration_ms_in)),
      tracing_session_id(std::move(tracing_session_id_in)),
      chrome_config(std::move(chrome_config_in)),
      interceptor_config(std::move(interceptor_config_in)),
      legacy_config(std::move(legacy_config_in)),
      track_event_config_raw(std::move(track_event_config_raw_in)),
      etw_config_raw(std::move(etw_config_raw_in)),
      system_metrics_config_raw(std::move(system_metrics_config_raw_in)),
      histogram_samples_config_raw(std::move(histogram_samples_config_raw_in)),
      chromium_sampling_heap_profiler_raw(std::move(chromium_sampling_heap_profiler_raw_in)),
      chromium_stack_sampling_profiler_raw(std::move(chromium_stack_sampling_profiler_raw_in)) {}

DataSourceConfig::~DataSourceConfig() = default;

void DataSourceConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "target_buffer"), this->target_buffer,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "trace_duration_ms"), this->trace_duration_ms,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tracing_session_id"), this->tracing_session_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint64_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "chrome_config"), this->chrome_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::perfetto::ChromeConfig&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "interceptor_config"), this->interceptor_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type InterceptorConfigPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "legacy_config"), this->legacy_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "track_event_config_raw"), this->track_event_config_raw,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "etw_config_raw"), this->etw_config_raw,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "system_metrics_config_raw"), this->system_metrics_config_raw,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "histogram_samples_config_raw"), this->histogram_samples_config_raw,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "chromium_sampling_heap_profiler_raw"), this->chromium_sampling_heap_profiler_raw,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "chromium_stack_sampling_profiler_raw"), this->chromium_stack_sampling_profiler_raw,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DataSourceConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DataSourceRegistration::DataSourceRegistration()
    : name(),
      id(),
      will_notify_on_start(),
      will_notify_on_stop(),
      handles_incremental_state_clear(),
      track_event_descriptor_raw() {}

DataSourceRegistration::DataSourceRegistration(
    const std::string& name_in,
    uint64_t id_in,
    bool will_notify_on_start_in,
    bool will_notify_on_stop_in,
    bool handles_incremental_state_clear_in,
    const std::string& track_event_descriptor_raw_in)
    : name(std::move(name_in)),
      id(std::move(id_in)),
      will_notify_on_start(std::move(will_notify_on_start_in)),
      will_notify_on_stop(std::move(will_notify_on_stop_in)),
      handles_incremental_state_clear(std::move(handles_incremental_state_clear_in)),
      track_event_descriptor_raw(std::move(track_event_descriptor_raw_in)) {}

DataSourceRegistration::~DataSourceRegistration() = default;

void DataSourceRegistration::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "id"), this->id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint64_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "will_notify_on_start"), this->will_notify_on_start,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "will_notify_on_stop"), this->will_notify_on_stop,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "handles_incremental_state_clear"), this->handles_incremental_state_clear,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "track_event_descriptor_raw"), this->track_event_descriptor_raw,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DataSourceRegistration::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
BufferConfig::BufferConfig()
    : size_kb(),
      fill_policy() {}

BufferConfig::BufferConfig(
    uint32_t size_kb_in,
    ::perfetto::TraceConfig::BufferConfig::FillPolicy fill_policy_in)
    : size_kb(std::move(size_kb_in)),
      fill_policy(std::move(fill_policy_in)) {}

BufferConfig::~BufferConfig() = default;

void BufferConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "size_kb"), this->size_kb,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "fill_policy"), this->fill_policy,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::perfetto::TraceConfig::BufferConfig::FillPolicy>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool BufferConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DataSource::DataSource()
    : config(),
      producer_name_filter() {}

DataSource::DataSource(
    const ::perfetto::DataSourceConfig& config_in,
    std::vector<std::string> producer_name_filter_in)
    : config(std::move(config_in)),
      producer_name_filter(std::move(producer_name_filter_in)) {}

DataSource::~DataSource() = default;

void DataSource::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "config"), this->config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::perfetto::DataSourceConfig&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "producer_name_filter"), this->producer_name_filter,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::vector<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DataSource::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
PerfettoBuiltinDataSource::PerfettoBuiltinDataSource()
    : disable_clock_snapshotting(),
      disable_trace_config(),
      disable_system_info(),
      disable_service_events(),
      primary_trace_clock_id() {}

PerfettoBuiltinDataSource::PerfettoBuiltinDataSource(
    bool disable_clock_snapshotting_in,
    bool disable_trace_config_in,
    bool disable_system_info_in,
    bool disable_service_events_in,
    int32_t primary_trace_clock_id_in)
    : disable_clock_snapshotting(std::move(disable_clock_snapshotting_in)),
      disable_trace_config(std::move(disable_trace_config_in)),
      disable_system_info(std::move(disable_system_info_in)),
      disable_service_events(std::move(disable_service_events_in)),
      primary_trace_clock_id(std::move(primary_trace_clock_id_in)) {}

PerfettoBuiltinDataSource::~PerfettoBuiltinDataSource() = default;

void PerfettoBuiltinDataSource::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "disable_clock_snapshotting"), this->disable_clock_snapshotting,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "disable_trace_config"), this->disable_trace_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "disable_system_info"), this->disable_system_info,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "disable_service_events"), this->disable_service_events,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "primary_trace_clock_id"), this->primary_trace_clock_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type int32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool PerfettoBuiltinDataSource::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
IncrementalStateConfig::IncrementalStateConfig()
    : clear_period_ms() {}

IncrementalStateConfig::IncrementalStateConfig(
    uint32_t clear_period_ms_in)
    : clear_period_ms(std::move(clear_period_ms_in)) {}

IncrementalStateConfig::~IncrementalStateConfig() = default;

void IncrementalStateConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "clear_period_ms"), this->clear_period_ms,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool IncrementalStateConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TraceConfig::TraceConfig()
    : data_sources(),
      perfetto_builtin_data_source(),
      buffers(),
      incremental_state_config(),
      duration_ms(),
      write_into_file(),
      trace_uuid(),
      unique_session_name() {}

TraceConfig::TraceConfig(
    std::vector<DataSourcePtr> data_sources_in,
    const ::perfetto::TraceConfig::BuiltinDataSource& perfetto_builtin_data_source_in,
    std::vector<BufferConfigPtr> buffers_in,
    const ::perfetto::TraceConfig::IncrementalStateConfig& incremental_state_config_in,
    uint32_t duration_ms_in,
    bool write_into_file_in,
    const std::optional<::base::Token>& trace_uuid_in,
    const std::optional<::base::UnguessableToken>& unique_session_name_in)
    : data_sources(std::move(data_sources_in)),
      perfetto_builtin_data_source(std::move(perfetto_builtin_data_source_in)),
      buffers(std::move(buffers_in)),
      incremental_state_config(std::move(incremental_state_config_in)),
      duration_ms(std::move(duration_ms_in)),
      write_into_file(std::move(write_into_file_in)),
      trace_uuid(std::move(trace_uuid_in)),
      unique_session_name(std::move(unique_session_name_in)) {}

TraceConfig::~TraceConfig() = default;

void TraceConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "data_sources"), this->data_sources,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<DataSourcePtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "perfetto_builtin_data_source"), this->perfetto_builtin_data_source,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::perfetto::TraceConfig::BuiltinDataSource&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "buffers"), this->buffers,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<BufferConfigPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "incremental_state_config"), this->incremental_state_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::perfetto::TraceConfig::IncrementalStateConfig&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "duration_ms"), this->duration_ms,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "write_into_file"), this->write_into_file,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "trace_uuid"), this->trace_uuid,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::base::Token>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "unique_session_name"), this->unique_session_name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::base::UnguessableToken>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool TraceConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
// The declaration includes the definition on other builds.

ProducerHost::IPCStableHashFunction ProducerHost::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ProducerHost>(message.name())) {
    case messages::ProducerHost::kCommitData: {
      return &ProducerHost::CommitData_Sym::IPCStableHash;
    }
    case messages::ProducerHost::kRegisterDataSource: {
      return &ProducerHost::RegisterDataSource_Sym::IPCStableHash;
    }
    case messages::ProducerHost::kUpdateDataSource: {
      return &ProducerHost::UpdateDataSource_Sym::IPCStableHash;
    }
    case messages::ProducerHost::kRegisterTraceWriter: {
      return &ProducerHost::RegisterTraceWriter_Sym::IPCStableHash;
    }
    case messages::ProducerHost::kUnregisterTraceWriter: {
      return &ProducerHost::UnregisterTraceWriter_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ProducerHost::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::ProducerHost>(message.name())) {
      case messages::ProducerHost::kCommitData:
            return "Receive tracing::mojom::ProducerHost::CommitData";
      case messages::ProducerHost::kRegisterDataSource:
            return "Receive tracing::mojom::ProducerHost::RegisterDataSource";
      case messages::ProducerHost::kUpdateDataSource:
            return "Receive tracing::mojom::ProducerHost::UpdateDataSource";
      case messages::ProducerHost::kRegisterTraceWriter:
            return "Receive tracing::mojom::ProducerHost::RegisterTraceWriter";
      case messages::ProducerHost::kUnregisterTraceWriter:
            return "Receive tracing::mojom::ProducerHost::UnregisterTraceWriter";
    }
  } else {
    switch (static_cast<messages::ProducerHost>(message.name())) {
      case messages::ProducerHost::kCommitData:
            return "Receive reply tracing::mojom::ProducerHost::CommitData";
      case messages::ProducerHost::kRegisterDataSource:
            return "Receive reply tracing::mojom::ProducerHost::RegisterDataSource";
      case messages::ProducerHost::kUpdateDataSource:
            return "Receive reply tracing::mojom::ProducerHost::UpdateDataSource";
      case messages::ProducerHost::kRegisterTraceWriter:
            return "Receive reply tracing::mojom::ProducerHost::RegisterTraceWriter";
      case messages::ProducerHost::kUnregisterTraceWriter:
            return "Receive reply tracing::mojom::ProducerHost::UnregisterTraceWriter";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ProducerHost::CommitData_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x947597b8;  // IPCStableHash for tracing::mojom::ProducerHost::CommitData
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ProducerHost::RegisterDataSource_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x669044ab;  // IPCStableHash for tracing::mojom::ProducerHost::RegisterDataSource
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ProducerHost::UpdateDataSource_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xf9570935;  // IPCStableHash for tracing::mojom::ProducerHost::UpdateDataSource
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ProducerHost::RegisterTraceWriter_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x6ce56ca6;  // IPCStableHash for tracing::mojom::ProducerHost::RegisterTraceWriter
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ProducerHost::UnregisterTraceWriter_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xe1ac1ae7;  // IPCStableHash for tracing::mojom::ProducerHost::UnregisterTraceWriter
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class ProducerHost_CommitData_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ProducerHost_CommitData_ForwardToCallback(
      ProducerHost::CommitDataCallback callback
      ) : callback_(std::move(callback)) {
  }

  ProducerHost_CommitData_ForwardToCallback(const ProducerHost_CommitData_ForwardToCallback&) = delete;
  ProducerHost_CommitData_ForwardToCallback& operator=(const ProducerHost_CommitData_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  ProducerHost::CommitDataCallback callback_;
};

ProducerHostProxy::ProducerHostProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void ProducerHostProxy::CommitData(
    const ::perfetto::CommitDataRequest& in_data_request, CommitDataCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ProducerHost::CommitData", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("data_request"), in_data_request,
                        "<value of type const ::perfetto::CommitDataRequest&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerHost::kCommitData), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerHost_CommitData_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->data_request)::BaseType> data_request_fragment(
          params.message());
  
  mojo::internal::Serialize<::tracing::mojom::CommitDataRequestDataView>(
    in_data_request,
    data_request_fragment);

  params->data_request.Set(
      data_request_fragment.is_null() ? nullptr : data_request_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->data_request.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null data_request in ProducerHost.CommitData request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerHost::Name_);
  message.set_method_name("CommitData");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new ProducerHost_CommitData_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void ProducerHostProxy::RegisterDataSource(
    const ::perfetto::DataSourceDescriptor& in_registration_info) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ProducerHost::RegisterDataSource", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("registration_info"), in_registration_info,
                        "<value of type const ::perfetto::DataSourceDescriptor&>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerHost::kRegisterDataSource), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerHost_RegisterDataSource_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->registration_info)::BaseType> registration_info_fragment(
          params.message());
  
  mojo::internal::Serialize<::tracing::mojom::DataSourceRegistrationDataView>(
    in_registration_info,
    registration_info_fragment);

  params->registration_info.Set(
      registration_info_fragment.is_null() ? nullptr : registration_info_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->registration_info.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null registration_info in ProducerHost.RegisterDataSource request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerHost::Name_);
  message.set_method_name("RegisterDataSource");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void ProducerHostProxy::UpdateDataSource(
    const ::perfetto::DataSourceDescriptor& in_registration_info) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ProducerHost::UpdateDataSource", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("registration_info"), in_registration_info,
                        "<value of type const ::perfetto::DataSourceDescriptor&>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerHost::kUpdateDataSource), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerHost_UpdateDataSource_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->registration_info)::BaseType> registration_info_fragment(
          params.message());
  
  mojo::internal::Serialize<::tracing::mojom::DataSourceRegistrationDataView>(
    in_registration_info,
    registration_info_fragment);

  params->registration_info.Set(
      registration_info_fragment.is_null() ? nullptr : registration_info_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->registration_info.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null registration_info in ProducerHost.UpdateDataSource request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerHost::Name_);
  message.set_method_name("UpdateDataSource");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void ProducerHostProxy::RegisterTraceWriter(
    uint32_t in_writer_id, uint32_t in_target_buffer) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ProducerHost::RegisterTraceWriter", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("writer_id"), in_writer_id,
                        "<value of type uint32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("target_buffer"), in_target_buffer,
                        "<value of type uint32_t>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerHost::kRegisterTraceWriter), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerHost_RegisterTraceWriter_Params_Data> params(
          message);
  params.Allocate();

  params->writer_id = in_writer_id;

  params->target_buffer = in_target_buffer;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerHost::Name_);
  message.set_method_name("RegisterTraceWriter");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void ProducerHostProxy::UnregisterTraceWriter(
    uint32_t in_writer_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ProducerHost::UnregisterTraceWriter", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("writer_id"), in_writer_id,
                        "<value of type uint32_t>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerHost::kUnregisterTraceWriter), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerHost_UnregisterTraceWriter_Params_Data> params(
          message);
  params.Allocate();

  params->writer_id = in_writer_id;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerHost::Name_);
  message.set_method_name("UnregisterTraceWriter");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}
class ProducerHost_CommitData_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ProducerHost::CommitDataCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ProducerHost_CommitData_ProxyToResponder> proxy(
        new ProducerHost_CommitData_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ProducerHost_CommitData_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ProducerHost_CommitData_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  ProducerHost_CommitData_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "ProducerHost::CommitDataCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      );
};

bool ProducerHost_CommitData_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::ProducerHost_CommitData_ResponseParams_Data* params =
      reinterpret_cast<
          internal::ProducerHost_CommitData_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for ProducerHost.0
  bool success = true;
  ProducerHost_CommitData_ResponseParamsDataView input_data_view(params, message);
  
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ProducerHost::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run();
  }
  return true;
}

void ProducerHost_CommitData_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply tracing::mojom::ProducerHost::CommitData");
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerHost::kCommitData), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerHost_CommitData_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerHost::Name_);
  message.set_method_name("CommitData");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool ProducerHostStubDispatch::Accept(
    ProducerHost* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ProducerHost>(message->header()->name)) {
    case messages::ProducerHost::kCommitData: {
      break;
    }
    case messages::ProducerHost::kRegisterDataSource: {
      DCHECK(message->is_serialized());
      internal::ProducerHost_RegisterDataSource_Params_Data* params =
          reinterpret_cast<internal::ProducerHost_RegisterDataSource_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ProducerHost.1
      bool success = true;
      ::perfetto::DataSourceDescriptor p_registration_info{};
      ProducerHost_RegisterDataSource_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRegistrationInfo(&p_registration_info))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerHost::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RegisterDataSource(        
        std::move(p_registration_info));
      return true;
    }
    case messages::ProducerHost::kUpdateDataSource: {
      DCHECK(message->is_serialized());
      internal::ProducerHost_UpdateDataSource_Params_Data* params =
          reinterpret_cast<internal::ProducerHost_UpdateDataSource_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ProducerHost.2
      bool success = true;
      ::perfetto::DataSourceDescriptor p_registration_info{};
      ProducerHost_UpdateDataSource_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRegistrationInfo(&p_registration_info))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerHost::Name_, 2, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UpdateDataSource(        
        std::move(p_registration_info));
      return true;
    }
    case messages::ProducerHost::kRegisterTraceWriter: {
      DCHECK(message->is_serialized());
      internal::ProducerHost_RegisterTraceWriter_Params_Data* params =
          reinterpret_cast<internal::ProducerHost_RegisterTraceWriter_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ProducerHost.3
      bool success = true;
      uint32_t p_writer_id{};
      uint32_t p_target_buffer{};
      ProducerHost_RegisterTraceWriter_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_writer_id = input_data_view.writer_id();
      if (success)
        p_target_buffer = input_data_view.target_buffer();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerHost::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RegisterTraceWriter(        
        std::move(p_writer_id), 
        std::move(p_target_buffer));
      return true;
    }
    case messages::ProducerHost::kUnregisterTraceWriter: {
      DCHECK(message->is_serialized());
      internal::ProducerHost_UnregisterTraceWriter_Params_Data* params =
          reinterpret_cast<internal::ProducerHost_UnregisterTraceWriter_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ProducerHost.4
      bool success = true;
      uint32_t p_writer_id{};
      ProducerHost_UnregisterTraceWriter_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_writer_id = input_data_view.writer_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerHost::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UnregisterTraceWriter(        
        std::move(p_writer_id));
      return true;
    }
  }
  return false;
}

// static
bool ProducerHostStubDispatch::AcceptWithResponder(
    ProducerHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::ProducerHost>(message->header()->name)) {
    case messages::ProducerHost::kCommitData: {
      internal::ProducerHost_CommitData_Params_Data* params =
          reinterpret_cast<
              internal::ProducerHost_CommitData_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ProducerHost.0
      bool success = true;
      ::perfetto::CommitDataRequest p_data_request{};
      ProducerHost_CommitData_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadDataRequest(&p_data_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerHost::Name_, 0, false);
        return false;
      }
      auto callback =
          ProducerHost_CommitData_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CommitData(        
        std::move(p_data_request), std::move(callback));
      return true;
    }
    case messages::ProducerHost::kRegisterDataSource: {
      break;
    }
    case messages::ProducerHost::kUpdateDataSource: {
      break;
    }
    case messages::ProducerHost::kRegisterTraceWriter: {
      break;
    }
    case messages::ProducerHost::kUnregisterTraceWriter: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kProducerHostValidationInfo[] = {
    { &internal::ProducerHost_CommitData_Params_Data::Validate,
     &internal::ProducerHost_CommitData_ResponseParams_Data::Validate},
    { &internal::ProducerHost_RegisterDataSource_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ProducerHost_UpdateDataSource_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ProducerHost_RegisterTraceWriter_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ProducerHost_UnregisterTraceWriter_Params_Data::Validate,
     nullptr /* no response */},
};

bool ProducerHostRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::tracing::mojom::ProducerHost::Name_,
    kProducerHostValidationInfo);
}

bool ProducerHostResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::tracing::mojom::ProducerHost::Name_,
    kProducerHostValidationInfo);
}
// The declaration includes the definition on other builds.

ProducerClient::IPCStableHashFunction ProducerClient::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ProducerClient>(message.name())) {
    case messages::ProducerClient::kOnTracingStart: {
      return &ProducerClient::OnTracingStart_Sym::IPCStableHash;
    }
    case messages::ProducerClient::kStartDataSource: {
      return &ProducerClient::StartDataSource_Sym::IPCStableHash;
    }
    case messages::ProducerClient::kStopDataSource: {
      return &ProducerClient::StopDataSource_Sym::IPCStableHash;
    }
    case messages::ProducerClient::kFlush: {
      return &ProducerClient::Flush_Sym::IPCStableHash;
    }
    case messages::ProducerClient::kClearIncrementalState: {
      return &ProducerClient::ClearIncrementalState_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ProducerClient::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::ProducerClient>(message.name())) {
      case messages::ProducerClient::kOnTracingStart:
            return "Receive tracing::mojom::ProducerClient::OnTracingStart";
      case messages::ProducerClient::kStartDataSource:
            return "Receive tracing::mojom::ProducerClient::StartDataSource";
      case messages::ProducerClient::kStopDataSource:
            return "Receive tracing::mojom::ProducerClient::StopDataSource";
      case messages::ProducerClient::kFlush:
            return "Receive tracing::mojom::ProducerClient::Flush";
      case messages::ProducerClient::kClearIncrementalState:
            return "Receive tracing::mojom::ProducerClient::ClearIncrementalState";
    }
  } else {
    switch (static_cast<messages::ProducerClient>(message.name())) {
      case messages::ProducerClient::kOnTracingStart:
            return "Receive reply tracing::mojom::ProducerClient::OnTracingStart";
      case messages::ProducerClient::kStartDataSource:
            return "Receive reply tracing::mojom::ProducerClient::StartDataSource";
      case messages::ProducerClient::kStopDataSource:
            return "Receive reply tracing::mojom::ProducerClient::StopDataSource";
      case messages::ProducerClient::kFlush:
            return "Receive reply tracing::mojom::ProducerClient::Flush";
      case messages::ProducerClient::kClearIncrementalState:
            return "Receive reply tracing::mojom::ProducerClient::ClearIncrementalState";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ProducerClient::OnTracingStart_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x7d83d068;  // IPCStableHash for tracing::mojom::ProducerClient::OnTracingStart
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ProducerClient::StartDataSource_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x1053802f;  // IPCStableHash for tracing::mojom::ProducerClient::StartDataSource
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ProducerClient::StopDataSource_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x46741920;  // IPCStableHash for tracing::mojom::ProducerClient::StopDataSource
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ProducerClient::Flush_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xa877bc87;  // IPCStableHash for tracing::mojom::ProducerClient::Flush
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ProducerClient::ClearIncrementalState_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x57584ddf;  // IPCStableHash for tracing::mojom::ProducerClient::ClearIncrementalState
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class ProducerClient_StartDataSource_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ProducerClient_StartDataSource_ForwardToCallback(
      ProducerClient::StartDataSourceCallback callback
      ) : callback_(std::move(callback)) {
  }

  ProducerClient_StartDataSource_ForwardToCallback(const ProducerClient_StartDataSource_ForwardToCallback&) = delete;
  ProducerClient_StartDataSource_ForwardToCallback& operator=(const ProducerClient_StartDataSource_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  ProducerClient::StartDataSourceCallback callback_;
};

class ProducerClient_StopDataSource_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ProducerClient_StopDataSource_ForwardToCallback(
      ProducerClient::StopDataSourceCallback callback
      ) : callback_(std::move(callback)) {
  }

  ProducerClient_StopDataSource_ForwardToCallback(const ProducerClient_StopDataSource_ForwardToCallback&) = delete;
  ProducerClient_StopDataSource_ForwardToCallback& operator=(const ProducerClient_StopDataSource_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  ProducerClient::StopDataSourceCallback callback_;
};

ProducerClientProxy::ProducerClientProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void ProducerClientProxy::OnTracingStart(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send tracing::mojom::ProducerClient::OnTracingStart");
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerClient::kOnTracingStart), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerClient_OnTracingStart_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerClient::Name_);
  message.set_method_name("OnTracingStart");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void ProducerClientProxy::StartDataSource(
    uint64_t in_id, const ::perfetto::DataSourceConfig& in_data_source_config, StartDataSourceCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ProducerClient::StartDataSource", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("id"), in_id,
                        "<value of type uint64_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("data_source_config"), in_data_source_config,
                        "<value of type const ::perfetto::DataSourceConfig&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerClient::kStartDataSource), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerClient_StartDataSource_Params_Data> params(
          message);
  params.Allocate();

  params->id = in_id;
  mojo::internal::MessageFragment<
      typename decltype(params->data_source_config)::BaseType> data_source_config_fragment(
          params.message());
  
  mojo::internal::Serialize<::tracing::mojom::DataSourceConfigDataView>(
    in_data_source_config,
    data_source_config_fragment);

  params->data_source_config.Set(
      data_source_config_fragment.is_null() ? nullptr : data_source_config_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->data_source_config.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null data_source_config in ProducerClient.StartDataSource request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerClient::Name_);
  message.set_method_name("StartDataSource");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new ProducerClient_StartDataSource_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void ProducerClientProxy::StopDataSource(
    uint64_t in_id, StopDataSourceCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ProducerClient::StopDataSource", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("id"), in_id,
                        "<value of type uint64_t>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerClient::kStopDataSource), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerClient_StopDataSource_Params_Data> params(
          message);
  params.Allocate();

  params->id = in_id;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerClient::Name_);
  message.set_method_name("StopDataSource");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new ProducerClient_StopDataSource_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void ProducerClientProxy::Flush(
    uint64_t in_flush_request_id, const std::vector<uint64_t>& in_data_source_ids) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ProducerClient::Flush", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("flush_request_id"), in_flush_request_id,
                        "<value of type uint64_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("data_source_ids"), in_data_source_ids,
                        "<value of type const std::vector<uint64_t>&>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerClient::kFlush), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerClient_Flush_Params_Data> params(
          message);
  params.Allocate();

  params->flush_request_id = in_flush_request_id;
  mojo::internal::MessageFragment<
      typename decltype(params->data_source_ids)::BaseType>
      data_source_ids_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& data_source_ids_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<uint64_t>>(
    in_data_source_ids,
    data_source_ids_fragment,
    &data_source_ids_validate_params);

  params->data_source_ids.Set(
      data_source_ids_fragment.is_null() ? nullptr : data_source_ids_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->data_source_ids.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null data_source_ids in ProducerClient.Flush request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerClient::Name_);
  message.set_method_name("Flush");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void ProducerClientProxy::ClearIncrementalState(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send tracing::mojom::ProducerClient::ClearIncrementalState");
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerClient::kClearIncrementalState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerClient_ClearIncrementalState_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerClient::Name_);
  message.set_method_name("ClearIncrementalState");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}
class ProducerClient_StartDataSource_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ProducerClient::StartDataSourceCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ProducerClient_StartDataSource_ProxyToResponder> proxy(
        new ProducerClient_StartDataSource_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ProducerClient_StartDataSource_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ProducerClient_StartDataSource_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  ProducerClient_StartDataSource_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "ProducerClient::StartDataSourceCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      );
};

bool ProducerClient_StartDataSource_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::ProducerClient_StartDataSource_ResponseParams_Data* params =
      reinterpret_cast<
          internal::ProducerClient_StartDataSource_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for ProducerClient.1
  bool success = true;
  ProducerClient_StartDataSource_ResponseParamsDataView input_data_view(params, message);
  
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ProducerClient::Name_, 1, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run();
  }
  return true;
}

void ProducerClient_StartDataSource_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply tracing::mojom::ProducerClient::StartDataSource");
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerClient::kStartDataSource), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerClient_StartDataSource_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerClient::Name_);
  message.set_method_name("StartDataSource");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class ProducerClient_StopDataSource_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ProducerClient::StopDataSourceCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ProducerClient_StopDataSource_ProxyToResponder> proxy(
        new ProducerClient_StopDataSource_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ProducerClient_StopDataSource_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ProducerClient_StopDataSource_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  ProducerClient_StopDataSource_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "ProducerClient::StopDataSourceCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      );
};

bool ProducerClient_StopDataSource_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::ProducerClient_StopDataSource_ResponseParams_Data* params =
      reinterpret_cast<
          internal::ProducerClient_StopDataSource_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for ProducerClient.2
  bool success = true;
  ProducerClient_StopDataSource_ResponseParamsDataView input_data_view(params, message);
  
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ProducerClient::Name_, 2, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run();
  }
  return true;
}

void ProducerClient_StopDataSource_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply tracing::mojom::ProducerClient::StopDataSource");
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ProducerClient::kStopDataSource), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ProducerClient_StopDataSource_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ProducerClient::Name_);
  message.set_method_name("StopDataSource");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool ProducerClientStubDispatch::Accept(
    ProducerClient* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ProducerClient>(message->header()->name)) {
    case messages::ProducerClient::kOnTracingStart: {
      DCHECK(message->is_serialized());
      internal::ProducerClient_OnTracingStart_Params_Data* params =
          reinterpret_cast<internal::ProducerClient_OnTracingStart_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ProducerClient.0
      bool success = true;
      ProducerClient_OnTracingStart_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerClient::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnTracingStart(        );
      return true;
    }
    case messages::ProducerClient::kStartDataSource: {
      break;
    }
    case messages::ProducerClient::kStopDataSource: {
      break;
    }
    case messages::ProducerClient::kFlush: {
      DCHECK(message->is_serialized());
      internal::ProducerClient_Flush_Params_Data* params =
          reinterpret_cast<internal::ProducerClient_Flush_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ProducerClient.3
      bool success = true;
      uint64_t p_flush_request_id{};
      std::vector<uint64_t> p_data_source_ids{};
      ProducerClient_Flush_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_flush_request_id = input_data_view.flush_request_id();
      if (success && !input_data_view.ReadDataSourceIds(&p_data_source_ids))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerClient::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->Flush(        
        std::move(p_flush_request_id), 
        std::move(p_data_source_ids));
      return true;
    }
    case messages::ProducerClient::kClearIncrementalState: {
      DCHECK(message->is_serialized());
      internal::ProducerClient_ClearIncrementalState_Params_Data* params =
          reinterpret_cast<internal::ProducerClient_ClearIncrementalState_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ProducerClient.4
      bool success = true;
      ProducerClient_ClearIncrementalState_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerClient::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ClearIncrementalState(        );
      return true;
    }
  }
  return false;
}

// static
bool ProducerClientStubDispatch::AcceptWithResponder(
    ProducerClient* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::ProducerClient>(message->header()->name)) {
    case messages::ProducerClient::kOnTracingStart: {
      break;
    }
    case messages::ProducerClient::kStartDataSource: {
      internal::ProducerClient_StartDataSource_Params_Data* params =
          reinterpret_cast<
              internal::ProducerClient_StartDataSource_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ProducerClient.1
      bool success = true;
      uint64_t p_id{};
      ::perfetto::DataSourceConfig p_data_source_config{};
      ProducerClient_StartDataSource_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_id = input_data_view.id();
      if (success && !input_data_view.ReadDataSourceConfig(&p_data_source_config))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerClient::Name_, 1, false);
        return false;
      }
      auto callback =
          ProducerClient_StartDataSource_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->StartDataSource(        
        std::move(p_id), 
        std::move(p_data_source_config), std::move(callback));
      return true;
    }
    case messages::ProducerClient::kStopDataSource: {
      internal::ProducerClient_StopDataSource_Params_Data* params =
          reinterpret_cast<
              internal::ProducerClient_StopDataSource_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ProducerClient.2
      bool success = true;
      uint64_t p_id{};
      ProducerClient_StopDataSource_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_id = input_data_view.id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ProducerClient::Name_, 2, false);
        return false;
      }
      auto callback =
          ProducerClient_StopDataSource_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->StopDataSource(        
        std::move(p_id), std::move(callback));
      return true;
    }
    case messages::ProducerClient::kFlush: {
      break;
    }
    case messages::ProducerClient::kClearIncrementalState: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kProducerClientValidationInfo[] = {
    { &internal::ProducerClient_OnTracingStart_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ProducerClient_StartDataSource_Params_Data::Validate,
     &internal::ProducerClient_StartDataSource_ResponseParams_Data::Validate},
    { &internal::ProducerClient_StopDataSource_Params_Data::Validate,
     &internal::ProducerClient_StopDataSource_ResponseParams_Data::Validate},
    { &internal::ProducerClient_Flush_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ProducerClient_ClearIncrementalState_Params_Data::Validate,
     nullptr /* no response */},
};

bool ProducerClientRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::tracing::mojom::ProducerClient::Name_,
    kProducerClientValidationInfo);
}

bool ProducerClientResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::tracing::mojom::ProducerClient::Name_,
    kProducerClientValidationInfo);
}
// The declaration includes the definition on other builds.

PerfettoService::IPCStableHashFunction PerfettoService::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::PerfettoService>(message.name())) {
    case messages::PerfettoService::kConnectToProducerHost: {
      return &PerfettoService::ConnectToProducerHost_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* PerfettoService::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::PerfettoService>(message.name())) {
      case messages::PerfettoService::kConnectToProducerHost:
            return "Receive tracing::mojom::PerfettoService::ConnectToProducerHost";
    }
  } else {
    switch (static_cast<messages::PerfettoService>(message.name())) {
      case messages::PerfettoService::kConnectToProducerHost:
            return "Receive reply tracing::mojom::PerfettoService::ConnectToProducerHost";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t PerfettoService::ConnectToProducerHost_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x863c14ed;  // IPCStableHash for tracing::mojom::PerfettoService::ConnectToProducerHost
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

PerfettoServiceProxy::PerfettoServiceProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void PerfettoServiceProxy::ConnectToProducerHost(
    ::mojo::PendingRemote<ProducerClient> in_producer_client, ::mojo::PendingReceiver<ProducerHost> in_producer_host_receiver, ::base::UnsafeSharedMemoryRegion in_shared_memory, uint64_t in_shared_memory_buffer_page_size_bytes) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::PerfettoService::ConnectToProducerHost", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("producer_client"), in_producer_client,
                        "<value of type ::mojo::PendingRemote<ProducerClient>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("producer_host_receiver"), in_producer_host_receiver,
                        "<value of type ::mojo::PendingReceiver<ProducerHost>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("shared_memory"), in_shared_memory,
                        "<value of type ::base::UnsafeSharedMemoryRegion>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("shared_memory_buffer_page_size_bytes"), in_shared_memory_buffer_page_size_bytes,
                        "<value of type uint64_t>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PerfettoService::kConnectToProducerHost), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::PerfettoService_ConnectToProducerHost_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::tracing::mojom::ProducerClientInterfaceBase>>(
    in_producer_client,
    &params->producer_client,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->producer_client)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid producer_client in PerfettoService.ConnectToProducerHost request");

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::tracing::mojom::ProducerHostInterfaceBase>>(
    in_producer_host_receiver,
    &params->producer_host_receiver,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->producer_host_receiver)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid producer_host_receiver in PerfettoService.ConnectToProducerHost request");
  mojo::internal::MessageFragment<
      typename decltype(params->shared_memory)::BaseType> shared_memory_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UnsafeSharedMemoryRegionDataView>(
    in_shared_memory,
    shared_memory_fragment);

  params->shared_memory.Set(
      shared_memory_fragment.is_null() ? nullptr : shared_memory_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->shared_memory.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null shared_memory in PerfettoService.ConnectToProducerHost request");

  params->shared_memory_buffer_page_size_bytes = in_shared_memory_buffer_page_size_bytes;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PerfettoService::Name_);
  message.set_method_name("ConnectToProducerHost");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

// static
bool PerfettoServiceStubDispatch::Accept(
    PerfettoService* impl,
    mojo::Message* message) {
  switch (static_cast<messages::PerfettoService>(message->header()->name)) {
    case messages::PerfettoService::kConnectToProducerHost: {
      DCHECK(message->is_serialized());
      internal::PerfettoService_ConnectToProducerHost_Params_Data* params =
          reinterpret_cast<internal::PerfettoService_ConnectToProducerHost_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PerfettoService.0
      bool success = true;
      ::mojo::PendingRemote<ProducerClient> p_producer_client{};
      ::mojo::PendingReceiver<ProducerHost> p_producer_host_receiver{};
      ::base::UnsafeSharedMemoryRegion p_shared_memory{};
      uint64_t p_shared_memory_buffer_page_size_bytes{};
      PerfettoService_ConnectToProducerHost_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_producer_client =
            input_data_view.TakeProducerClient<decltype(p_producer_client)>();
      }
      if (success) {
        p_producer_host_receiver =
            input_data_view.TakeProducerHostReceiver<decltype(p_producer_host_receiver)>();
      }
      if (success && !input_data_view.ReadSharedMemory(&p_shared_memory))
        success = false;
      if (success)
        p_shared_memory_buffer_page_size_bytes = input_data_view.shared_memory_buffer_page_size_bytes();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PerfettoService::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ConnectToProducerHost(        
        std::move(p_producer_client), 
        std::move(p_producer_host_receiver), 
        std::move(p_shared_memory), 
        std::move(p_shared_memory_buffer_page_size_bytes));
      return true;
    }
  }
  return false;
}

// static
bool PerfettoServiceStubDispatch::AcceptWithResponder(
    PerfettoService* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::PerfettoService>(message->header()->name)) {
    case messages::PerfettoService::kConnectToProducerHost: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kPerfettoServiceValidationInfo[] = {
    { &internal::PerfettoService_ConnectToProducerHost_Params_Data::Validate,
     nullptr /* no response */},
};

bool PerfettoServiceRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::tracing::mojom::PerfettoService::Name_,
    kPerfettoServiceValidationInfo);
}

// The declaration includes the definition on other builds.

ConsumerHost::IPCStableHashFunction ConsumerHost::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ConsumerHost>(message.name())) {
    case messages::ConsumerHost::kEnableTracing: {
      return &ConsumerHost::EnableTracing_Sym::IPCStableHash;
    }
    case messages::ConsumerHost::kCloneSession: {
      return &ConsumerHost::CloneSession_Sym::IPCStableHash;
    }
    case messages::ConsumerHost::kQueryServiceState: {
      return &ConsumerHost::QueryServiceState_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ConsumerHost::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::ConsumerHost>(message.name())) {
      case messages::ConsumerHost::kEnableTracing:
            return "Receive tracing::mojom::ConsumerHost::EnableTracing";
      case messages::ConsumerHost::kCloneSession:
            return "Receive tracing::mojom::ConsumerHost::CloneSession";
      case messages::ConsumerHost::kQueryServiceState:
            return "Receive tracing::mojom::ConsumerHost::QueryServiceState";
    }
  } else {
    switch (static_cast<messages::ConsumerHost>(message.name())) {
      case messages::ConsumerHost::kEnableTracing:
            return "Receive reply tracing::mojom::ConsumerHost::EnableTracing";
      case messages::ConsumerHost::kCloneSession:
            return "Receive reply tracing::mojom::ConsumerHost::CloneSession";
      case messages::ConsumerHost::kQueryServiceState:
            return "Receive reply tracing::mojom::ConsumerHost::QueryServiceState";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ConsumerHost::EnableTracing_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xb2f0912f;  // IPCStableHash for tracing::mojom::ConsumerHost::EnableTracing
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ConsumerHost::CloneSession_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x5e765094;  // IPCStableHash for tracing::mojom::ConsumerHost::CloneSession
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ConsumerHost::QueryServiceState_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x439a4401;  // IPCStableHash for tracing::mojom::ConsumerHost::QueryServiceState
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class ConsumerHost_CloneSession_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ConsumerHost_CloneSession_ForwardToCallback(
      ConsumerHost::CloneSessionCallback callback
      ) : callback_(std::move(callback)) {
  }

  ConsumerHost_CloneSession_ForwardToCallback(const ConsumerHost_CloneSession_ForwardToCallback&) = delete;
  ConsumerHost_CloneSession_ForwardToCallback& operator=(const ConsumerHost_CloneSession_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  ConsumerHost::CloneSessionCallback callback_;
};

class ConsumerHost_QueryServiceState_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ConsumerHost_QueryServiceState_ForwardToCallback(
      ConsumerHost::QueryServiceStateCallback callback
      ) : callback_(std::move(callback)) {
  }

  ConsumerHost_QueryServiceState_ForwardToCallback(const ConsumerHost_QueryServiceState_ForwardToCallback&) = delete;
  ConsumerHost_QueryServiceState_ForwardToCallback& operator=(const ConsumerHost_QueryServiceState_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  ConsumerHost::QueryServiceStateCallback callback_;
};

ConsumerHostProxy::ConsumerHostProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void ConsumerHostProxy::EnableTracing(
    ::mojo::PendingReceiver<TracingSessionHost> in_tracing_session_host, ::mojo::PendingRemote<TracingSessionClient> in_tracing_session_client, const ::perfetto::TraceConfig& in_config, ::base::File in_output_file) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ConsumerHost::EnableTracing", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tracing_session_host"), in_tracing_session_host,
                        "<value of type ::mojo::PendingReceiver<TracingSessionHost>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tracing_session_client"), in_tracing_session_client,
                        "<value of type ::mojo::PendingRemote<TracingSessionClient>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("config"), in_config,
                        "<value of type const ::perfetto::TraceConfig&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("output_file"), in_output_file,
                        "<value of type ::base::File>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ConsumerHost::kEnableTracing), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ConsumerHost_EnableTracing_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::tracing::mojom::TracingSessionHostInterfaceBase>>(
    in_tracing_session_host,
    &params->tracing_session_host,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->tracing_session_host)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid tracing_session_host in ConsumerHost.EnableTracing request");

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::tracing::mojom::TracingSessionClientInterfaceBase>>(
    in_tracing_session_client,
    &params->tracing_session_client,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->tracing_session_client)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid tracing_session_client in ConsumerHost.EnableTracing request");
  mojo::internal::MessageFragment<
      typename decltype(params->config)::BaseType> config_fragment(
          params.message());
  
  mojo::internal::Serialize<::tracing::mojom::TraceConfigDataView>(
    in_config,
    config_fragment);

  params->config.Set(
      config_fragment.is_null() ? nullptr : config_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->config.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null config in ConsumerHost.EnableTracing request");
  mojo::internal::MessageFragment<
      typename decltype(params->output_file)::BaseType> output_file_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::FileDataView>(
    in_output_file,
    output_file_fragment);

  params->output_file.Set(
      output_file_fragment.is_null() ? nullptr : output_file_fragment.data());

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ConsumerHost::Name_);
  message.set_method_name("EnableTracing");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void ConsumerHostProxy::CloneSession(
    ::mojo::PendingReceiver<TracingSessionHost> in_tracing_session_host, ::mojo::PendingRemote<TracingSessionClient> in_tracing_session_client, const ::base::UnguessableToken& in_unguessable_name, CloneSessionCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::ConsumerHost::CloneSession", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tracing_session_host"), in_tracing_session_host,
                        "<value of type ::mojo::PendingReceiver<TracingSessionHost>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tracing_session_client"), in_tracing_session_client,
                        "<value of type ::mojo::PendingRemote<TracingSessionClient>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("unguessable_name"), in_unguessable_name,
                        "<value of type const ::base::UnguessableToken&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ConsumerHost::kCloneSession), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ConsumerHost_CloneSession_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::tracing::mojom::TracingSessionHostInterfaceBase>>(
    in_tracing_session_host,
    &params->tracing_session_host,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->tracing_session_host)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid tracing_session_host in ConsumerHost.CloneSession request");

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::tracing::mojom::TracingSessionClientInterfaceBase>>(
    in_tracing_session_client,
    &params->tracing_session_client,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->tracing_session_client)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid tracing_session_client in ConsumerHost.CloneSession request");
  mojo::internal::MessageFragment<
      typename decltype(params->unguessable_name)::BaseType> unguessable_name_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UnguessableTokenDataView>(
    in_unguessable_name,
    unguessable_name_fragment);

  params->unguessable_name.Set(
      unguessable_name_fragment.is_null() ? nullptr : unguessable_name_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->unguessable_name.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null unguessable_name in ConsumerHost.CloneSession request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ConsumerHost::Name_);
  message.set_method_name("CloneSession");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new ConsumerHost_CloneSession_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void ConsumerHostProxy::QueryServiceState(
    QueryServiceStateCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send tracing::mojom::ConsumerHost::QueryServiceState");
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ConsumerHost::kQueryServiceState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ConsumerHost_QueryServiceState_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ConsumerHost::Name_);
  message.set_method_name("QueryServiceState");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new ConsumerHost_QueryServiceState_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}
class ConsumerHost_CloneSession_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ConsumerHost::CloneSessionCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ConsumerHost_CloneSession_ProxyToResponder> proxy(
        new ConsumerHost_CloneSession_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ConsumerHost_CloneSession_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ConsumerHost_CloneSession_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  ConsumerHost_CloneSession_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "ConsumerHost::CloneSessionCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_success, const std::string& in_error, const ::base::Token& in_uuid);
};

bool ConsumerHost_CloneSession_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::ConsumerHost_CloneSession_ResponseParams_Data* params =
      reinterpret_cast<
          internal::ConsumerHost_CloneSession_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for ConsumerHost.1
  bool success = true;
  bool p_success{};
  std::string p_error{};
  ::base::Token p_uuid{};
  ConsumerHost_CloneSession_ResponseParamsDataView input_data_view(params, message);
  
  if (success)
    p_success = input_data_view.success();
  if (success && !input_data_view.ReadError(&p_error))
    success = false;
  if (success && !input_data_view.ReadUuid(&p_uuid))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ConsumerHost::Name_, 1, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_success), 
std::move(p_error), 
std::move(p_uuid));
  }
  return true;
}

void ConsumerHost_CloneSession_ProxyToResponder::Run(
    bool in_success, const std::string& in_error, const ::base::Token& in_uuid) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply tracing::mojom::ConsumerHost::CloneSession", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("error"), in_error,
                        "<value of type const std::string&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("uuid"), in_uuid,
                        "<value of type const ::base::Token&>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ConsumerHost::kCloneSession), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ConsumerHost_CloneSession_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;
  mojo::internal::MessageFragment<
      typename decltype(params->error)::BaseType> error_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_error,
    error_fragment);

  params->error.Set(
      error_fragment.is_null() ? nullptr : error_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->error.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null error in ");
  mojo::internal::MessageFragment<
      typename decltype(params->uuid)::BaseType> uuid_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::TokenDataView>(
    in_uuid,
    uuid_fragment);

  params->uuid.Set(
      uuid_fragment.is_null() ? nullptr : uuid_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->uuid.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null uuid in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ConsumerHost::Name_);
  message.set_method_name("CloneSession");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class ConsumerHost_QueryServiceState_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ConsumerHost::QueryServiceStateCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ConsumerHost_QueryServiceState_ProxyToResponder> proxy(
        new ConsumerHost_QueryServiceState_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ConsumerHost_QueryServiceState_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ConsumerHost_QueryServiceState_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  ConsumerHost_QueryServiceState_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "ConsumerHost::QueryServiceStateCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_success, const std::string& in_service_state_data);
};

bool ConsumerHost_QueryServiceState_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::ConsumerHost_QueryServiceState_ResponseParams_Data* params =
      reinterpret_cast<
          internal::ConsumerHost_QueryServiceState_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for ConsumerHost.2
  bool success = true;
  bool p_success{};
  std::string p_service_state_data{};
  ConsumerHost_QueryServiceState_ResponseParamsDataView input_data_view(params, message);
  
  if (success)
    p_success = input_data_view.success();
  if (success && !input_data_view.ReadServiceStateData(&p_service_state_data))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ConsumerHost::Name_, 2, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_success), 
std::move(p_service_state_data));
  }
  return true;
}

void ConsumerHost_QueryServiceState_ProxyToResponder::Run(
    bool in_success, const std::string& in_service_state_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply tracing::mojom::ConsumerHost::QueryServiceState", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("service_state_data"), in_service_state_data,
                        "<value of type const std::string&>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ConsumerHost::kQueryServiceState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::ConsumerHost_QueryServiceState_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;
  mojo::internal::MessageFragment<
      typename decltype(params->service_state_data)::BaseType> service_state_data_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::ByteStringDataView>(
    in_service_state_data,
    service_state_data_fragment);

  params->service_state_data.Set(
      service_state_data_fragment.is_null() ? nullptr : service_state_data_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->service_state_data.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null service_state_data in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ConsumerHost::Name_);
  message.set_method_name("QueryServiceState");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool ConsumerHostStubDispatch::Accept(
    ConsumerHost* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ConsumerHost>(message->header()->name)) {
    case messages::ConsumerHost::kEnableTracing: {
      DCHECK(message->is_serialized());
      internal::ConsumerHost_EnableTracing_Params_Data* params =
          reinterpret_cast<internal::ConsumerHost_EnableTracing_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ConsumerHost.0
      bool success = true;
      ::mojo::PendingReceiver<TracingSessionHost> p_tracing_session_host{};
      ::mojo::PendingRemote<TracingSessionClient> p_tracing_session_client{};
      ::perfetto::TraceConfig p_config{};
      ::base::File p_output_file{};
      ConsumerHost_EnableTracing_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_tracing_session_host =
            input_data_view.TakeTracingSessionHost<decltype(p_tracing_session_host)>();
      }
      if (success) {
        p_tracing_session_client =
            input_data_view.TakeTracingSessionClient<decltype(p_tracing_session_client)>();
      }
      if (success && !input_data_view.ReadConfig(&p_config))
        success = false;
      if (success && !input_data_view.ReadOutputFile(&p_output_file))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ConsumerHost::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->EnableTracing(        
        std::move(p_tracing_session_host), 
        std::move(p_tracing_session_client), 
        std::move(p_config), 
        std::move(p_output_file));
      return true;
    }
    case messages::ConsumerHost::kCloneSession: {
      break;
    }
    case messages::ConsumerHost::kQueryServiceState: {
      break;
    }
  }
  return false;
}

// static
bool ConsumerHostStubDispatch::AcceptWithResponder(
    ConsumerHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::ConsumerHost>(message->header()->name)) {
    case messages::ConsumerHost::kEnableTracing: {
      break;
    }
    case messages::ConsumerHost::kCloneSession: {
      internal::ConsumerHost_CloneSession_Params_Data* params =
          reinterpret_cast<
              internal::ConsumerHost_CloneSession_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ConsumerHost.1
      bool success = true;
      ::mojo::PendingReceiver<TracingSessionHost> p_tracing_session_host{};
      ::mojo::PendingRemote<TracingSessionClient> p_tracing_session_client{};
      ::base::UnguessableToken p_unguessable_name{};
      ConsumerHost_CloneSession_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_tracing_session_host =
            input_data_view.TakeTracingSessionHost<decltype(p_tracing_session_host)>();
      }
      if (success) {
        p_tracing_session_client =
            input_data_view.TakeTracingSessionClient<decltype(p_tracing_session_client)>();
      }
      if (success && !input_data_view.ReadUnguessableName(&p_unguessable_name))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ConsumerHost::Name_, 1, false);
        return false;
      }
      auto callback =
          ConsumerHost_CloneSession_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CloneSession(        
        std::move(p_tracing_session_host), 
        std::move(p_tracing_session_client), 
        std::move(p_unguessable_name), std::move(callback));
      return true;
    }
    case messages::ConsumerHost::kQueryServiceState: {
      internal::ConsumerHost_QueryServiceState_Params_Data* params =
          reinterpret_cast<
              internal::ConsumerHost_QueryServiceState_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ConsumerHost.2
      bool success = true;
      ConsumerHost_QueryServiceState_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ConsumerHost::Name_, 2, false);
        return false;
      }
      auto callback =
          ConsumerHost_QueryServiceState_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->QueryServiceState(std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kConsumerHostValidationInfo[] = {
    { &internal::ConsumerHost_EnableTracing_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ConsumerHost_CloneSession_Params_Data::Validate,
     &internal::ConsumerHost_CloneSession_ResponseParams_Data::Validate},
    { &internal::ConsumerHost_QueryServiceState_Params_Data::Validate,
     &internal::ConsumerHost_QueryServiceState_ResponseParams_Data::Validate},
};

bool ConsumerHostRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::tracing::mojom::ConsumerHost::Name_,
    kConsumerHostValidationInfo);
}

bool ConsumerHostResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::tracing::mojom::ConsumerHost::Name_,
    kConsumerHostValidationInfo);
}
// The declaration includes the definition on other builds.

TracingSessionHost::IPCStableHashFunction TracingSessionHost::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::TracingSessionHost>(message.name())) {
    case messages::TracingSessionHost::kChangeTraceConfig: {
      return &TracingSessionHost::ChangeTraceConfig_Sym::IPCStableHash;
    }
    case messages::TracingSessionHost::kDisableTracing: {
      return &TracingSessionHost::DisableTracing_Sym::IPCStableHash;
    }
    case messages::TracingSessionHost::kReadBuffers: {
      return &TracingSessionHost::ReadBuffers_Sym::IPCStableHash;
    }
    case messages::TracingSessionHost::kRequestBufferUsage: {
      return &TracingSessionHost::RequestBufferUsage_Sym::IPCStableHash;
    }
    case messages::TracingSessionHost::kDisableTracingAndEmitJson: {
      return &TracingSessionHost::DisableTracingAndEmitJson_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* TracingSessionHost::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::TracingSessionHost>(message.name())) {
      case messages::TracingSessionHost::kChangeTraceConfig:
            return "Receive tracing::mojom::TracingSessionHost::ChangeTraceConfig";
      case messages::TracingSessionHost::kDisableTracing:
            return "Receive tracing::mojom::TracingSessionHost::DisableTracing";
      case messages::TracingSessionHost::kReadBuffers:
            return "Receive tracing::mojom::TracingSessionHost::ReadBuffers";
      case messages::TracingSessionHost::kRequestBufferUsage:
            return "Receive tracing::mojom::TracingSessionHost::RequestBufferUsage";
      case messages::TracingSessionHost::kDisableTracingAndEmitJson:
            return "Receive tracing::mojom::TracingSessionHost::DisableTracingAndEmitJson";
    }
  } else {
    switch (static_cast<messages::TracingSessionHost>(message.name())) {
      case messages::TracingSessionHost::kChangeTraceConfig:
            return "Receive reply tracing::mojom::TracingSessionHost::ChangeTraceConfig";
      case messages::TracingSessionHost::kDisableTracing:
            return "Receive reply tracing::mojom::TracingSessionHost::DisableTracing";
      case messages::TracingSessionHost::kReadBuffers:
            return "Receive reply tracing::mojom::TracingSessionHost::ReadBuffers";
      case messages::TracingSessionHost::kRequestBufferUsage:
            return "Receive reply tracing::mojom::TracingSessionHost::RequestBufferUsage";
      case messages::TracingSessionHost::kDisableTracingAndEmitJson:
            return "Receive reply tracing::mojom::TracingSessionHost::DisableTracingAndEmitJson";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t TracingSessionHost::ChangeTraceConfig_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xdd7a0897;  // IPCStableHash for tracing::mojom::TracingSessionHost::ChangeTraceConfig
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t TracingSessionHost::DisableTracing_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x5e830b0c;  // IPCStableHash for tracing::mojom::TracingSessionHost::DisableTracing
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t TracingSessionHost::ReadBuffers_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xce891c25;  // IPCStableHash for tracing::mojom::TracingSessionHost::ReadBuffers
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t TracingSessionHost::RequestBufferUsage_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xd58b573f;  // IPCStableHash for tracing::mojom::TracingSessionHost::RequestBufferUsage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t TracingSessionHost::DisableTracingAndEmitJson_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x5d098364;  // IPCStableHash for tracing::mojom::TracingSessionHost::DisableTracingAndEmitJson
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class TracingSessionHost_ReadBuffers_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  TracingSessionHost_ReadBuffers_ForwardToCallback(
      TracingSessionHost::ReadBuffersCallback callback
      ) : callback_(std::move(callback)) {
  }

  TracingSessionHost_ReadBuffers_ForwardToCallback(const TracingSessionHost_ReadBuffers_ForwardToCallback&) = delete;
  TracingSessionHost_ReadBuffers_ForwardToCallback& operator=(const TracingSessionHost_ReadBuffers_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  TracingSessionHost::ReadBuffersCallback callback_;
};

class TracingSessionHost_RequestBufferUsage_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  TracingSessionHost_RequestBufferUsage_ForwardToCallback(
      TracingSessionHost::RequestBufferUsageCallback callback
      ) : callback_(std::move(callback)) {
  }

  TracingSessionHost_RequestBufferUsage_ForwardToCallback(const TracingSessionHost_RequestBufferUsage_ForwardToCallback&) = delete;
  TracingSessionHost_RequestBufferUsage_ForwardToCallback& operator=(const TracingSessionHost_RequestBufferUsage_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  TracingSessionHost::RequestBufferUsageCallback callback_;
};

class TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback(
      TracingSessionHost::DisableTracingAndEmitJsonCallback callback
      ) : callback_(std::move(callback)) {
  }

  TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback(const TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback&) = delete;
  TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback& operator=(const TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  TracingSessionHost::DisableTracingAndEmitJsonCallback callback_;
};

TracingSessionHostProxy::TracingSessionHostProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void TracingSessionHostProxy::ChangeTraceConfig(
    const ::perfetto::TraceConfig& in_config) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::TracingSessionHost::ChangeTraceConfig", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("config"), in_config,
                        "<value of type const ::perfetto::TraceConfig&>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionHost::kChangeTraceConfig), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionHost_ChangeTraceConfig_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->config)::BaseType> config_fragment(
          params.message());
  
  mojo::internal::Serialize<::tracing::mojom::TraceConfigDataView>(
    in_config,
    config_fragment);

  params->config.Set(
      config_fragment.is_null() ? nullptr : config_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->config.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null config in TracingSessionHost.ChangeTraceConfig request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionHost::Name_);
  message.set_method_name("ChangeTraceConfig");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void TracingSessionHostProxy::DisableTracing(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send tracing::mojom::TracingSessionHost::DisableTracing");
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionHost::kDisableTracing), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionHost_DisableTracing_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionHost::Name_);
  message.set_method_name("DisableTracing");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void TracingSessionHostProxy::ReadBuffers(
    ::mojo::ScopedDataPipeProducerHandle in_stream, ReadBuffersCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::TracingSessionHost::ReadBuffers", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("stream"), in_stream,
                        "<value of type ::mojo::ScopedDataPipeProducerHandle>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionHost::kReadBuffers), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionHost_ReadBuffers_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::ScopedDataPipeProducerHandle>(
    in_stream,
    &params->stream,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->stream)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid stream in TracingSessionHost.ReadBuffers request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionHost::Name_);
  message.set_method_name("ReadBuffers");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new TracingSessionHost_ReadBuffers_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void TracingSessionHostProxy::RequestBufferUsage(
    RequestBufferUsageCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send tracing::mojom::TracingSessionHost::RequestBufferUsage");
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionHost::kRequestBufferUsage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionHost_RequestBufferUsage_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionHost::Name_);
  message.set_method_name("RequestBufferUsage");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new TracingSessionHost_RequestBufferUsage_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void TracingSessionHostProxy::DisableTracingAndEmitJson(
    const std::string& in_agent_label_filter, ::mojo::ScopedDataPipeProducerHandle in_stream, DisableTracingAndEmitJsonCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::TracingSessionHost::DisableTracingAndEmitJson", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("agent_label_filter"), in_agent_label_filter,
                        "<value of type const std::string&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("stream"), in_stream,
                        "<value of type ::mojo::ScopedDataPipeProducerHandle>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionHost::kDisableTracingAndEmitJson), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionHost_DisableTracingAndEmitJson_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->agent_label_filter)::BaseType> agent_label_filter_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_agent_label_filter,
    agent_label_filter_fragment);

  params->agent_label_filter.Set(
      agent_label_filter_fragment.is_null() ? nullptr : agent_label_filter_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->agent_label_filter.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null agent_label_filter in TracingSessionHost.DisableTracingAndEmitJson request");

  
  mojo::internal::Serialize<mojo::ScopedDataPipeProducerHandle>(
    in_stream,
    &params->stream,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->stream)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid stream in TracingSessionHost.DisableTracingAndEmitJson request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionHost::Name_);
  message.set_method_name("DisableTracingAndEmitJson");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}
class TracingSessionHost_ReadBuffers_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static TracingSessionHost::ReadBuffersCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<TracingSessionHost_ReadBuffers_ProxyToResponder> proxy(
        new TracingSessionHost_ReadBuffers_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&TracingSessionHost_ReadBuffers_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~TracingSessionHost_ReadBuffers_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  TracingSessionHost_ReadBuffers_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "TracingSessionHost::ReadBuffersCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      );
};

bool TracingSessionHost_ReadBuffers_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::TracingSessionHost_ReadBuffers_ResponseParams_Data* params =
      reinterpret_cast<
          internal::TracingSessionHost_ReadBuffers_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for TracingSessionHost.2
  bool success = true;
  TracingSessionHost_ReadBuffers_ResponseParamsDataView input_data_view(params, message);
  
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        TracingSessionHost::Name_, 2, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run();
  }
  return true;
}

void TracingSessionHost_ReadBuffers_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply tracing::mojom::TracingSessionHost::ReadBuffers");
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionHost::kReadBuffers), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionHost_ReadBuffers_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionHost::Name_);
  message.set_method_name("ReadBuffers");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class TracingSessionHost_RequestBufferUsage_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static TracingSessionHost::RequestBufferUsageCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<TracingSessionHost_RequestBufferUsage_ProxyToResponder> proxy(
        new TracingSessionHost_RequestBufferUsage_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&TracingSessionHost_RequestBufferUsage_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~TracingSessionHost_RequestBufferUsage_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  TracingSessionHost_RequestBufferUsage_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "TracingSessionHost::RequestBufferUsageCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_success, float in_percent_full, bool in_data_loss);
};

bool TracingSessionHost_RequestBufferUsage_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::TracingSessionHost_RequestBufferUsage_ResponseParams_Data* params =
      reinterpret_cast<
          internal::TracingSessionHost_RequestBufferUsage_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for TracingSessionHost.3
  bool success = true;
  bool p_success{};
  float p_percent_full{};
  bool p_data_loss{};
  TracingSessionHost_RequestBufferUsage_ResponseParamsDataView input_data_view(params, message);
  
  if (success)
    p_success = input_data_view.success();
  if (success)
    p_percent_full = input_data_view.percent_full();
  if (success)
    p_data_loss = input_data_view.data_loss();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        TracingSessionHost::Name_, 3, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_success), 
std::move(p_percent_full), 
std::move(p_data_loss));
  }
  return true;
}

void TracingSessionHost_RequestBufferUsage_ProxyToResponder::Run(
    bool in_success, float in_percent_full, bool in_data_loss) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply tracing::mojom::TracingSessionHost::RequestBufferUsage", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("percent_full"), in_percent_full,
                        "<value of type float>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("data_loss"), in_data_loss,
                        "<value of type bool>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionHost::kRequestBufferUsage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionHost_RequestBufferUsage_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;

  params->percent_full = in_percent_full;

  params->data_loss = in_data_loss;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionHost::Name_);
  message.set_method_name("RequestBufferUsage");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static TracingSessionHost::DisableTracingAndEmitJsonCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder> proxy(
        new TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "TracingSessionHost::DisableTracingAndEmitJsonCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      );
};

bool TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::TracingSessionHost_DisableTracingAndEmitJson_ResponseParams_Data* params =
      reinterpret_cast<
          internal::TracingSessionHost_DisableTracingAndEmitJson_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for TracingSessionHost.4
  bool success = true;
  TracingSessionHost_DisableTracingAndEmitJson_ResponseParamsDataView input_data_view(params, message);
  
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        TracingSessionHost::Name_, 4, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run();
  }
  return true;
}

void TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply tracing::mojom::TracingSessionHost::DisableTracingAndEmitJson");
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionHost::kDisableTracingAndEmitJson), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionHost_DisableTracingAndEmitJson_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionHost::Name_);
  message.set_method_name("DisableTracingAndEmitJson");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool TracingSessionHostStubDispatch::Accept(
    TracingSessionHost* impl,
    mojo::Message* message) {
  switch (static_cast<messages::TracingSessionHost>(message->header()->name)) {
    case messages::TracingSessionHost::kChangeTraceConfig: {
      DCHECK(message->is_serialized());
      internal::TracingSessionHost_ChangeTraceConfig_Params_Data* params =
          reinterpret_cast<internal::TracingSessionHost_ChangeTraceConfig_Params_Data*>(
              message->mutable_payload());
      

      // Validation for TracingSessionHost.0
      bool success = true;
      ::perfetto::TraceConfig p_config{};
      TracingSessionHost_ChangeTraceConfig_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadConfig(&p_config))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TracingSessionHost::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ChangeTraceConfig(        
        std::move(p_config));
      return true;
    }
    case messages::TracingSessionHost::kDisableTracing: {
      DCHECK(message->is_serialized());
      internal::TracingSessionHost_DisableTracing_Params_Data* params =
          reinterpret_cast<internal::TracingSessionHost_DisableTracing_Params_Data*>(
              message->mutable_payload());
      

      // Validation for TracingSessionHost.1
      bool success = true;
      TracingSessionHost_DisableTracing_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TracingSessionHost::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->DisableTracing(        );
      return true;
    }
    case messages::TracingSessionHost::kReadBuffers: {
      break;
    }
    case messages::TracingSessionHost::kRequestBufferUsage: {
      break;
    }
    case messages::TracingSessionHost::kDisableTracingAndEmitJson: {
      break;
    }
  }
  return false;
}

// static
bool TracingSessionHostStubDispatch::AcceptWithResponder(
    TracingSessionHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::TracingSessionHost>(message->header()->name)) {
    case messages::TracingSessionHost::kChangeTraceConfig: {
      break;
    }
    case messages::TracingSessionHost::kDisableTracing: {
      break;
    }
    case messages::TracingSessionHost::kReadBuffers: {
      internal::TracingSessionHost_ReadBuffers_Params_Data* params =
          reinterpret_cast<
              internal::TracingSessionHost_ReadBuffers_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for TracingSessionHost.2
      bool success = true;
      ::mojo::ScopedDataPipeProducerHandle p_stream{};
      TracingSessionHost_ReadBuffers_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_stream = input_data_view.TakeStream();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TracingSessionHost::Name_, 2, false);
        return false;
      }
      auto callback =
          TracingSessionHost_ReadBuffers_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ReadBuffers(        
        std::move(p_stream), std::move(callback));
      return true;
    }
    case messages::TracingSessionHost::kRequestBufferUsage: {
      internal::TracingSessionHost_RequestBufferUsage_Params_Data* params =
          reinterpret_cast<
              internal::TracingSessionHost_RequestBufferUsage_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for TracingSessionHost.3
      bool success = true;
      TracingSessionHost_RequestBufferUsage_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TracingSessionHost::Name_, 3, false);
        return false;
      }
      auto callback =
          TracingSessionHost_RequestBufferUsage_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RequestBufferUsage(std::move(callback));
      return true;
    }
    case messages::TracingSessionHost::kDisableTracingAndEmitJson: {
      internal::TracingSessionHost_DisableTracingAndEmitJson_Params_Data* params =
          reinterpret_cast<
              internal::TracingSessionHost_DisableTracingAndEmitJson_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for TracingSessionHost.4
      bool success = true;
      std::string p_agent_label_filter{};
      ::mojo::ScopedDataPipeProducerHandle p_stream{};
      TracingSessionHost_DisableTracingAndEmitJson_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadAgentLabelFilter(&p_agent_label_filter))
        success = false;
      if (success)
        p_stream = input_data_view.TakeStream();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TracingSessionHost::Name_, 4, false);
        return false;
      }
      auto callback =
          TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->DisableTracingAndEmitJson(        
        std::move(p_agent_label_filter), 
        std::move(p_stream), std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kTracingSessionHostValidationInfo[] = {
    { &internal::TracingSessionHost_ChangeTraceConfig_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::TracingSessionHost_DisableTracing_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::TracingSessionHost_ReadBuffers_Params_Data::Validate,
     &internal::TracingSessionHost_ReadBuffers_ResponseParams_Data::Validate},
    { &internal::TracingSessionHost_RequestBufferUsage_Params_Data::Validate,
     &internal::TracingSessionHost_RequestBufferUsage_ResponseParams_Data::Validate},
    { &internal::TracingSessionHost_DisableTracingAndEmitJson_Params_Data::Validate,
     &internal::TracingSessionHost_DisableTracingAndEmitJson_ResponseParams_Data::Validate},
};

bool TracingSessionHostRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::tracing::mojom::TracingSessionHost::Name_,
    kTracingSessionHostValidationInfo);
}

bool TracingSessionHostResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::tracing::mojom::TracingSessionHost::Name_,
    kTracingSessionHostValidationInfo);
}
// The declaration includes the definition on other builds.

TracingSessionClient::IPCStableHashFunction TracingSessionClient::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::TracingSessionClient>(message.name())) {
    case messages::TracingSessionClient::kOnTracingEnabled: {
      return &TracingSessionClient::OnTracingEnabled_Sym::IPCStableHash;
    }
    case messages::TracingSessionClient::kOnTracingDisabled: {
      return &TracingSessionClient::OnTracingDisabled_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* TracingSessionClient::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::TracingSessionClient>(message.name())) {
      case messages::TracingSessionClient::kOnTracingEnabled:
            return "Receive tracing::mojom::TracingSessionClient::OnTracingEnabled";
      case messages::TracingSessionClient::kOnTracingDisabled:
            return "Receive tracing::mojom::TracingSessionClient::OnTracingDisabled";
    }
  } else {
    switch (static_cast<messages::TracingSessionClient>(message.name())) {
      case messages::TracingSessionClient::kOnTracingEnabled:
            return "Receive reply tracing::mojom::TracingSessionClient::OnTracingEnabled";
      case messages::TracingSessionClient::kOnTracingDisabled:
            return "Receive reply tracing::mojom::TracingSessionClient::OnTracingDisabled";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t TracingSessionClient::OnTracingEnabled_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x88225667;  // IPCStableHash for tracing::mojom::TracingSessionClient::OnTracingEnabled
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t TracingSessionClient::OnTracingDisabled_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x674fc95b;  // IPCStableHash for tracing::mojom::TracingSessionClient::OnTracingDisabled
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

TracingSessionClientProxy::TracingSessionClientProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void TracingSessionClientProxy::OnTracingEnabled(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send tracing::mojom::TracingSessionClient::OnTracingEnabled");
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionClient::kOnTracingEnabled), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionClient_OnTracingEnabled_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionClient::Name_);
  message.set_method_name("OnTracingEnabled");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void TracingSessionClientProxy::OnTracingDisabled(
    bool in_tracing_succeeded) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send tracing::mojom::TracingSessionClient::OnTracingDisabled", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tracing_succeeded"), in_tracing_succeeded,
                        "<value of type bool>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::TracingSessionClient::kOnTracingDisabled), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::tracing::mojom::internal::TracingSessionClient_OnTracingDisabled_Params_Data> params(
          message);
  params.Allocate();

  params->tracing_succeeded = in_tracing_succeeded;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TracingSessionClient::Name_);
  message.set_method_name("OnTracingDisabled");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

// static
bool TracingSessionClientStubDispatch::Accept(
    TracingSessionClient* impl,
    mojo::Message* message) {
  switch (static_cast<messages::TracingSessionClient>(message->header()->name)) {
    case messages::TracingSessionClient::kOnTracingEnabled: {
      DCHECK(message->is_serialized());
      internal::TracingSessionClient_OnTracingEnabled_Params_Data* params =
          reinterpret_cast<internal::TracingSessionClient_OnTracingEnabled_Params_Data*>(
              message->mutable_payload());
      

      // Validation for TracingSessionClient.0
      bool success = true;
      TracingSessionClient_OnTracingEnabled_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TracingSessionClient::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnTracingEnabled(        );
      return true;
    }
    case messages::TracingSessionClient::kOnTracingDisabled: {
      DCHECK(message->is_serialized());
      internal::TracingSessionClient_OnTracingDisabled_Params_Data* params =
          reinterpret_cast<internal::TracingSessionClient_OnTracingDisabled_Params_Data*>(
              message->mutable_payload());
      

      // Validation for TracingSessionClient.1
      bool success = true;
      bool p_tracing_succeeded{};
      TracingSessionClient_OnTracingDisabled_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tracing_succeeded = input_data_view.tracing_succeeded();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TracingSessionClient::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnTracingDisabled(        
        std::move(p_tracing_succeeded));
      return true;
    }
  }
  return false;
}

// static
bool TracingSessionClientStubDispatch::AcceptWithResponder(
    TracingSessionClient* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::TracingSessionClient>(message->header()->name)) {
    case messages::TracingSessionClient::kOnTracingEnabled: {
      break;
    }
    case messages::TracingSessionClient::kOnTracingDisabled: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kTracingSessionClientValidationInfo[] = {
    { &internal::TracingSessionClient_OnTracingEnabled_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::TracingSessionClient_OnTracingDisabled_Params_Data::Validate,
     nullptr /* no response */},
};

bool TracingSessionClientRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::tracing::mojom::TracingSessionClient::Name_,
    kTracingSessionClientValidationInfo);
}



}  // tracing::mojom


namespace mojo {


// static
bool StructTraits<::tracing::mojom::ChunksToMove::DataView, ::tracing::mojom::ChunksToMovePtr>::Read(
    ::tracing::mojom::ChunksToMove::DataView input,
    ::tracing::mojom::ChunksToMovePtr* output) {
  bool success = true;
  ::tracing::mojom::ChunksToMovePtr result(::tracing::mojom::ChunksToMove::New());
  
      if (success)
        result->page = input.page();
      if (success)
        result->chunk = input.chunk();
      if (success)
        result->target_buffer = input.target_buffer();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::ChunkPatch::DataView, ::tracing::mojom::ChunkPatchPtr>::Read(
    ::tracing::mojom::ChunkPatch::DataView input,
    ::tracing::mojom::ChunkPatchPtr* output) {
  bool success = true;
  ::tracing::mojom::ChunkPatchPtr result(::tracing::mojom::ChunkPatch::New());
  
      if (success)
        result->offset = input.offset();
      if (success && !input.ReadData(&result->data))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::ChunksToPatch::DataView, ::tracing::mojom::ChunksToPatchPtr>::Read(
    ::tracing::mojom::ChunksToPatch::DataView input,
    ::tracing::mojom::ChunksToPatchPtr* output) {
  bool success = true;
  ::tracing::mojom::ChunksToPatchPtr result(::tracing::mojom::ChunksToPatch::New());
  
      if (success)
        result->target_buffer = input.target_buffer();
      if (success)
        result->writer_id = input.writer_id();
      if (success)
        result->chunk_id = input.chunk_id();
      if (success && !input.ReadPatches(&result->patches))
        success = false;
      if (success)
        result->has_more_patches = input.has_more_patches();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::CommitDataRequest::DataView, ::tracing::mojom::CommitDataRequestPtr>::Read(
    ::tracing::mojom::CommitDataRequest::DataView input,
    ::tracing::mojom::CommitDataRequestPtr* output) {
  bool success = true;
  ::tracing::mojom::CommitDataRequestPtr result(::tracing::mojom::CommitDataRequest::New());
  
      if (success && !input.ReadChunksToMove(&result->chunks_to_move))
        success = false;
      if (success && !input.ReadChunksToPatch(&result->chunks_to_patch))
        success = false;
      if (success)
        result->flush_request_id = input.flush_request_id();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::ChromeConfig::DataView, ::tracing::mojom::ChromeConfigPtr>::Read(
    ::tracing::mojom::ChromeConfig::DataView input,
    ::tracing::mojom::ChromeConfigPtr* output) {
  bool success = true;
  ::tracing::mojom::ChromeConfigPtr result(::tracing::mojom::ChromeConfig::New());
  
      if (success && !input.ReadTraceConfig(&result->trace_config))
        success = false;
      if (success)
        result->privacy_filtering_enabled = input.privacy_filtering_enabled();
      if (success)
        result->convert_to_legacy_json = input.convert_to_legacy_json();
      if (success)
        result->event_package_name_filter_enabled = input.event_package_name_filter_enabled();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::ConsoleConfig::DataView, ::tracing::mojom::ConsoleConfigPtr>::Read(
    ::tracing::mojom::ConsoleConfig::DataView input,
    ::tracing::mojom::ConsoleConfigPtr* output) {
  bool success = true;
  ::tracing::mojom::ConsoleConfigPtr result(::tracing::mojom::ConsoleConfig::New());
  
      if (success && !input.ReadOutput(&result->output))
        success = false;
      if (success)
        result->enable_colors = input.enable_colors();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::InterceptorConfig::DataView, ::tracing::mojom::InterceptorConfigPtr>::Read(
    ::tracing::mojom::InterceptorConfig::DataView input,
    ::tracing::mojom::InterceptorConfigPtr* output) {
  bool success = true;
  ::tracing::mojom::InterceptorConfigPtr result(::tracing::mojom::InterceptorConfig::New());
  
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success && !input.ReadConsoleConfig(&result->console_config))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::DataSourceConfig::DataView, ::tracing::mojom::DataSourceConfigPtr>::Read(
    ::tracing::mojom::DataSourceConfig::DataView input,
    ::tracing::mojom::DataSourceConfigPtr* output) {
  bool success = true;
  ::tracing::mojom::DataSourceConfigPtr result(::tracing::mojom::DataSourceConfig::New());
  
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success)
        result->target_buffer = input.target_buffer();
      if (success)
        result->trace_duration_ms = input.trace_duration_ms();
      if (success)
        result->tracing_session_id = input.tracing_session_id();
      if (success && !input.ReadChromeConfig(&result->chrome_config))
        success = false;
      if (success && !input.ReadInterceptorConfig(&result->interceptor_config))
        success = false;
      if (success && !input.ReadLegacyConfig(&result->legacy_config))
        success = false;
      if (success && !input.ReadTrackEventConfigRaw(&result->track_event_config_raw))
        success = false;
      if (success && !input.ReadEtwConfigRaw(&result->etw_config_raw))
        success = false;
      if (success && !input.ReadSystemMetricsConfigRaw(&result->system_metrics_config_raw))
        success = false;
      if (success && !input.ReadHistogramSamplesConfigRaw(&result->histogram_samples_config_raw))
        success = false;
      if (success && !input.ReadChromiumSamplingHeapProfilerRaw(&result->chromium_sampling_heap_profiler_raw))
        success = false;
      if (success && !input.ReadChromiumStackSamplingProfilerRaw(&result->chromium_stack_sampling_profiler_raw))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::DataSourceRegistration::DataView, ::tracing::mojom::DataSourceRegistrationPtr>::Read(
    ::tracing::mojom::DataSourceRegistration::DataView input,
    ::tracing::mojom::DataSourceRegistrationPtr* output) {
  bool success = true;
  ::tracing::mojom::DataSourceRegistrationPtr result(::tracing::mojom::DataSourceRegistration::New());
  
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success)
        result->id = input.id();
      if (success)
        result->will_notify_on_start = input.will_notify_on_start();
      if (success)
        result->will_notify_on_stop = input.will_notify_on_stop();
      if (success)
        result->handles_incremental_state_clear = input.handles_incremental_state_clear();
      if (success && !input.ReadTrackEventDescriptorRaw(&result->track_event_descriptor_raw))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::BufferConfig::DataView, ::tracing::mojom::BufferConfigPtr>::Read(
    ::tracing::mojom::BufferConfig::DataView input,
    ::tracing::mojom::BufferConfigPtr* output) {
  bool success = true;
  ::tracing::mojom::BufferConfigPtr result(::tracing::mojom::BufferConfig::New());
  
      if (success)
        result->size_kb = input.size_kb();
      if (success && !input.ReadFillPolicy(&result->fill_policy))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::DataSource::DataView, ::tracing::mojom::DataSourcePtr>::Read(
    ::tracing::mojom::DataSource::DataView input,
    ::tracing::mojom::DataSourcePtr* output) {
  bool success = true;
  ::tracing::mojom::DataSourcePtr result(::tracing::mojom::DataSource::New());
  
      if (success && !input.ReadConfig(&result->config))
        success = false;
      if (success && !input.ReadProducerNameFilter(&result->producer_name_filter))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::PerfettoBuiltinDataSource::DataView, ::tracing::mojom::PerfettoBuiltinDataSourcePtr>::Read(
    ::tracing::mojom::PerfettoBuiltinDataSource::DataView input,
    ::tracing::mojom::PerfettoBuiltinDataSourcePtr* output) {
  bool success = true;
  ::tracing::mojom::PerfettoBuiltinDataSourcePtr result(::tracing::mojom::PerfettoBuiltinDataSource::New());
  
      if (success)
        result->disable_clock_snapshotting = input.disable_clock_snapshotting();
      if (success)
        result->disable_trace_config = input.disable_trace_config();
      if (success)
        result->disable_system_info = input.disable_system_info();
      if (success)
        result->disable_service_events = input.disable_service_events();
      if (success)
        result->primary_trace_clock_id = input.primary_trace_clock_id();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::IncrementalStateConfig::DataView, ::tracing::mojom::IncrementalStateConfigPtr>::Read(
    ::tracing::mojom::IncrementalStateConfig::DataView input,
    ::tracing::mojom::IncrementalStateConfigPtr* output) {
  bool success = true;
  ::tracing::mojom::IncrementalStateConfigPtr result(::tracing::mojom::IncrementalStateConfig::New());
  
      if (success)
        result->clear_period_ms = input.clear_period_ms();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::tracing::mojom::TraceConfig::DataView, ::tracing::mojom::TraceConfigPtr>::Read(
    ::tracing::mojom::TraceConfig::DataView input,
    ::tracing::mojom::TraceConfigPtr* output) {
  bool success = true;
  ::tracing::mojom::TraceConfigPtr result(::tracing::mojom::TraceConfig::New());
  
      if (success && !input.ReadDataSources(&result->data_sources))
        success = false;
      if (success && !input.ReadPerfettoBuiltinDataSource(&result->perfetto_builtin_data_source))
        success = false;
      if (success && !input.ReadBuffers(&result->buffers))
        success = false;
      if (success && !input.ReadIncrementalStateConfig(&result->incremental_state_config))
        success = false;
      if (success)
        result->duration_ms = input.duration_ms();
      if (success)
        result->write_into_file = input.write_into_file();
      if (success && !input.ReadTraceUuid(&result->trace_uuid))
        success = false;
      if (success && !input.ReadUniqueSessionName(&result->unique_session_name))
        success = false;
  *output = std::move(result);
  return success;
}

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace tracing::mojom {


void ProducerHostInterceptorForTesting::CommitData(const ::perfetto::CommitDataRequest& data_request, CommitDataCallback callback) {
  GetForwardingInterface()->CommitData(
    std::move(data_request)
    , std::move(callback));
}
void ProducerHostInterceptorForTesting::RegisterDataSource(const ::perfetto::DataSourceDescriptor& registration_info) {
  GetForwardingInterface()->RegisterDataSource(
    std::move(registration_info)
    );
}
void ProducerHostInterceptorForTesting::UpdateDataSource(const ::perfetto::DataSourceDescriptor& registration_info) {
  GetForwardingInterface()->UpdateDataSource(
    std::move(registration_info)
    );
}
void ProducerHostInterceptorForTesting::RegisterTraceWriter(uint32_t writer_id, uint32_t target_buffer) {
  GetForwardingInterface()->RegisterTraceWriter(
    std::move(writer_id)
    , 
    std::move(target_buffer)
    );
}
void ProducerHostInterceptorForTesting::UnregisterTraceWriter(uint32_t writer_id) {
  GetForwardingInterface()->UnregisterTraceWriter(
    std::move(writer_id)
    );
}
ProducerHostAsyncWaiter::ProducerHostAsyncWaiter(
    ProducerHost* proxy) : proxy_(proxy) {}

ProducerHostAsyncWaiter::~ProducerHostAsyncWaiter() = default;


void ProducerHostAsyncWaiter::CommitData(
    const ::perfetto::CommitDataRequest& data_request) {
  base::RunLoop loop;
  proxy_->CommitData(
      std::move(data_request),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}






void ProducerClientInterceptorForTesting::OnTracingStart() {
  GetForwardingInterface()->OnTracingStart();
}
void ProducerClientInterceptorForTesting::StartDataSource(uint64_t id, const ::perfetto::DataSourceConfig& data_source_config, StartDataSourceCallback callback) {
  GetForwardingInterface()->StartDataSource(
    std::move(id)
    , 
    std::move(data_source_config)
    , std::move(callback));
}
void ProducerClientInterceptorForTesting::StopDataSource(uint64_t id, StopDataSourceCallback callback) {
  GetForwardingInterface()->StopDataSource(
    std::move(id)
    , std::move(callback));
}
void ProducerClientInterceptorForTesting::Flush(uint64_t flush_request_id, const std::vector<uint64_t>& data_source_ids) {
  GetForwardingInterface()->Flush(
    std::move(flush_request_id)
    , 
    std::move(data_source_ids)
    );
}
void ProducerClientInterceptorForTesting::ClearIncrementalState() {
  GetForwardingInterface()->ClearIncrementalState();
}
ProducerClientAsyncWaiter::ProducerClientAsyncWaiter(
    ProducerClient* proxy) : proxy_(proxy) {}

ProducerClientAsyncWaiter::~ProducerClientAsyncWaiter() = default;


void ProducerClientAsyncWaiter::StartDataSource(
    uint64_t id, const ::perfetto::DataSourceConfig& data_source_config) {
  base::RunLoop loop;
  proxy_->StartDataSource(
      std::move(id),
      std::move(data_source_config),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void ProducerClientAsyncWaiter::StopDataSource(
    uint64_t id) {
  base::RunLoop loop;
  proxy_->StopDataSource(
      std::move(id),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}






void PerfettoServiceInterceptorForTesting::ConnectToProducerHost(::mojo::PendingRemote<ProducerClient> producer_client, ::mojo::PendingReceiver<ProducerHost> producer_host_receiver, ::base::UnsafeSharedMemoryRegion shared_memory, uint64_t shared_memory_buffer_page_size_bytes) {
  GetForwardingInterface()->ConnectToProducerHost(
    std::move(producer_client)
    , 
    std::move(producer_host_receiver)
    , 
    std::move(shared_memory)
    , 
    std::move(shared_memory_buffer_page_size_bytes)
    );
}
PerfettoServiceAsyncWaiter::PerfettoServiceAsyncWaiter(
    PerfettoService* proxy) : proxy_(proxy) {}

PerfettoServiceAsyncWaiter::~PerfettoServiceAsyncWaiter() = default;





void ConsumerHostInterceptorForTesting::EnableTracing(::mojo::PendingReceiver<TracingSessionHost> tracing_session_host, ::mojo::PendingRemote<TracingSessionClient> tracing_session_client, const ::perfetto::TraceConfig& config, ::base::File output_file) {
  GetForwardingInterface()->EnableTracing(
    std::move(tracing_session_host)
    , 
    std::move(tracing_session_client)
    , 
    std::move(config)
    , 
    std::move(output_file)
    );
}
void ConsumerHostInterceptorForTesting::CloneSession(::mojo::PendingReceiver<TracingSessionHost> tracing_session_host, ::mojo::PendingRemote<TracingSessionClient> tracing_session_client, const ::base::UnguessableToken& unguessable_name, CloneSessionCallback callback) {
  GetForwardingInterface()->CloneSession(
    std::move(tracing_session_host)
    , 
    std::move(tracing_session_client)
    , 
    std::move(unguessable_name)
    , std::move(callback));
}
void ConsumerHostInterceptorForTesting::QueryServiceState(QueryServiceStateCallback callback) {
  GetForwardingInterface()->QueryServiceState(std::move(callback));
}
ConsumerHostAsyncWaiter::ConsumerHostAsyncWaiter(
    ConsumerHost* proxy) : proxy_(proxy) {}

ConsumerHostAsyncWaiter::~ConsumerHostAsyncWaiter() = default;


void ConsumerHostAsyncWaiter::CloneSession(
    ::mojo::PendingReceiver<TracingSessionHost> tracing_session_host, ::mojo::PendingRemote<TracingSessionClient> tracing_session_client, const ::base::UnguessableToken& unguessable_name, bool* out_success, std::string* out_error, ::base::Token* out_uuid) {
  base::RunLoop loop;
  proxy_->CloneSession(
      std::move(tracing_session_host),
      std::move(tracing_session_client),
      std::move(unguessable_name),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             std::string* out_error
,
             ::base::Token* out_uuid
,
             bool success,
             const std::string& error,
             const ::base::Token& uuid) {*out_success = std::move(success);*out_error = std::move(error);*out_uuid = std::move(uuid);
            loop->Quit();
          },
          &loop,
          out_success,
          out_error,
          out_uuid));
  loop.Run();
}



void ConsumerHostAsyncWaiter::QueryServiceState(
    bool* out_success, std::string* out_service_state_data) {
  base::RunLoop loop;
  proxy_->QueryServiceState(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             std::string* out_service_state_data
,
             bool success,
             const std::string& service_state_data) {*out_success = std::move(success);*out_service_state_data = std::move(service_state_data);
            loop->Quit();
          },
          &loop,
          out_success,
          out_service_state_data));
  loop.Run();
}






void TracingSessionHostInterceptorForTesting::ChangeTraceConfig(const ::perfetto::TraceConfig& config) {
  GetForwardingInterface()->ChangeTraceConfig(
    std::move(config)
    );
}
void TracingSessionHostInterceptorForTesting::DisableTracing() {
  GetForwardingInterface()->DisableTracing();
}
void TracingSessionHostInterceptorForTesting::ReadBuffers(::mojo::ScopedDataPipeProducerHandle stream, ReadBuffersCallback callback) {
  GetForwardingInterface()->ReadBuffers(
    std::move(stream)
    , std::move(callback));
}
void TracingSessionHostInterceptorForTesting::RequestBufferUsage(RequestBufferUsageCallback callback) {
  GetForwardingInterface()->RequestBufferUsage(std::move(callback));
}
void TracingSessionHostInterceptorForTesting::DisableTracingAndEmitJson(const std::string& agent_label_filter, ::mojo::ScopedDataPipeProducerHandle stream, DisableTracingAndEmitJsonCallback callback) {
  GetForwardingInterface()->DisableTracingAndEmitJson(
    std::move(agent_label_filter)
    , 
    std::move(stream)
    , std::move(callback));
}
TracingSessionHostAsyncWaiter::TracingSessionHostAsyncWaiter(
    TracingSessionHost* proxy) : proxy_(proxy) {}

TracingSessionHostAsyncWaiter::~TracingSessionHostAsyncWaiter() = default;


void TracingSessionHostAsyncWaiter::ReadBuffers(
    ::mojo::ScopedDataPipeProducerHandle stream) {
  base::RunLoop loop;
  proxy_->ReadBuffers(
      std::move(stream),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void TracingSessionHostAsyncWaiter::RequestBufferUsage(
    bool* out_success, float* out_percent_full, bool* out_data_loss) {
  base::RunLoop loop;
  proxy_->RequestBufferUsage(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             float* out_percent_full
,
             bool* out_data_loss
,
             bool success,
             float percent_full,
             bool data_loss) {*out_success = std::move(success);*out_percent_full = std::move(percent_full);*out_data_loss = std::move(data_loss);
            loop->Quit();
          },
          &loop,
          out_success,
          out_percent_full,
          out_data_loss));
  loop.Run();
}



void TracingSessionHostAsyncWaiter::DisableTracingAndEmitJson(
    const std::string& agent_label_filter, ::mojo::ScopedDataPipeProducerHandle stream) {
  base::RunLoop loop;
  proxy_->DisableTracingAndEmitJson(
      std::move(agent_label_filter),
      std::move(stream),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}






void TracingSessionClientInterceptorForTesting::OnTracingEnabled() {
  GetForwardingInterface()->OnTracingEnabled();
}
void TracingSessionClientInterceptorForTesting::OnTracingDisabled(bool tracing_succeeded) {
  GetForwardingInterface()->OnTracingDisabled(
    std::move(tracing_succeeded)
    );
}
TracingSessionClientAsyncWaiter::TracingSessionClientAsyncWaiter(
    TracingSessionClient* proxy) : proxy_(proxy) {}

TracingSessionClientAsyncWaiter::~TracingSessionClientAsyncWaiter() = default;







}  // tracing::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif