perfetto_service.mojom.cc | Explore in Territory

// 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/hash/md5_constexpr.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/features.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_util.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 {
const char kPerfettoProducerNamePrefix[] = …;
const char kTraceEventDataSourceName[] = …;
const char kMemoryInstrumentationDataSourceName[] = …;
const char kMetaDataSourceName[] = …;
const char kSystemTraceDataSourceName[] = …;
const char kArcTraceDataSourceName[] = …;
const char kSamplerProfilerSourceName[] = …;
const char kJavaHeapProfilerSourceName[] = …;
const char kNativeHeapProfilerSourceName[] = …;
ChunksToMove::ChunksToMove()
    : … { … }

ChunksToMove::ChunksToMove(
    uint32_t page_in,
    uint32_t chunk_in,
    uint32_t target_buffer_in)
    : … { … }

ChunksToMove::~ChunksToMove() = default;

void ChunksToMove::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ChunksToMove::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ChunkPatch::ChunkPatch()
    : … { … }

ChunkPatch::ChunkPatch(
    uint32_t offset_in,
    const std::string& data_in)
    : … { … }

ChunkPatch::~ChunkPatch() = default;

void ChunkPatch::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ChunkPatch::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ChunksToPatch::ChunksToPatch()
    : … { … }

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)
    : … { … }

ChunksToPatch::~ChunksToPatch() = default;

void ChunksToPatch::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ChunksToPatch::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
CommitDataRequest::CommitDataRequest()
    : … { … }

CommitDataRequest::CommitDataRequest(
    std::vector<::perfetto::CommitDataRequest::ChunksToMove> chunks_to_move_in,
    std::vector<ChunksToPatchPtr> chunks_to_patch_in,
    uint64_t flush_request_id_in)
    : … { … }

CommitDataRequest::~CommitDataRequest() = default;

void CommitDataRequest::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool CommitDataRequest::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ChromeConfig::ChromeConfig()
    : … { … }

ChromeConfig::ChromeConfig(
    const std::string& trace_config_in,
    bool privacy_filtering_enabled_in,
    bool convert_to_legacy_json_in,
    TracingClientPriority client_priority_in)
    : … { … }

ChromeConfig::~ChromeConfig() = default;

void ChromeConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ChromeConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ConsoleConfig::ConsoleConfig()
    : … { … }

ConsoleConfig::ConsoleConfig(
    ConsoleOutput output_in,
    bool enable_colors_in)
    : … { … }

ConsoleConfig::~ConsoleConfig() = default;
size_t ConsoleConfig::Hash(size_t seed) const { … }

void ConsoleConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ConsoleConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
InterceptorConfig::InterceptorConfig()
    : … { … }

InterceptorConfig::InterceptorConfig(
    const std::string& name_in,
    ConsoleConfigPtr console_config_in)
    : … { … }

InterceptorConfig::~InterceptorConfig() = default;

void InterceptorConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool InterceptorConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
DataSourceConfig::DataSourceConfig()
    : … { … }

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)
    : … { … }

DataSourceConfig::~DataSourceConfig() = default;

void DataSourceConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool DataSourceConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
DataSourceRegistration::DataSourceRegistration()
    : … { … }

DataSourceRegistration::DataSourceRegistration(
    const std::string& name_in,
    bool will_notify_on_start_in,
    bool will_notify_on_stop_in,
    bool handles_incremental_state_clear_in)
    : … { … }

DataSourceRegistration::~DataSourceRegistration() = default;

void DataSourceRegistration::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool DataSourceRegistration::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
BufferConfig::BufferConfig()
    : … { … }

BufferConfig::BufferConfig(
    uint32_t size_kb_in,
    ::perfetto::TraceConfig::BufferConfig::FillPolicy fill_policy_in)
    : … { … }

BufferConfig::~BufferConfig() = default;

void BufferConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool BufferConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
DataSource::DataSource()
    : … { … }

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

DataSource::~DataSource() = default;

void DataSource::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool DataSource::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PerfettoBuiltinDataSource::PerfettoBuiltinDataSource()
    : … { … }

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)
    : … { … }

