v8_foreground_task_runner_with_locker.cc 2.7 KB

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