memory_instrumentation.mojom.cc | Explore in Territory

// services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.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/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.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/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-params-data.h"
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-shared-message-ids.h"

#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-import-headers.h"
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-test-utils.h"


namespace memory_instrumentation::mojom {
constexpr uint32_t VmRegion::kProtectionFlagsRead;
constexpr uint32_t VmRegion::kProtectionFlagsWrite;
constexpr uint32_t VmRegion::kProtectionFlagsExec;
constexpr uint32_t VmRegion::kProtectionFlagsMayshare;
RequestArgs::RequestArgs()
    : … { … }

RequestArgs::RequestArgs(
    uint64_t dump_guid_in,
    ::base::trace_event::MemoryDumpType dump_type_in,
    ::base::trace_event::MemoryDumpLevelOfDetail level_of_detail_in,
    ::base::trace_event::MemoryDumpDeterminism determinism_in)
    : … { … }

RequestArgs::~RequestArgs() = default;

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

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

RawAllocatorDumpEdge::RawAllocatorDumpEdge(
    uint64_t source_id_in,
    uint64_t target_id_in,
    int32_t importance_in,
    bool overridable_in)
    : … { … }

RawAllocatorDumpEdge::~RawAllocatorDumpEdge() = default;

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

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

RawAllocatorDumpEntry::RawAllocatorDumpEntry(
    const std::string& name_in,
    const std::string& units_in,
    RawAllocatorDumpEntryValuePtr value_in)
    : … { … }

RawAllocatorDumpEntry::~RawAllocatorDumpEntry() = default;

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

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

RawAllocatorDump::RawAllocatorDump(
    uint64_t id_in,
    const std::string& absolute_name_in,
    bool weak_in,
    ::base::trace_event::MemoryDumpLevelOfDetail level_of_detail_in,
    std::vector<::base::trace_event::MemoryAllocatorDump::Entry> entries_in)
    : … { … }

RawAllocatorDump::~RawAllocatorDump() = default;

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

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

RawProcessMemoryDump::RawProcessMemoryDump(
    ::base::trace_event::MemoryDumpLevelOfDetail level_of_detail_in,
    std::vector<::base::trace_event::ProcessMemoryDump::MemoryAllocatorDumpEdge> allocator_dump_edges_in,
    std::vector<::std::unique_ptr<::base::trace_event::MemoryAllocatorDump>> allocator_dumps_in)
    : … { … }

RawProcessMemoryDump::~RawProcessMemoryDump() = default;

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

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

VmRegion::VmRegion(
    uint64_t start_address_in,
    uint64_t size_in_bytes_in,
    uint64_t module_timestamp_in,
    const std::string& module_debugid_in,
    const std::string& module_debug_path_in,
    uint32_t protection_flags_in,
    const std::string& mapped_file_in,
    uint64_t byte_stats_private_dirty_resident_in,
    uint64_t byte_stats_private_clean_resident_in,
    uint64_t byte_stats_shared_dirty_resident_in,
    uint64_t byte_stats_shared_clean_resident_in,
    uint64_t byte_stats_swapped_in,
    uint64_t byte_locked_in,
    uint64_t byte_stats_proportional_resident_in)
    : … { … }

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

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

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

PlatformPrivateFootprint::PlatformPrivateFootprint(
    uint64_t phys_footprint_bytes_in,
    uint64_t internal_bytes_in,
    uint64_t compressed_bytes_in,
    uint64_t rss_anon_bytes_in,
    uint64_t vm_swap_bytes_in,
    uint64_t private_bytes_in)
    : … { … }

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

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

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

RawOSMemDump::RawOSMemDump(
    uint32_t resident_set_kb_in,
    uint32_t peak_resident_set_kb_in,
    bool is_peak_rss_resettable_in,
    PlatformPrivateFootprintPtr platform_private_footprint_in,
    std::vector<VmRegionPtr> memory_maps_in,
    std::vector<uint8_t> native_library_pages_bitmap_in)
    : … { … }

RawOSMemDump::~RawOSMemDump() = default;

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

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

OSMemDump::OSMemDump(
    uint32_t resident_set_kb_in,
    uint32_t peak_resident_set_kb_in,
    bool is_peak_rss_resettable_in,
    uint32_t private_footprint_kb_in,
    uint32_t shared_footprint_kb_in,
    uint32_t private_footprint_swap_kb_in)
    : … { … }

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

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

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

AllocatorMemDump::AllocatorMemDump(
    const base::flat_map<std::string, uint64_t>& numeric_entries_in,
    base::flat_map<std::string, AllocatorMemDumpPtr> children_in)
    : … { … }

AllocatorMemDump::~AllocatorMemDump() = default;

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

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

ProcessMemoryDump::ProcessMemoryDump(
    ProcessType process_type_in,
    OSMemDumpPtr os_dump_in,
    base::flat_map<std::string, AllocatorMemDumpPtr> chrome_allocator_dumps_in,
    ::base::ProcessId pid_in,
    const std::optional<std::string>& service_name_in)
    : … { … }

ProcessMemoryDump::~ProcessMemoryDump() = default;

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

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

AggregatedMetrics::AggregatedMetrics(
    int32_t native_library_resident_kb_in,
    int32_t native_library_resident_not_ordered_kb_in,
    int32_t native_library_not_resident_ordered_kb_in)
    : … { … }

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

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

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

GlobalMemoryDump::GlobalMemoryDump(
    ::base::TimeTicks start_time_in,
    std::vector<ProcessMemoryDumpPtr> process_dumps_in,
    AggregatedMetricsPtr aggregated_metrics_in)
    : … { … }

GlobalMemoryDump::~GlobalMemoryDump() = default;

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

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

HeapProfileResult::HeapProfileResult(
    ::base::ProcessId pid_in,
    const ::std::string& json_in)
    : … { … }

HeapProfileResult::~HeapProfileResult() = default;

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

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

RawAllocatorDumpEntryValue::~RawAllocatorDumpEntryValue() { … }


void RawAllocatorDumpEntryValue::set_value_uint64(
    uint64_t value_uint64) { … }
void RawAllocatorDumpEntryValue::set_value_string(
    const std::string& value_string) { … }

void RawAllocatorDumpEntryValue::DestroyActive() { … }
size_t RawAllocatorDumpEntryValue::Hash(size_t seed) const { … }

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ClientProcess::RequestChromeMemoryDump_Sym::IPCStableHash() { … }
uint32_t ClientProcess::RequestOSMemoryDump_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

void ClientProcessProxy::RequestChromeMemoryDump(
    const ::base::trace_event::MemoryDumpRequestArgs& in_args, RequestChromeMemoryDumpCallback callback) { … }

void ClientProcessProxy::RequestOSMemoryDump(
    MemoryMapOption in_option, const std::vector<::base::ProcessId>& in_pids, RequestOSMemoryDumpCallback callback) { … }
class ClientProcess_RequestChromeMemoryDump_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void ClientProcess_RequestChromeMemoryDump_ProxyToResponder::Run(
    bool in_success, uint64_t in_dump_id, ::std::unique_ptr<::base::trace_event::ProcessMemoryDump> in_raw_process_memory_dump) { … }
class ClientProcess_RequestOSMemoryDump_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void ClientProcess_RequestOSMemoryDump_ProxyToResponder::Run(
    bool in_success, base::flat_map<::base::ProcessId, RawOSMemDumpPtr> in_dumps) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t HeapProfiler::DumpProcessesForTracing_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

void HeapProfilerProxy::DumpProcessesForTracing(
    bool in_strip_path_from_mapped_files, bool in_write_proto, DumpProcessesForTracingCallback callback) { … }
class HeapProfiler_DumpProcessesForTracing_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void HeapProfiler_DumpProcessesForTracing_ProxyToResponder::Run(
    std::vector<HeapProfileResultPtr> in_results) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t HeapProfilerHelper::GetVmRegionsForHeapProfiler_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

void HeapProfilerHelperProxy::GetVmRegionsForHeapProfiler(
    const std::vector<::base::ProcessId>& in_pids, GetVmRegionsForHeapProfilerCallback callback) { … }
class HeapProfilerHelper_GetVmRegionsForHeapProfiler_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void HeapProfilerHelper_GetVmRegionsForHeapProfiler_ProxyToResponder::Run(
    base::flat_map<::base::ProcessId, std::vector<VmRegionPtr>> in_vm_regions) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t Coordinator::RequestGlobalMemoryDump_Sym::IPCStableHash() { … }
uint32_t Coordinator::RequestGlobalMemoryDumpForPid_Sym::IPCStableHash() { … }
uint32_t Coordinator::RequestPrivateMemoryFootprint_Sym::IPCStableHash() { … }
uint32_t Coordinator::RequestGlobalMemoryDumpAndAppendToTrace_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

void CoordinatorProxy::RequestGlobalMemoryDump(
    ::base::trace_event::MemoryDumpType in_dump_type, ::base::trace_event::MemoryDumpLevelOfDetail in_level_of_detail, ::base::trace_event::MemoryDumpDeterminism in_determinism, const std::vector<std::string>& in_allocator_dump_names, RequestGlobalMemoryDumpCallback callback) { … }

void CoordinatorProxy::RequestGlobalMemoryDumpForPid(
    ::base::ProcessId in_pid, const std::vector<std::string>& in_allocator_dump_names, RequestGlobalMemoryDumpForPidCallback callback) { … }

void CoordinatorProxy::RequestPrivateMemoryFootprint(
    ::base::ProcessId in_pid, RequestPrivateMemoryFootprintCallback callback) { … }

void CoordinatorProxy::RequestGlobalMemoryDumpAndAppendToTrace(
    ::base::trace_event::MemoryDumpType in_dump_type, ::base::trace_event::MemoryDumpLevelOfDetail in_level_of_detail, ::base::trace_event::MemoryDumpDeterminism in_determinism, RequestGlobalMemoryDumpAndAppendToTraceCallback callback) { … }
class Coordinator_RequestGlobalMemoryDump_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Coordinator_RequestGlobalMemoryDump_ProxyToResponder::Run(
    bool in_success, GlobalMemoryDumpPtr in_global_memory_dump) { … }
class Coordinator_RequestGlobalMemoryDumpForPid_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Coordinator_RequestGlobalMemoryDumpForPid_ProxyToResponder::Run(
    bool in_success, GlobalMemoryDumpPtr in_global_memory_dump) { … }
class Coordinator_RequestPrivateMemoryFootprint_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Coordinator_RequestPrivateMemoryFootprint_ProxyToResponder::Run(
    bool in_success, GlobalMemoryDumpPtr in_global_memory_dump) { … }
class Coordinator_RequestGlobalMemoryDumpAndAppendToTrace_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Coordinator_RequestGlobalMemoryDumpAndAppendToTrace_ProxyToResponder::Run(
    bool in_success, uint64_t in_dump_id) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t CoordinatorConnector::RegisterCoordinatorClient_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void CoordinatorConnectorProxy::RegisterCoordinatorClient(
    ::mojo::PendingReceiver<Coordinator> in_receiver, ::mojo::PendingRemote<ClientProcess> in_client_process) { … }

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

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

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



}  // memory_instrumentation::mojom