PerfettoBuiltinDataSource::~PerfettoBuiltinDataSource() = default;

void PerfettoBuiltinDataSource::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PerfettoBuiltinDataSource::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
IncrementalStateConfig::IncrementalStateConfig()
    : … { … }

IncrementalStateConfig::IncrementalStateConfig(
    uint32_t clear_period_ms_in)
    : … { … }

IncrementalStateConfig::~IncrementalStateConfig() = default;

void IncrementalStateConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool IncrementalStateConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
TraceConfig::TraceConfig()
    : … { … }

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)
    : … { … }

TraceConfig::~TraceConfig() = default;

void TraceConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool TraceConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char ProducerHost::Name_[] = …;

ProducerHost::IPCStableHashFunction ProducerHost::MessageToMethodInfo_(mojo::Message& message) { … }


const char* ProducerHost::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ProducerHost::CommitData_Sym::IPCStableHash() { … }
uint32_t ProducerHost::RegisterDataSource_Sym::IPCStableHash() { … }
uint32_t ProducerHost::RegisterTraceWriter_Sym::IPCStableHash() { … }
uint32_t ProducerHost::UnregisterTraceWriter_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class ProducerHost_CommitData_ForwardToCallback
    : public mojo::MessageReceiver { … };

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

void ProducerHostProxy::CommitData(
    const ::perfetto::CommitDataRequest& in_data_request, CommitDataCallback callback) { … }

void ProducerHostProxy::RegisterDataSource(
    const ::perfetto::DataSourceDescriptor& in_registration_info) { … }

void ProducerHostProxy::RegisterTraceWriter(
    uint32_t in_writer_id, uint32_t in_target_buffer) { … }

void ProducerHostProxy::UnregisterTraceWriter(
    uint32_t in_writer_id) { … }
class ProducerHost_CommitData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ProducerHost_CommitData_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ProducerHost_CommitData_ProxyToResponder::Run(
    ) { … }

// static
bool ProducerHostStubDispatch::Accept(
    ProducerHost* impl,
    mojo::Message* message) { … }

