chromium/third_party/blink/renderer/platform/scheduler/common/throttling/task_queue_throttler.cc

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

#include "third_party/blink/renderer/platform/scheduler/common/throttling/task_queue_throttler.h"

#include <cstdint>
#include <optional>

#include "base/check_op.h"
#include "base/debug/stack_trace.h"
#include "base/functional/bind.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_pump.h"
#include "base/task/common/lazy_now.h"
#include "base/time/tick_clock.h"
#include "third_party/blink/renderer/platform/scheduler/common/throttling/budget_pool.h"
#include "third_party/blink/renderer/platform/wtf/hash_set.h"

namespace blink {
namespace scheduler {

LazyNow;
TaskQueue;

TaskQueueThrottler::TaskQueueThrottler(
    base::sequence_manager::TaskQueue* task_queue,
    const base::TickClock* tick_clock)
    : … { … }

TaskQueueThrottler::~TaskQueueThrottler() { … }

void TaskQueueThrottler::IncreaseThrottleRefCount() { … }

void TaskQueueThrottler::DecreaseThrottleRefCount() { … }

bool TaskQueueThrottler::IsThrottled() const { … }

std::optional<base::sequence_manager::WakeUp>
TaskQueueThrottler::GetNextAllowedWakeUpImpl(
    LazyNow* lazy_now,
    std::optional<base::sequence_manager::WakeUp> next_wake_up,
    bool has_ready_task) { … }

void TaskQueueThrottler::OnHasImmediateTask() { … }

std::optional<base::sequence_manager::WakeUp>
TaskQueueThrottler::GetNextAllowedWakeUp(
    LazyNow* lazy_now,
    std::optional<base::sequence_manager::WakeUp> next_desired_wake_up,
    bool has_ready_task) { … }

void TaskQueueThrottler::OnTaskRunTimeReported(base::TimeTicks start_time,
                                               base::TimeTicks end_time) { … }

void TaskQueueThrottler::UpdateQueueState(base::TimeTicks now) { … }

void TaskQueueThrottler::OnWakeUp(base::LazyNow* lazy_now) { … }

void TaskQueueThrottler::UpdateFence(base::TimeTicks now) { … }

void TaskQueueThrottler::DisableThrottling() { … }

std::optional<QueueBlockType> TaskQueueThrottler::GetBlockType(
    base::TimeTicks now) const { … }

void TaskQueueThrottler::AddBudgetPool(BudgetPool* budget_pool) { … }

void TaskQueueThrottler::RemoveBudgetPool(BudgetPool* budget_pool) { … }

bool TaskQueueThrottler::CanRunTasksAt(base::TimeTicks moment) { … }

base::TimeTicks TaskQueueThrottler::GetNextAllowedRunTime(
    base::TimeTicks desired_runtime) const { … }

base::TimeTicks TaskQueueThrottler::GetTimeTasksCanRunUntil(
    base::TimeTicks now) const { … }

void TaskQueueThrottler::WriteIntoTrace(perfetto::TracedValue context) const { … }

}  // namespace scheduler
}  // namespace blink