gin/v8_foreground_task_runner_with_locker.cc

   1 // Copyright 2017 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gin/v8_foreground_task_runner_with_locker.h"
   6
   7 #include "base/functional/bind.h"
   8 #include "base/functional/callback_helpers.h"
   9 #include "base/memory/raw_ptr.h"
  10 #include "base/task/single_thread_task_runner.h"
  11 #include "base/time/time.h"
  12 #include "v8/include/v8-isolate.h"
  13 #include "v8/include/v8-locker.h"
  14
  15 namespace gin {
  16
  17 V8ForegroundTaskRunnerWithLocker::V8ForegroundTaskRunnerWithLocker(
  18     v8::Isolate* isolate,
  19     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
  20     : isolate_(isolate), task_runner_(std::move(task_runner)) {
  21   DCHECK(task_runner_);
  22 }
  23
  24 V8ForegroundTaskRunnerWithLocker::~V8ForegroundTaskRunnerWithLocker() = default;
  25
  26 namespace {
  27
  28 void RunWithLocker(v8::Isolate* isolate, std::unique_ptr<v8::Task> task) {
  29   v8::Locker lock(isolate);
  30   v8::Isolate::Scope isolate_scope(isolate);
  31   task->Run();
  32 }
  33
  34 class IdleTaskWithLocker : public v8::IdleTask {
  35  public:
  36   IdleTaskWithLocker(v8::Isolate* isolate, std::unique_ptr<v8::IdleTask> task)
  37       : isolate_(isolate), task_(std::move(task)) {}
  38   IdleTaskWithLocker(const IdleTaskWithLocker&) = delete;
  39   IdleTaskWithLocker& operator=(const IdleTaskWithLocker&) = delete;
  40   ~IdleTaskWithLocker() override = default;
  41
  42   // v8::IdleTask implementation.
  43   void Run(double deadline_in_seconds) override {
  44     v8::Locker lock(isolate_);
  45     v8::Isolate::Scope isolate_scope(isolate_);
  46     task_->Run(deadline_in_seconds);
  47   }
  48
  49  private:
  50   raw_ptr<v8::Isolate> isolate_;
  51   std::unique_ptr<v8::IdleTask> task_;
  52 };
  53
  54 }  // namespace
  55
  56 void V8ForegroundTaskRunnerWithLocker::PostTask(
  57     std::unique_ptr<v8::Task> task) {
  58   task_runner_->PostTask(
  59       FROM_HERE, base::BindOnce(RunWithLocker, base::Unretained(isolate_),
  60                                 std::move(task)));
  61 }
  62
  63 void V8ForegroundTaskRunnerWithLocker::PostNonNestableTask(
  64     std::unique_ptr<v8::Task> task) {
  65   task_runner_->PostNonNestableTask(
  66       FROM_HERE, base::BindOnce(RunWithLocker, base::Unretained(isolate_),
  67                                 std::move(task)));
  68 }
  69
  70 void V8ForegroundTaskRunnerWithLocker::PostDelayedTask(
  71     std::unique_ptr<v8::Task> task,
  72     double delay_in_seconds) {
  73   task_runner_->PostDelayedTask(
  74       FROM_HERE,
  75       base::BindOnce(RunWithLocker, base::Unretained(isolate_),
  76                      std::move(task)),
  77       base::Seconds(delay_in_seconds));
  78 }
  79
  80 void V8ForegroundTaskRunnerWithLocker::PostIdleTask(
  81     std::unique_ptr<v8::IdleTask> task) {
  82   DCHECK(IdleTasksEnabled());
  83   idle_task_runner()->PostIdleTask(
  84       std::make_unique<IdleTaskWithLocker>(isolate_, std::move(task)));
  85 }
  86
  87 bool V8ForegroundTaskRunnerWithLocker::NonNestableTasksEnabled() const {
  88   return true;
  89 }
  90
  91 }  // namespace gin