// static
bool ProducerHostStubDispatch::AcceptWithResponder(
    ProducerHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kProducerHostValidationInfo[] = …;

bool ProducerHostRequestValidator::Accept(mojo::Message* message) { … }

bool ProducerHostResponseValidator::Accept(mojo::Message* message) { … }
const char ProducerClient::Name_[] = …;

ProducerClient::IPCStableHashFunction ProducerClient::MessageToMethodInfo_(mojo::Message& message) { … }


const char* ProducerClient::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ProducerClient::OnTracingStart_Sym::IPCStableHash() { … }
uint32_t ProducerClient::StartDataSource_Sym::IPCStableHash() { … }
uint32_t ProducerClient::StopDataSource_Sym::IPCStableHash() { … }
uint32_t ProducerClient::Flush_Sym::IPCStableHash() { … }
uint32_t ProducerClient::ClearIncrementalState_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class ProducerClient_StartDataSource_ForwardToCallback
    : public mojo::MessageReceiver { … };

class ProducerClient_StopDataSource_ForwardToCallback
    : public mojo::MessageReceiver { … };

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

void ProducerClientProxy::OnTracingStart(
    ) { … }

void ProducerClientProxy::StartDataSource(
    uint64_t in_id, const ::perfetto::DataSourceConfig& in_data_source_config, StartDataSourceCallback callback) { … }

void ProducerClientProxy::StopDataSource(
    uint64_t in_id, StopDataSourceCallback callback) { … }

void ProducerClientProxy::Flush(
    uint64_t in_flush_request_id, const std::vector<uint64_t>& in_data_source_ids) { … }

void ProducerClientProxy::ClearIncrementalState(
    ) { … }
class ProducerClient_StartDataSource_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ProducerClient_StartDataSource_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ProducerClient_StartDataSource_ProxyToResponder::Run(
    ) { … }
class ProducerClient_StopDataSource_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ProducerClient_StopDataSource_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ProducerClient_StopDataSource_ProxyToResponder::Run(
    ) { … }

// static
bool ProducerClientStubDispatch::Accept(
    ProducerClient* impl,
    mojo::Message* message) { … }

// static
bool ProducerClientStubDispatch::AcceptWithResponder(
    ProducerClient* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kProducerClientValidationInfo[] = …;

bool ProducerClientRequestValidator::Accept(mojo::Message* message) { … }

bool ProducerClientResponseValidator::Accept(mojo::Message* message) { … }
const char PerfettoService::Name_[] = …;

PerfettoService::IPCStableHashFunction PerfettoService::MessageToMethodInfo_(mojo::Message& message) { … }


const char* PerfettoService::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t PerfettoService::ConnectToProducerHost_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

PerfettoServiceProxy::PerfettoServiceProxy(mojo::MessageReceiverWithResponder* 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) { … }

// static
bool PerfettoServiceStubDispatch::Accept(
    PerfettoService* impl,
    mojo::Message* message) { … }

// static
bool PerfettoServiceStubDispatch::AcceptWithResponder(
    PerfettoService* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kPerfettoServiceValidationInfo[] = …;

bool PerfettoServiceRequestValidator::Accept(mojo::Message* message) { … }

const char ConsumerHost::Name_[] = …;

ConsumerHost::IPCStableHashFunction ConsumerHost::MessageToMethodInfo_(mojo::Message& message) { … }


const char* ConsumerHost::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ConsumerHost::EnableTracing_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

ConsumerHostProxy::ConsumerHostProxy(mojo::MessageReceiverWithResponder* 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) { … }

// static
bool ConsumerHostStubDispatch::Accept(
    ConsumerHost* impl,
    mojo::Message* message) { … }

// static
bool ConsumerHostStubDispatch::AcceptWithResponder(
    ConsumerHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kConsumerHostValidationInfo[] = …;

bool ConsumerHostRequestValidator::Accept(mojo::Message* message) { … }

const char TracingSessionHost::Name_[] = …;

TracingSessionHost::IPCStableHashFunction TracingSessionHost::MessageToMethodInfo_(mojo::Message& message) { … }


const char* TracingSessionHost::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t TracingSessionHost::ChangeTraceConfig_Sym::IPCStableHash() { … }
uint32_t TracingSessionHost::DisableTracing_Sym::IPCStableHash() { … }
uint32_t TracingSessionHost::ReadBuffers_Sym::IPCStableHash() { … }
uint32_t TracingSessionHost::RequestBufferUsage_Sym::IPCStableHash() { … }
uint32_t TracingSessionHost::DisableTracingAndEmitJson_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class TracingSessionHost_ReadBuffers_ForwardToCallback
    : public mojo::MessageReceiver { … };

class TracingSessionHost_RequestBufferUsage_ForwardToCallback
    : public mojo::MessageReceiver { … };

class TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback
    : public mojo::MessageReceiver { … };

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

void TracingSessionHostProxy::ChangeTraceConfig(
    const ::perfetto::TraceConfig& in_config) { … }

void TracingSessionHostProxy::DisableTracing(
    ) { … }

void TracingSessionHostProxy::ReadBuffers(
    ::mojo::ScopedDataPipeProducerHandle in_stream, ReadBuffersCallback callback) { … }

void TracingSessionHostProxy::RequestBufferUsage(
    RequestBufferUsageCallback callback) { … }

void TracingSessionHostProxy::DisableTracingAndEmitJson(
    const std::string& in_agent_label_filter, ::mojo::ScopedDataPipeProducerHandle in_stream, bool in_privacy_filtering_enabled, DisableTracingAndEmitJsonCallback callback) { … }
class TracingSessionHost_ReadBuffers_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool TracingSessionHost_ReadBuffers_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void TracingSessionHost_ReadBuffers_ProxyToResponder::Run(
    ) { … }
class TracingSessionHost_RequestBufferUsage_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool TracingSessionHost_RequestBufferUsage_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void TracingSessionHost_RequestBufferUsage_ProxyToResponder::Run(
    bool in_success, float in_percent_full, bool in_data_loss) { … }
class TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool TracingSessionHost_DisableTracingAndEmitJson_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void TracingSessionHost_DisableTracingAndEmitJson_ProxyToResponder::Run(
    ) { … }

// static
bool TracingSessionHostStubDispatch::Accept(
    TracingSessionHost* impl,
    mojo::Message* message) { … }

// static
bool TracingSessionHostStubDispatch::AcceptWithResponder(
    TracingSessionHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kTracingSessionHostValidationInfo[] = …;

bool TracingSessionHostRequestValidator::Accept(mojo::Message* message) { … }

bool TracingSessionHostResponseValidator::Accept(mojo::Message* message) { … }
const char TracingSessionClient::Name_[] = …;

TracingSessionClient::IPCStableHashFunction TracingSessionClient::MessageToMethodInfo_(mojo::Message& message) { … }


const char* TracingSessionClient::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t TracingSessionClient::OnTracingEnabled_Sym::IPCStableHash() { … }
uint32_t TracingSessionClient::OnTracingDisabled_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void TracingSessionClientProxy::OnTracingEnabled(
    ) { … }

void TracingSessionClientProxy::OnTracingDisabled(
    bool in_tracing_succeeded) { … }

// static
bool TracingSessionClientStubDispatch::Accept(
    TracingSessionClient* impl,
    mojo::Message* message) { … }

// static
bool TracingSessionClientStubDispatch::AcceptWithResponder(
    TracingSessionClient* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kTracingSessionClientValidationInfo[] = …;

bool TracingSessionClientRequestValidator::Accept(mojo::Message* message) { … }



}  // tracing::mojom


namespace mojo {


// static
bool StructTraits<::tracing::mojom::ChunksToMove::DataView, ::tracing::mojom::ChunksToMovePtr>::Read(
    ::tracing::mojom::ChunksToMove::DataView input,
    ::tracing::mojom::ChunksToMovePtr* output) { … }


// static
bool StructTraits<::tracing::mojom::ChunkPatch::DataView, ::tracing::mojom::ChunkPatchPtr>::Read(
    ::tracing::mojom::ChunkPatch::DataView input,
    ::tracing::mojom::ChunkPatchPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::ChunksToPatch::DataView, ::tracing::mojom::ChunksToPatchPtr>::Read(
    ::tracing::mojom::ChunksToPatch::DataView input,
    ::tracing::mojom::ChunksToPatchPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::CommitDataRequest::DataView, ::tracing::mojom::CommitDataRequestPtr>::Read(
    ::tracing::mojom::CommitDataRequest::DataView input,
    ::tracing::mojom::CommitDataRequestPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::ChromeConfig::DataView, ::tracing::mojom::ChromeConfigPtr>::Read(
    ::tracing::mojom::ChromeConfig::DataView input,
    ::tracing::mojom::ChromeConfigPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::ConsoleConfig::DataView, ::tracing::mojom::ConsoleConfigPtr>::Read(
    ::tracing::mojom::ConsoleConfig::DataView input,
    ::tracing::mojom::ConsoleConfigPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::InterceptorConfig::DataView, ::tracing::mojom::InterceptorConfigPtr>::Read(
    ::tracing::mojom::InterceptorConfig::DataView input,
    ::tracing::mojom::InterceptorConfigPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::DataSourceConfig::DataView, ::tracing::mojom::DataSourceConfigPtr>::Read(
    ::tracing::mojom::DataSourceConfig::DataView input,
    ::tracing::mojom::DataSourceConfigPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::DataSourceRegistration::DataView, ::tracing::mojom::DataSourceRegistrationPtr>::Read(
    ::tracing::mojom::DataSourceRegistration::DataView input,
    ::tracing::mojom::DataSourceRegistrationPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::BufferConfig::DataView, ::tracing::mojom::BufferConfigPtr>::Read(
    ::tracing::mojom::BufferConfig::DataView input,
    ::tracing::mojom::BufferConfigPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::DataSource::DataView, ::tracing::mojom::DataSourcePtr>::Read(
    ::tracing::mojom::DataSource::DataView input,
    ::tracing::mojom::DataSourcePtr* output) { … }


// static
bool StructTraits<::tracing::mojom::PerfettoBuiltinDataSource::DataView, ::tracing::mojom::PerfettoBuiltinDataSourcePtr>::Read(
    ::tracing::mojom::PerfettoBuiltinDataSource::DataView input,
    ::tracing::mojom::PerfettoBuiltinDataSourcePtr* output) { … }


// static
bool StructTraits<::tracing::mojom::IncrementalStateConfig::DataView, ::tracing::mojom::IncrementalStateConfigPtr>::Read(
    ::tracing::mojom::IncrementalStateConfig::DataView input,
    ::tracing::mojom::IncrementalStateConfigPtr* output) { … }


// static
bool StructTraits<::tracing::mojom::TraceConfig::DataView, ::tracing::mojom::TraceConfigPtr>::Read(
    ::tracing::mojom::TraceConfig::DataView input,
    ::tracing::mojom::TraceConfigPtr* output) { … }

}  // 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) { … }
void ProducerHostInterceptorForTesting::RegisterDataSource(const ::perfetto::DataSourceDescriptor& registration_info) { … }
void ProducerHostInterceptorForTesting::RegisterTraceWriter(uint32_t writer_id, uint32_t target_buffer) { … }
void ProducerHostInterceptorForTesting::UnregisterTraceWriter(uint32_t writer_id) { … }
ProducerHostAsyncWaiter::ProducerHostAsyncWaiter(
    ProducerHost* proxy) : … { … }

ProducerHostAsyncWaiter::~ProducerHostAsyncWaiter() = default;

void ProducerHostAsyncWaiter::CommitData(
    const ::perfetto::CommitDataRequest& data_request) { … }






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

ProducerClientAsyncWaiter::~ProducerClientAsyncWaiter() = default;

void ProducerClientAsyncWaiter::StartDataSource(
    uint64_t id, const ::perfetto::DataSourceConfig& data_source_config) { … }



void ProducerClientAsyncWaiter::StopDataSource(
    uint64_t id) { … }






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) { … }
PerfettoServiceAsyncWaiter::PerfettoServiceAsyncWaiter(
    PerfettoService* 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) { … }
ConsumerHostAsyncWaiter::ConsumerHostAsyncWaiter(
    ConsumerHost* proxy) : … { … }

ConsumerHostAsyncWaiter::~ConsumerHostAsyncWaiter() = default;




void TracingSessionHostInterceptorForTesting::ChangeTraceConfig(const ::perfetto::TraceConfig& config) { … }
void TracingSessionHostInterceptorForTesting::DisableTracing() { … }
void TracingSessionHostInterceptorForTesting::ReadBuffers(::mojo::ScopedDataPipeProducerHandle stream, ReadBuffersCallback callback) { … }
void TracingSessionHostInterceptorForTesting::RequestBufferUsage(RequestBufferUsageCallback callback) { … }
void TracingSessionHostInterceptorForTesting::DisableTracingAndEmitJson(const std::string& agent_label_filter, ::mojo::ScopedDataPipeProducerHandle stream, bool privacy_filtering_enabled, DisableTracingAndEmitJsonCallback callback) { … }
TracingSessionHostAsyncWaiter::TracingSessionHostAsyncWaiter(
    TracingSessionHost* proxy) : … { … }

TracingSessionHostAsyncWaiter::~TracingSessionHostAsyncWaiter() = default;

void TracingSessionHostAsyncWaiter::ReadBuffers(
    ::mojo::ScopedDataPipeProducerHandle stream) { … }



void TracingSessionHostAsyncWaiter::RequestBufferUsage(
    bool* out_success, float* out_percent_full, bool* out_data_loss) { … }



void TracingSessionHostAsyncWaiter::DisableTracingAndEmitJson(
    const std::string& agent_label_filter, ::mojo::ScopedDataPipeProducerHandle stream, bool privacy_filtering_enabled) { … }






void TracingSessionClientInterceptorForTesting::OnTracingEnabled() { … }
void TracingSessionClientInterceptorForTesting::OnTracingDisabled(bool tracing_succeeded) { … }
TracingSessionClientAsyncWaiter::TracingSessionClientAsyncWaiter(
    TracingSessionClient* proxy) : … { … }

TracingSessionClientAsyncWaiter::~TracingSessionClientAsyncWaiter() = default;






}  // tracing::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/services/tracing/public/mojom/perfetto_service.mojom.cc
