chromium/third_party/perfetto/src/trace_processor/importers/memory_tracker/graph.cc

/*
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "perfetto/ext/trace_processor/importers/memory_tracker/graph.h"

namespace perfetto {
namespace trace_processor {

namespace {

Edge;
PostOrderIterator;
PreOrderIterator;
Process;
Node;
SplitString;

}  // namespace

GlobalNodeGraph::GlobalNodeGraph()
    :{}
GlobalNodeGraph::~GlobalNodeGraph() {}

Process* GlobalNodeGraph::CreateGraphForProcess(
    base::PlatformProcessId process_id) {}

void GlobalNodeGraph::AddNodeOwnershipEdge(Node* owner,
                                           Node* owned,
                                           int importance) {}

Node* GlobalNodeGraph::CreateNode(Process* process_graph, Node* parent) {}

PreOrderIterator GlobalNodeGraph::VisitInDepthFirstPreOrder() {}

PostOrderIterator GlobalNodeGraph::VisitInDepthFirstPostOrder() {}

Process::Process(base::PlatformProcessId pid, GlobalNodeGraph* global_graph)
    :{}
Process::~Process() {}

Node* Process::CreateNode(MemoryAllocatorNodeId id,
                          const std::string& path,
                          bool weak) {}

Node* Process::FindNode(const std::string& path) {}

Node::Node(Process* node_graph, Node* parent)
    :{}
Node::~Node() {}

Node* Node::GetChild(const std::string& name) const {}

void Node::InsertChild(const std::string& name, Node* node) {}

Node* Node::CreateChild(const std::string& name) {}

bool Node::IsDescendentOf(const Node& possible_parent) const {}

void Node::AddOwnedByEdge(Edge* edge) {}

void Node::SetOwnsEdge(Edge* owns_edge) {}

void Node::AddEntry(const std::string& name,
                    Node::Entry::ScalarUnits units,
                    uint64_t value) {}

void Node::AddEntry(const std::string& name, const std::string& value) {}

Node::Entry::Entry(Entry::ScalarUnits units2, uint64_t value)
    :{}

Node::Entry::Entry(const std::string& value)
    :{}

Edge::Edge(Node* source, Node* target, int priority)
    :{}

PreOrderIterator::PreOrderIterator(std::vector<Node*>&& roots)
    :{}
PreOrderIterator::PreOrderIterator(PreOrderIterator&& other) = default;
PreOrderIterator::~PreOrderIterator() {}

// Yields the next node in the DFS post-order traversal.
Node* PreOrderIterator::next() {}

PostOrderIterator::PostOrderIterator(std::vector<Node*>&& roots)
    :{}
PostOrderIterator::PostOrderIterator(PostOrderIterator&& other) = default;
PostOrderIterator::~PostOrderIterator() = default;

// Yields the next node in the DFS post-order traversal.
Node* PostOrderIterator::next() {}

}  // namespace trace_processor
}  // namespace perfetto