coordinator_impl.cc | Explore in Territory

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

#include "services/resource_coordinator/memory_instrumentation/coordinator_impl.h"

#include <inttypes.h>
#include <stdio.h>

#include <utility>

#include "base/command_line.h"
#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/metrics/histogram_macros.h"
#include "base/not_fatal_until.h"
#include "base/task/sequenced_task_runner.h"
#include "base/trace_event/memory_dump_manager.h"
#include "base/trace_event/memory_dump_request_args.h"
#include "base/trace_event/trace_event.h"
#include "build/build_config.h"
#include "services/resource_coordinator/memory_instrumentation/queued_request_dispatcher.h"
#include "services/resource_coordinator/memory_instrumentation/switches.h"
#include "services/resource_coordinator/public/cpp/memory_instrumentation/client_process_impl.h"
#include "services/resource_coordinator/public/cpp/memory_instrumentation/tracing_observer_proto.h"
#include "services/resource_coordinator/public/mojom/memory_instrumentation/constants.mojom.h"
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom.h"

#if BUILDFLAG(IS_MAC)
#include "base/mac/mac_util.h"
#endif

MemoryDumpDeterminism;
MemoryDumpLevelOfDetail;
MemoryDumpType;

namespace memory_instrumentation {

namespace {

memory_instrumentation::CoordinatorImpl* g_coordinator_impl;

constexpr base::TimeDelta kHeapDumpTimeout = …;

// A wrapper classes that allows a string to be exported as JSON in a trace
// event.
class StringWrapper : public base::trace_event::ConvertableToTraceFormat { … };

}  // namespace

CoordinatorImpl::CoordinatorImpl()
    : … { … }

CoordinatorImpl::~CoordinatorImpl() { … }

// static
CoordinatorImpl* CoordinatorImpl::GetInstance() { … }

void CoordinatorImpl::RegisterHeapProfiler(
    mojo::PendingRemote<mojom::HeapProfiler> profiler,
    mojo::PendingReceiver<mojom::HeapProfilerHelper> helper_receiver) { … }

void CoordinatorImpl::RegisterClientProcess(
    mojo::PendingReceiver<mojom::Coordinator> receiver,
    mojo::PendingRemote<mojom::ClientProcess> client_process,
    mojom::ProcessType process_type,
    base::ProcessId process_id,
    const std::optional<std::string>& service_name) { … }

void CoordinatorImpl::RequestGlobalMemoryDump(
    MemoryDumpType dump_type,
    MemoryDumpLevelOfDetail level_of_detail,
    MemoryDumpDeterminism determinism,
    const std::vector<std::string>& allocator_dump_names,
    RequestGlobalMemoryDumpCallback callback) { … }

void CoordinatorImpl::RequestGlobalMemoryDumpForPid(
    base::ProcessId pid,
    const std::vector<std::string>& allocator_dump_names,
    RequestGlobalMemoryDumpForPidCallback callback) { … }

void CoordinatorImpl::RequestPrivateMemoryFootprint(
    base::ProcessId pid,
    RequestPrivateMemoryFootprintCallback callback) { … }

void CoordinatorImpl::RequestGlobalMemoryDumpAndAppendToTrace(
    MemoryDumpType dump_type,
    MemoryDumpLevelOfDetail level_of_detail,
    MemoryDumpDeterminism determinism,
    RequestGlobalMemoryDumpAndAppendToTraceCallback callback) { … }

void CoordinatorImpl::GetVmRegionsForHeapProfiler(
    const std::vector<base::ProcessId>& pids,
    GetVmRegionsForHeapProfilerCallback callback) { … }

void CoordinatorImpl::UnregisterClientProcess(base::ProcessId process_id) { … }

void CoordinatorImpl::RequestGlobalMemoryDumpInternal(
    const QueuedRequest::Args& args,
    RequestGlobalMemoryDumpInternalCallback callback) { … }

void CoordinatorImpl::OnQueuedRequestTimedOut(uint64_t dump_guid) { … }

void CoordinatorImpl::OnHeapDumpTimeOut(uint64_t dump_guid) { … }

void CoordinatorImpl::PerformNextQueuedGlobalMemoryDump() { … }

QueuedRequest* CoordinatorImpl::GetCurrentRequest() { … }

void CoordinatorImpl::OnChromeMemoryDumpResponse(
    base::ProcessId process_id,
    bool success,
    uint64_t dump_guid,
    std::unique_ptr<base::trace_event::ProcessMemoryDump> chrome_memory_dump) { … }

void CoordinatorImpl::OnOSMemoryDumpResponse(uint64_t dump_guid,
                                             base::ProcessId process_id,
                                             bool success,
                                             OSMemDumpMap os_dumps) { … }

void CoordinatorImpl::OnOSMemoryDumpForVMRegions(uint64_t dump_guid,
                                                 base::ProcessId process_id,
                                                 bool success,
                                                 OSMemDumpMap os_dumps) { … }

void CoordinatorImpl::FinalizeVmRegionDumpIfAllManagersReplied(
    uint64_t dump_guid) { … }

void CoordinatorImpl::OnDumpProcessesForTracing(
    uint64_t dump_guid,
    std::vector<mojom::HeapProfileResultPtr> heap_profile_results) { … }

void CoordinatorImpl::RemovePendingResponse(
    base::ProcessId process_id,
    QueuedRequest::PendingResponse::Type type) { … }

void CoordinatorImpl::FinalizeGlobalMemoryDumpIfAllManagersReplied() { … }

CoordinatorImpl::ClientInfo::ClientInfo(
    mojo::Remote<mojom::ClientProcess> client,
    mojom::ProcessType process_type,
    std::optional<std::string> service_name)
    : … { … }

CoordinatorImpl::ClientInfo::~ClientInfo() = default;

}  // namespace memory_instrumentation
chromium/services/resource_coordinator/memory_instrumentation/coordinator_impl.cc
