third_party/blink/renderer/platform/scheduler/common/scheduler_helper.cc

// Copyright 2015 The Chromium Authors. All rights reserved.
// 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/scheduler_helper.h"

#include <utility>

#include "base/task/sequence_manager/sequence_manager_impl.h"
#include "base/task/sequence_manager/task_queue.h"
#include "base/time/default_tick_clock.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/traced_value.h"

namespace blink {
namespace scheduler {

using base::sequence_manager::TaskQueue;
using base::sequence_manager::SequenceManager;
using base::sequence_manager::TaskTimeObserver;
using base::sequence_manager::TimeDomain;

SchedulerHelper::SchedulerHelper(
    std::unique_ptr<SequenceManager> sequence_manager)
    : sequence_manager_(std::move(sequence_manager)), observer_(nullptr) {
  sequence_manager_->SetWorkBatchSize(4);
}

void SchedulerHelper::InitDefaultQueues(
    scoped_refptr<TaskQueue> default_task_queue,
    scoped_refptr<TaskQueue> control_task_queue,
    TaskType default_task_type) {
  control_task_queue->SetQueuePriority(TaskQueue::kControlPriority);

  default_task_runner_ =
      default_task_queue->CreateTaskRunner(static_cast<int>(default_task_type));

  DCHECK(sequence_manager_);
  sequence_manager_->SetDefaultTaskRunner(default_task_runner_);
}

SchedulerHelper::~SchedulerHelper() {
  Shutdown();
}

void SchedulerHelper::Shutdown() {
  CheckOnValidThread();
  if (!sequence_manager_)
    return;
  sequence_manager_->SetObserver(nullptr);
  sequence_manager_.reset();
}

scoped_refptr<base::SingleThreadTaskRunner>
SchedulerHelper::DefaultTaskRunner() {
  return default_task_runner_;
}

void SchedulerHelper::SetWorkBatchSizeForTesting(int work_batch_size) {
  CheckOnValidThread();
  DCHECK(sequence_manager_.get());
  sequence_manager_->SetWorkBatchSize(work_batch_size);
}

bool SchedulerHelper::GetAndClearSystemIsQuiescentBit() {
  CheckOnValidThread();
  DCHECK(sequence_manager_.get());
  return sequence_manager_->GetAndClearSystemIsQuiescentBit();
}

void SchedulerHelper::AddTaskObserver(
    base::MessageLoop::TaskObserver* task_observer) {
  CheckOnValidThread();
  if (sequence_manager_) {
    static_cast<base::sequence_manager::internal::SequenceManagerImpl*>(
        sequence_manager_.get())
        ->AddTaskObserver(task_observer);
  }
}

void SchedulerHelper::RemoveTaskObserver(
    base::MessageLoop::TaskObserver* task_observer) {
  CheckOnValidThread();
  if (sequence_manager_) {
    static_cast<base::sequence_manager::internal::SequenceManagerImpl*>(
        sequence_manager_.get())
        ->RemoveTaskObserver(task_observer);
  }
}

void SchedulerHelper::AddTaskTimeObserver(
    TaskTimeObserver* task_time_observer) {
  if (sequence_manager_)
    sequence_manager_->AddTaskTimeObserver(task_time_observer);
}

void SchedulerHelper::RemoveTaskTimeObserver(
    TaskTimeObserver* task_time_observer) {
  if (sequence_manager_)
    sequence_manager_->RemoveTaskTimeObserver(task_time_observer);
}

void SchedulerHelper::SetObserver(Observer* observer) {
  CheckOnValidThread();
  observer_ = observer;
  DCHECK(sequence_manager_);
  sequence_manager_->SetObserver(this);
}

void SchedulerHelper::SweepCanceledDelayedTasks() {
  CheckOnValidThread();
  DCHECK(sequence_manager_);
  sequence_manager_->SweepCanceledDelayedTasks();
}

TimeDomain* SchedulerHelper::real_time_domain() const {
  CheckOnValidThread();
  DCHECK(sequence_manager_);
  return sequence_manager_->GetRealTimeDomain();
}

void SchedulerHelper::RegisterTimeDomain(TimeDomain* time_domain) {
  CheckOnValidThread();
  DCHECK(sequence_manager_);
  sequence_manager_->RegisterTimeDomain(time_domain);
}

void SchedulerHelper::UnregisterTimeDomain(TimeDomain* time_domain) {
  CheckOnValidThread();
  if (sequence_manager_)
    sequence_manager_->UnregisterTimeDomain(time_domain);
}

void SchedulerHelper::OnBeginNestedRunLoop() {
  if (observer_)
    observer_->OnBeginNestedRunLoop();
}

void SchedulerHelper::OnExitNestedRunLoop() {
  if (observer_)
    observer_->OnExitNestedRunLoop();
}

const base::TickClock* SchedulerHelper::GetClock() const {
  if (sequence_manager_)
    return sequence_manager_->GetTickClock();
  return nullptr;
}

base::TimeTicks SchedulerHelper::NowTicks() const {
  if (sequence_manager_)
    return sequence_manager_->NowTicks();
  // We may need current time for tracing when shutting down worker thread.
  return base::TimeTicks::Now();
}

void SchedulerHelper::SetTimerSlack(base::TimerSlack timer_slack) {
  if (sequence_manager_) {
    static_cast<base::sequence_manager::internal::SequenceManagerImpl*>(
        sequence_manager_.get())
        ->SetTimerSlack(timer_slack);
  }
}

double SchedulerHelper::GetSamplingRateForRecordingCPUTime() const {
  if (sequence_manager_) {
    return sequence_manager_->GetMetricRecordingSettings()
        .task_sampling_rate_for_recording_cpu_time;
  }
  return 0;
}

bool SchedulerHelper::HasCPUTimingForEachTask() const {
  if (sequence_manager_) {
    return sequence_manager_->GetMetricRecordingSettings()
        .records_cpu_time_for_each_task;
  }
  return false;
}

}  // namespace scheduler
}  // namespace blink