v8_context_tracker_internal.cc | Explore in Territory

// Copyright 2020 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/v8_memory/v8_context_tracker_internal.h"

#include <utility>

#include "base/check.h"
#include "base/not_fatal_until.h"
#include "components/performance_manager/v8_memory/v8_context_tracker_helpers.h"

namespace performance_manager {
namespace v8_memory {
namespace internal {

////////////////////////////////////////////////////////////////////////////////
// ExecutionContextData implementation:

ExecutionContextData::ExecutionContextData(
    ProcessData* process_data,
    const blink::ExecutionContextToken& token,
    mojom::IframeAttributionDataPtr iframe_attribution_data)
    : … { … }

ExecutionContextData::~ExecutionContextData() { … }

bool ExecutionContextData::IsTracked() const { … }

bool ExecutionContextData::ShouldDestroy() const { … }

void ExecutionContextData::SetRemoteFrameData(
    base::PassKey<RemoteFrameData>,
    RemoteFrameData* remote_frame_data) { … }

bool ExecutionContextData::ClearRemoteFrameData(
    base::PassKey<RemoteFrameData>) { … }

void ExecutionContextData::IncrementV8ContextCount(
    base::PassKey<V8ContextData>) { … }

bool ExecutionContextData::DecrementV8ContextCount(
    base::PassKey<V8ContextData>) { … }

bool ExecutionContextData::MarkDestroyed(base::PassKey<ProcessData>) { … }

bool ExecutionContextData::MarkMainV8ContextCreated(
    base::PassKey<V8ContextTrackerDataStore>) { … }

void ExecutionContextData::MarkMainV8ContextDetached(
    base::PassKey<V8ContextData>) { … }

////////////////////////////////////////////////////////////////////////////////
// RemoteFrameData implementation:

RemoteFrameData::RemoteFrameData(ProcessData* process_data,
                                 const blink::RemoteFrameToken& token,
                                 ExecutionContextData* execution_context_data)
    : … { … }

RemoteFrameData::~RemoteFrameData() { … }

bool RemoteFrameData::IsTracked() const { … }

////////////////////////////////////////////////////////////////////////////////
// V8ContextData implementation:

V8ContextData::V8ContextData(ProcessData* process_data,
                             const mojom::V8ContextDescription& description,
                             ExecutionContextData* execution_context_data)
    : … { … }

V8ContextData::~V8ContextData() { … }

bool V8ContextData::IsTracked() const { … }

ExecutionContextData* V8ContextData::GetExecutionContextData() const { … }

void V8ContextData::SetWasTracked(base::PassKey<V8ContextTrackerDataStore>) { … }

bool V8ContextData::MarkDetached(base::PassKey<ProcessData>) { … }

bool V8ContextData::IsMainV8Context() const { … }

bool V8ContextData::MarkDetachedImpl() { … }

////////////////////////////////////////////////////////////////////////////////
// ProcessData implementation:

ProcessData::ProcessData(const ProcessNodeImpl* process_node)
    : … { … }

ProcessData::~ProcessData() { … }

void ProcessData::TearDown() { … }

void ProcessData::Add(base::PassKey<V8ContextTrackerDataStore>,
                      ExecutionContextData* ec_data) { … }

void ProcessData::Add(base::PassKey<V8ContextTrackerDataStore>,
                      RemoteFrameData* rf_data) { … }

void ProcessData::Add(base::PassKey<V8ContextTrackerDataStore>,
                      V8ContextData* v8_data) { … }

void ProcessData::Remove(base::PassKey<V8ContextTrackerDataStore>,
                         ExecutionContextData* ec_data) { … }

void ProcessData::Remove(base::PassKey<V8ContextTrackerDataStore>,
                         RemoteFrameData* rf_data) { … }

void ProcessData::Remove(base::PassKey<V8ContextTrackerDataStore>,
                         V8ContextData* v8_data) { … }

bool ProcessData::MarkDestroyed(base::PassKey<V8ContextTrackerDataStore>,
                                ExecutionContextData* ec_data) { … }

bool ProcessData::MarkDetached(base::PassKey<V8ContextTrackerDataStore>,
                               V8ContextData* v8_data) { … }

////////////////////////////////////////////////////////////////////////////////
// V8ContextTrackerDataStore implementation:

V8ContextTrackerDataStore::V8ContextTrackerDataStore() = default;

V8ContextTrackerDataStore::~V8ContextTrackerDataStore() { … }

void V8ContextTrackerDataStore::Pass(
    std::unique_ptr<ExecutionContextData> ec_data) { … }

void V8ContextTrackerDataStore::Pass(std::unique_ptr<RemoteFrameData> rf_data) { … }

bool V8ContextTrackerDataStore::Pass(std::unique_ptr<V8ContextData> v8_data) { … }

ExecutionContextData* V8ContextTrackerDataStore::Get(
    const blink::ExecutionContextToken& token) { … }

RemoteFrameData* V8ContextTrackerDataStore::Get(
    const blink::RemoteFrameToken& token) { … }

V8ContextData* V8ContextTrackerDataStore::Get(
    const blink::V8ContextToken& token) { … }

void V8ContextTrackerDataStore::MarkDestroyed(ExecutionContextData* ec_data) { … }

bool V8ContextTrackerDataStore::MarkDetached(V8ContextData* v8_data) { … }

void V8ContextTrackerDataStore::Destroy(
    const blink::ExecutionContextToken& token) { … }

void V8ContextTrackerDataStore::Destroy(const blink::RemoteFrameToken& token) { … }

void V8ContextTrackerDataStore::Destroy(const blink::V8ContextToken& token) { … }

}  // namespace internal
}  // namespace v8_memory
}  // namespace performance_manager
chromium/components/performance_manager/v8_memory/v8_context_tracker_internal.cc
