chromium/components/performance_manager/resource_attribution/queries.cc

// Copyright 2023 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/public/resource_attribution/queries.h"

#include <utility>

#include "base/check.h"
#include "base/containers/enum_set.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/task/bind_post_task.h"
#include "base/timer/timer.h"
#include "components/performance_manager/resource_attribution/query_params.h"
#include "components/performance_manager/resource_attribution/query_scheduler.h"

namespace resource_attribution {

namespace {

QueryParams;
QueryScheduler;

// The minimum delay between QueryOnce() calls for kMemorySummary resources.
// This can only be updated in unit tests so doesn't need to be thread-safe.
// Copied from ProcessMetricsDecorator::kMinImmediateRefreshDelay.
// TODO(crbug.com/40926264): Manage timing centrally in QueryScheduler.
base::TimeDelta g_min_memory_query_delay = …;

void AddScopedQueryToScheduler(QueryParams* query_params,
                               QueryScheduler* scheduler) { … }

void RemoveScopedQueryFromScheduler(std::unique_ptr<QueryParams> query_params,
                                    QueryScheduler* scheduler) { … }

void StartRepeatingQueryInScheduler(QueryParams* query_params,
                                    QueryScheduler* scheduler) { … }

void RequestResultsFromScheduler(
    QueryParams* query_params,
    base::OnceCallback<void(const QueryResultMap&)> callback,
    QueryScheduler* scheduler) { … }

}  // namespace

class ScopedResourceUsageQuery::ThrottledTimer { … };

void ScopedResourceUsageQuery::ThrottledTimer::StartTimer(
    base::TimeDelta delay,
    internal::QueryParams* params,
    scoped_refptr<ObserverList> observer_list) { … }

void ScopedResourceUsageQuery::ThrottledTimer::SendRequestToScheduler(
    internal::QueryParams* params,
    scoped_refptr<ObserverList> observer_list,
    bool timer_fired) { … }

bool ScopedResourceUsageQuery::ThrottledTimer::ShouldSendRequest(
    internal::QueryParams* params,
    bool timer_fired) { … }

ScopedResourceUsageQuery::ScopedDisableMemoryQueryDelayForTesting::
    ScopedDisableMemoryQueryDelayForTesting()
    : … { … }

ScopedResourceUsageQuery::ScopedDisableMemoryQueryDelayForTesting::
    ~ScopedDisableMemoryQueryDelayForTesting() { … }

ScopedResourceUsageQuery::~ScopedResourceUsageQuery() { … }

ScopedResourceUsageQuery::ScopedResourceUsageQuery(ScopedResourceUsageQuery&&) =
    default;

ScopedResourceUsageQuery& ScopedResourceUsageQuery::operator=(
    ScopedResourceUsageQuery&&) = default;

void ScopedResourceUsageQuery::AddObserver(QueryResultObserver* observer) { … }

void ScopedResourceUsageQuery::RemoveObserver(QueryResultObserver* observer) { … }

void ScopedResourceUsageQuery::Start(base::TimeDelta delay) { … }

void ScopedResourceUsageQuery::QueryOnce() { … }

QueryParams* ScopedResourceUsageQuery::GetParamsForTesting() const { … }

// static
base::TimeDelta ScopedResourceUsageQuery::GetMinMemoryQueryDelayForTesting() { … }

ScopedResourceUsageQuery::ScopedResourceUsageQuery(
    base::PassKey<QueryBuilder>,
    std::unique_ptr<QueryParams> params)
    : … { … }

// static
void ScopedResourceUsageQuery::NotifyObservers(
    scoped_refptr<ObserverList> observer_list,
    const QueryResultMap& results) { … }

QueryBuilder::QueryBuilder() : … { … }

QueryBuilder::~QueryBuilder() = default;

QueryBuilder::QueryBuilder(QueryBuilder&&) = default;

QueryBuilder& QueryBuilder::operator=(QueryBuilder&&) = default;

QueryBuilder& QueryBuilder::AddResourceContext(const ResourceContext& context) { … }

QueryBuilder& QueryBuilder::AddResourceType(ResourceType resource_type) { … }

ScopedResourceUsageQuery QueryBuilder::CreateScopedQuery() { … }

void QueryBuilder::QueryOnce(
    base::OnceCallback<void(const QueryResultMap&)> callback,
    scoped_refptr<base::TaskRunner> task_runner) { … }

QueryBuilder QueryBuilder::Clone() const { … }

QueryParams* QueryBuilder::GetParamsForTesting() const { … }

QueryBuilder::QueryBuilder(std::unique_ptr<QueryParams> params)
    : … { … }

QueryBuilder& QueryBuilder::AddAllContextsWithTypeId(
    internal::ResourceContextTypeId type_id) { … }

void QueryBuilder::ValidateQuery() const { … }

}  // namespace resource_attribution