graph_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 "components/performance_manager/graph/graph_impl.h"

#include <string_view>
#include <utility>

#include "base/check_op.h"
#include "base/containers/contains.h"
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/containers/map_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/notreached.h"
#include "base/numerics/safe_conversions.h"
#include "components/performance_manager/graph/frame_node_impl.h"
#include "components/performance_manager/graph/node_base.h"
#include "components/performance_manager/graph/page_node_impl.h"
#include "components/performance_manager/graph/process_node_impl.h"
#include "components/performance_manager/graph/system_node_impl.h"
#include "components/performance_manager/graph/worker_node_impl.h"
#include "components/performance_manager/public/graph/node_data_describer.h"
#include "components/performance_manager/public/graph/node_data_describer_registry.h"

namespace ukm {
class UkmEntryBuilder;
}  // namespace ukm

namespace performance_manager {

namespace {

// A unique type ID for this implementation.
const uintptr_t kGraphImplType = …;

base::Value::Dict DescribeNodeWithDescriber(const NodeDataDescriber& describer,
                                            const Node* node) { … }

class NodeDataDescriberRegistryImpl : public NodeDataDescriberRegistry { … };

NodeDataDescriberRegistryImpl::~NodeDataDescriberRegistryImpl() { … }

void NodeDataDescriberRegistryImpl::RegisterDescriber(
    const NodeDataDescriber* describer,
    std::string_view name) { … }

void NodeDataDescriberRegistryImpl::UnregisterDescriber(
    const NodeDataDescriber* describer) { … }

base::Value::Dict NodeDataDescriberRegistryImpl::DescribeNodeData(
    const Node* node) const { … }

}  // namespace

GraphImpl::GraphImpl() { … }

GraphImpl::~GraphImpl() { … }

void GraphImpl::SetUp() { … }

void GraphImpl::TearDown() { … }

void GraphImpl::AddFrameNodeObserver(FrameNodeObserver* observer) { … }

void GraphImpl::AddPageNodeObserver(PageNodeObserver* observer) { … }

void GraphImpl::AddProcessNodeObserver(ProcessNodeObserver* observer) { … }

void GraphImpl::AddSystemNodeObserver(SystemNodeObserver* observer) { … }

void GraphImpl::AddWorkerNodeObserver(WorkerNodeObserver* observer) { … }

void GraphImpl::RemoveFrameNodeObserver(FrameNodeObserver* observer) { … }

void GraphImpl::RemovePageNodeObserver(PageNodeObserver* observer) { … }

void GraphImpl::RemoveProcessNodeObserver(ProcessNodeObserver* observer) { … }

void GraphImpl::RemoveSystemNodeObserver(SystemNodeObserver* observer) { … }

void GraphImpl::RemoveWorkerNodeObserver(WorkerNodeObserver* observer) { … }

void GraphImpl::PassToGraphImpl(std::unique_ptr<GraphOwned> graph_owned) { … }

std::unique_ptr<GraphOwned> GraphImpl::TakeFromGraph(GraphOwned* graph_owned) { … }

void GraphImpl::RegisterObject(GraphRegistered* object) { … }

void GraphImpl::UnregisterObject(GraphRegistered* object) { … }

const SystemNode* GraphImpl::GetSystemNode() const { … }

Graph::NodeSetView<const ProcessNode*> GraphImpl::GetAllProcessNodes() const { … }

Graph::NodeSetView<const FrameNode*> GraphImpl::GetAllFrameNodes() const { … }

Graph::NodeSetView<const PageNode*> GraphImpl::GetAllPageNodes() const { … }

Graph::NodeSetView<const WorkerNode*> GraphImpl::GetAllWorkerNodes() const { … }

bool GraphImpl::HasOnlySystemNode() const { … }

ukm::UkmRecorder* GraphImpl::GetUkmRecorder() const { … }

NodeDataDescriberRegistry* GraphImpl::GetNodeDataDescriberRegistry() const { … }

uintptr_t GraphImpl::GetImplType() const { … }

const void* GraphImpl::GetImpl() const { … }

#if DCHECK_IS_ON()
bool GraphImpl::IsOnGraphSequence() const { … }
#endif

void GraphImpl::AddInitializingFrameNodeObserver(
    InitializingFrameNodeObserver* frame_node_observer) { … }

void GraphImpl::RemoveInitializingFrameNodeObserver(
    InitializingFrameNodeObserver* frame_node_observer) { … }

GraphRegistered* GraphImpl::GetRegisteredObject(uintptr_t type_id) { … }

// static
GraphImpl* GraphImpl::FromGraph(const Graph* graph) { … }

bool GraphImpl::NodeInGraph(const NodeBase* node) const { … }

ProcessNodeImpl* GraphImpl::GetProcessNodeByPid(base::ProcessId pid) { … }

FrameNodeImpl* GraphImpl::GetFrameNodeById(
    RenderProcessHostId render_process_id,
    int render_frame_id) { … }

Graph::NodeSetView<ProcessNodeImpl*> GraphImpl::GetAllProcessNodeImpls() const { … }

Graph::NodeSetView<FrameNodeImpl*> GraphImpl::GetAllFrameNodeImpls() const { … }

Graph::NodeSetView<PageNodeImpl*> GraphImpl::GetAllPageNodeImpls() const { … }

Graph::NodeSetView<WorkerNodeImpl*> GraphImpl::GetAllWorkerNodeImpls() const { … }

void GraphImpl::AddNewNode(NodeBase* new_node) { … }

void GraphImpl::RemoveNode(NodeBase* node) { … }

void GraphImpl::NotifyFrameNodeInitializing(const FrameNode* frame_node) { … }

void GraphImpl::NotifyFrameNodeTearingDown(const FrameNode* frame_node) { … }

size_t GraphImpl::NodeDataDescriberCountForTesting() const { … }

Graph::NodeSet& GraphImpl::GetNodesOfType(NodeTypeEnum node_type) { … }

const Graph::NodeSet& GraphImpl::GetNodesOfType(NodeTypeEnum node_type) const { … }

NodeState GraphImpl::GetNodeState(const NodeBase* node) const { … }

template <>
const GraphImpl::ObserverList<FrameNodeObserver>& GraphImpl::GetObservers()
    const { … }

template <>
const GraphImpl::ObserverList<PageNodeObserver>& GraphImpl::GetObservers()
    const { … }

template <>
const GraphImpl::ObserverList<ProcessNodeObserver>& GraphImpl::GetObservers()
    const { … }

template <>
const GraphImpl::ObserverList<SystemNodeObserver>& GraphImpl::GetObservers()
    const { … }

template <>
const GraphImpl::ObserverList<WorkerNodeObserver>& GraphImpl::GetObservers()
    const { … }

GraphImpl::ProcessAndFrameId::ProcessAndFrameId(
    RenderProcessHostId render_process_id,
    int render_frame_id)
    : … { … }

bool GraphImpl::ProcessAndFrameId::operator<(
    const ProcessAndFrameId& other) const { … }

GraphImpl::ProcessAndFrameId::~ProcessAndFrameId() = default;

GraphImpl::ProcessAndFrameId::ProcessAndFrameId(
    const GraphImpl::ProcessAndFrameId& other) = default;

GraphImpl::ProcessAndFrameId& GraphImpl::ProcessAndFrameId::operator=(
    const GraphImpl::ProcessAndFrameId& other) = default;

void GraphImpl::DispatchNodeAddedNotifications(NodeBase* node) { … }

void GraphImpl::DispatchNodeRemovedNotifications(NodeBase* node) { … }

int64_t GraphImpl::GetNextNodeSerializationId() { … }

void GraphImpl::BeforeProcessPidChange(ProcessNodeImpl* process,
                                       base::ProcessId new_pid) { … }

void GraphImpl::RegisterFrameNodeForId(RenderProcessHostId render_process_id,
                                       int render_frame_id,
                                       FrameNodeImpl* frame_node) { … }

void GraphImpl::UnregisterFrameNodeForId(RenderProcessHostId render_process_id,
                                         int render_frame_id,
                                         FrameNodeImpl* frame_node) { … }

void GraphImpl::CreateSystemNode() { … }

void GraphImpl::ReleaseSystemNode() { … }

}  // namespace performance_manager
chromium/components/performance_manager/graph/graph_impl.cc
