// Copyright 2018 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/public/platform/scheduler/web_thread_scheduler.h"

#include <utility>

#include "base/feature_list.h"
#include "base/message_loop/message_pump_type.h"
#include "base/task/single_thread_task_runner.h"
#include "base/trace_event/trace_event.h"
#include "build/build_config.h"
#include "third_party/blink/public/common/input/web_input_event_attribution.h"
#include "third_party/blink/renderer/platform/scheduler/common/features.h"
#include "third_party/blink/renderer/platform/scheduler/common/task_priority.h"
#include "third_party/blink/renderer/platform/scheduler/common/tracing_helper.h"
#include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h"
#include "third_party/blink/renderer/platform/scheduler/public/main_thread.h"

namespace blink {
namespace scheduler {
namespace {

base::sequence_manager::SequenceManager::Settings::Builder
CreateSequenceManagerSettings() {
  return std::move(base::sequence_manager::SequenceManager::Settings::Builder()
                       .SetMessagePumpType(base::MessagePumpType::DEFAULT)
                       .SetShouldSampleCPUTime(true)
                       .SetAddQueueTimeToTasks(true)
                       .SetPrioritySettings(CreatePrioritySettings()));
}

}  // namespace

WebThreadScheduler::~WebThreadScheduler() = default;

// static
std::unique_ptr<WebThreadScheduler>
WebThreadScheduler::CreateMainThreadScheduler(
    std::unique_ptr<base::MessagePump> message_pump) {
  DCHECK(message_pump);
  auto settings = CreateSequenceManagerSettings()
                      .SetIsMainThread(true)
                      .Build();
  auto sequence_manager =
      base::sequence_manager::CreateSequenceManagerOnCurrentThreadWithPump(
          std::move(message_pump), std::move(settings));
  return std::make_unique<MainThreadSchedulerImpl>(std::move(sequence_manager));
}

// static
std::unique_ptr<WebThreadScheduler>
WebThreadScheduler::CreateInProcessMainThreadScheduler(
    std::unique_ptr<base::MessagePump> message_pump) {
  DCHECK(message_pump);
  auto settings = CreateSequenceManagerSettings().Build();
  auto sequence_manager =
      base::sequence_manager::CreateSequenceManagerOnCurrentThreadWithPump(
          std::move(message_pump), std::move(settings));
  return std::make_unique<MainThreadSchedulerImpl>(std::move(sequence_manager));
}

// static
std::unique_ptr<WebThreadScheduler>
WebThreadScheduler::CreateMainThreadSchedulerForTesting(
    base::sequence_manager::SequenceManager* sequence_manager) {
  return std::make_unique<MainThreadSchedulerImpl>(sequence_manager);
}

// static
base::sequence_manager::SequenceManager::PrioritySettings
WebThreadScheduler::CreatePrioritySettingsForTesting() {
  return CreatePrioritySettings();
}

// Stubs for main thread only virtual functions.
scoped_refptr<base::SingleThreadTaskRunner>
WebThreadScheduler::DeprecatedDefaultTaskRunner() {
  NOTREACHED();
}

std::unique_ptr<MainThread> WebThreadScheduler::CreateMainThread() {
  NOTREACHED();
}

void WebThreadScheduler::SetRendererBackgrounded(bool backgrounded) {
  NOTREACHED();
}

#if BUILDFLAG(IS_ANDROID)
void WebThreadScheduler::PauseTimersForAndroidWebView() {
  NOTREACHED();
}

void WebThreadScheduler::ResumeTimersForAndroidWebView() {
  NOTREACHED();
}
#endif  // BUILDFLAG(IS_ANDROID)

void WebThreadScheduler::OnUrgentMessageReceived() {
  NOTREACHED();
}

void WebThreadScheduler::OnUrgentMessageProcessed() {
  NOTREACHED();
}

}  // namespace scheduler
}  // namespace blink