namespace mojo {


// static
bool StructTraits<::memory_instrumentation::mojom::RequestArgs::DataView, ::memory_instrumentation::mojom::RequestArgsPtr>::Read(
    ::memory_instrumentation::mojom::RequestArgs::DataView input,
    ::memory_instrumentation::mojom::RequestArgsPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::RawAllocatorDumpEdge::DataView, ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr>::Read(
    ::memory_instrumentation::mojom::RawAllocatorDumpEdge::DataView input,
    ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::RawAllocatorDumpEntry::DataView, ::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr>::Read(
    ::memory_instrumentation::mojom::RawAllocatorDumpEntry::DataView input,
    ::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::RawAllocatorDump::DataView, ::memory_instrumentation::mojom::RawAllocatorDumpPtr>::Read(
    ::memory_instrumentation::mojom::RawAllocatorDump::DataView input,
    ::memory_instrumentation::mojom::RawAllocatorDumpPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::RawProcessMemoryDump::DataView, ::memory_instrumentation::mojom::RawProcessMemoryDumpPtr>::Read(
    ::memory_instrumentation::mojom::RawProcessMemoryDump::DataView input,
    ::memory_instrumentation::mojom::RawProcessMemoryDumpPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::VmRegion::DataView, ::memory_instrumentation::mojom::VmRegionPtr>::Read(
    ::memory_instrumentation::mojom::VmRegion::DataView input,
    ::memory_instrumentation::mojom::VmRegionPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::PlatformPrivateFootprint::DataView, ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr>::Read(
    ::memory_instrumentation::mojom::PlatformPrivateFootprint::DataView input,
    ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::RawOSMemDump::DataView, ::memory_instrumentation::mojom::RawOSMemDumpPtr>::Read(
    ::memory_instrumentation::mojom::RawOSMemDump::DataView input,
    ::memory_instrumentation::mojom::RawOSMemDumpPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::OSMemDump::DataView, ::memory_instrumentation::mojom::OSMemDumpPtr>::Read(
    ::memory_instrumentation::mojom::OSMemDump::DataView input,
    ::memory_instrumentation::mojom::OSMemDumpPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::AllocatorMemDump::DataView, ::memory_instrumentation::mojom::AllocatorMemDumpPtr>::Read(
    ::memory_instrumentation::mojom::AllocatorMemDump::DataView input,
    ::memory_instrumentation::mojom::AllocatorMemDumpPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::ProcessMemoryDump::DataView, ::memory_instrumentation::mojom::ProcessMemoryDumpPtr>::Read(
    ::memory_instrumentation::mojom::ProcessMemoryDump::DataView input,
    ::memory_instrumentation::mojom::ProcessMemoryDumpPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::AggregatedMetrics::DataView, ::memory_instrumentation::mojom::AggregatedMetricsPtr>::Read(
    ::memory_instrumentation::mojom::AggregatedMetrics::DataView input,
    ::memory_instrumentation::mojom::AggregatedMetricsPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::GlobalMemoryDump::DataView, ::memory_instrumentation::mojom::GlobalMemoryDumpPtr>::Read(
    ::memory_instrumentation::mojom::GlobalMemoryDump::DataView input,
    ::memory_instrumentation::mojom::GlobalMemoryDumpPtr* output) { … }


// static
bool StructTraits<::memory_instrumentation::mojom::HeapProfileResult::DataView, ::memory_instrumentation::mojom::HeapProfileResultPtr>::Read(
    ::memory_instrumentation::mojom::HeapProfileResult::DataView input,
    ::memory_instrumentation::mojom::HeapProfileResultPtr* output) { … }

// static
bool UnionTraits<::memory_instrumentation::mojom::RawAllocatorDumpEntryValue::DataView, ::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr>::Read(
    ::memory_instrumentation::mojom::RawAllocatorDumpEntryValue::DataView input,
    ::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr* 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 memory_instrumentation::mojom {


void ClientProcessInterceptorForTesting::RequestChromeMemoryDump(const ::base::trace_event::MemoryDumpRequestArgs& args, RequestChromeMemoryDumpCallback callback) { … }
void ClientProcessInterceptorForTesting::RequestOSMemoryDump(MemoryMapOption option, const std::vector<::base::ProcessId>& pids, RequestOSMemoryDumpCallback callback) { … }
ClientProcessAsyncWaiter::ClientProcessAsyncWaiter(
    ClientProcess* proxy) : … { … }

ClientProcessAsyncWaiter::~ClientProcessAsyncWaiter() = default;

void ClientProcessAsyncWaiter::RequestChromeMemoryDump(
    const ::base::trace_event::MemoryDumpRequestArgs& args, bool* out_success, uint64_t* out_dump_id, ::std::unique_ptr<::base::trace_event::ProcessMemoryDump>* out_raw_process_memory_dump) { … }



void ClientProcessAsyncWaiter::RequestOSMemoryDump(
    MemoryMapOption option, const std::vector<::base::ProcessId>& pids, bool* out_success, base::flat_map<::base::ProcessId, RawOSMemDumpPtr>* out_dumps) { … }






void HeapProfilerInterceptorForTesting::DumpProcessesForTracing(bool strip_path_from_mapped_files, bool write_proto, DumpProcessesForTracingCallback callback) { … }
HeapProfilerAsyncWaiter::HeapProfilerAsyncWaiter(
    HeapProfiler* proxy) : … { … }

HeapProfilerAsyncWaiter::~HeapProfilerAsyncWaiter() = default;

void HeapProfilerAsyncWaiter::DumpProcessesForTracing(
    bool strip_path_from_mapped_files, bool write_proto, std::vector<HeapProfileResultPtr>* out_results) { … }

std::vector<HeapProfileResultPtr> HeapProfilerAsyncWaiter::DumpProcessesForTracing(
    bool strip_path_from_mapped_files, bool write_proto) { … }




void HeapProfilerHelperInterceptorForTesting::GetVmRegionsForHeapProfiler(const std::vector<::base::ProcessId>& pids, GetVmRegionsForHeapProfilerCallback callback) { … }
HeapProfilerHelperAsyncWaiter::HeapProfilerHelperAsyncWaiter(
    HeapProfilerHelper* proxy) : … { … }

HeapProfilerHelperAsyncWaiter::~HeapProfilerHelperAsyncWaiter() = default;

void HeapProfilerHelperAsyncWaiter::GetVmRegionsForHeapProfiler(
    const std::vector<::base::ProcessId>& pids, base::flat_map<::base::ProcessId, std::vector<VmRegionPtr>>* out_vm_regions) { … }

base::flat_map<::base::ProcessId, std::vector<VmRegionPtr>> HeapProfilerHelperAsyncWaiter::GetVmRegionsForHeapProfiler(
    const std::vector<::base::ProcessId>& pids) { … }




void CoordinatorInterceptorForTesting::RequestGlobalMemoryDump(::base::trace_event::MemoryDumpType dump_type, ::base::trace_event::MemoryDumpLevelOfDetail level_of_detail, ::base::trace_event::MemoryDumpDeterminism determinism, const std::vector<std::string>& allocator_dump_names, RequestGlobalMemoryDumpCallback callback) { … }
void CoordinatorInterceptorForTesting::RequestGlobalMemoryDumpForPid(::base::ProcessId pid, const std::vector<std::string>& allocator_dump_names, RequestGlobalMemoryDumpForPidCallback callback) { … }
void CoordinatorInterceptorForTesting::RequestPrivateMemoryFootprint(::base::ProcessId pid, RequestPrivateMemoryFootprintCallback callback) { … }
void CoordinatorInterceptorForTesting::RequestGlobalMemoryDumpAndAppendToTrace(::base::trace_event::MemoryDumpType dump_type, ::base::trace_event::MemoryDumpLevelOfDetail level_of_detail, ::base::trace_event::MemoryDumpDeterminism determinism, RequestGlobalMemoryDumpAndAppendToTraceCallback callback) { … }
CoordinatorAsyncWaiter::CoordinatorAsyncWaiter(
    Coordinator* proxy) : … { … }

CoordinatorAsyncWaiter::~CoordinatorAsyncWaiter() = default;

void CoordinatorAsyncWaiter::RequestGlobalMemoryDump(
    ::base::trace_event::MemoryDumpType dump_type, ::base::trace_event::MemoryDumpLevelOfDetail level_of_detail, ::base::trace_event::MemoryDumpDeterminism determinism, const std::vector<std::string>& allocator_dump_names, bool* out_success, GlobalMemoryDumpPtr* out_global_memory_dump) { … }



void CoordinatorAsyncWaiter::RequestGlobalMemoryDumpForPid(
    ::base::ProcessId pid, const std::vector<std::string>& allocator_dump_names, bool* out_success, GlobalMemoryDumpPtr* out_global_memory_dump) { … }



void CoordinatorAsyncWaiter::RequestPrivateMemoryFootprint(
    ::base::ProcessId pid, bool* out_success, GlobalMemoryDumpPtr* out_global_memory_dump) { … }



void CoordinatorAsyncWaiter::RequestGlobalMemoryDumpAndAppendToTrace(
    ::base::trace_event::MemoryDumpType dump_type, ::base::trace_event::MemoryDumpLevelOfDetail level_of_detail, ::base::trace_event::MemoryDumpDeterminism determinism, bool* out_success, uint64_t* out_dump_id) { … }






void CoordinatorConnectorInterceptorForTesting::RegisterCoordinatorClient(::mojo::PendingReceiver<Coordinator> receiver, ::mojo::PendingRemote<ClientProcess> client_process) { … }
CoordinatorConnectorAsyncWaiter::CoordinatorConnectorAsyncWaiter(
    CoordinatorConnector* proxy) : … { … }

CoordinatorConnectorAsyncWaiter::~CoordinatorConnectorAsyncWaiter() = default;






}  // memory_instrumentation::mojom


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