1
// Copyright (c) 2023 Cloudflare, Inc.
2
// Licensed under the Apache 2.0 license found in the LICENSE file or at:
3
//     https://opensource.org/licenses/Apache-2.0
4
 
5
#pragma once
6
 
7
#include <v8-platform.h>
8
 
9
#include <kj/common.h>
10
 
11
namespace workerd::jsg {
12
 
13
class V8PlatformWrapper: public v8::Platform {
14
 public:
15
  explicit V8PlatformWrapper(v8::Platform& inner): inner(inner) {}
16
 
17
  v8::PageAllocator* GetPageAllocator() override {
18
    return inner.GetPageAllocator();
19
  }
20
 
21
  int NumberOfWorkerThreads() override {
22
    return inner.NumberOfWorkerThreads();
23
  }
24
 
25
  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
26
      v8::Isolate* isolate, v8::TaskPriority priority) override {
27
    return inner.GetForegroundTaskRunner(isolate, priority);
28
  }
29
 
30
  void PostTaskOnWorkerThreadImpl(v8::TaskPriority priority,
31
      std::unique_ptr<v8::Task> task,
32
      const v8::SourceLocation& location) override {
33
    inner.PostTaskOnWorkerThreadImpl(priority, kj::mv(task), location);
34
  }
35
 
36
  void PostDelayedTaskOnWorkerThreadImpl(v8::TaskPriority priority,
37
      std::unique_ptr<v8::Task> task,
38
      double delay_in_seconds,
39
      const v8::SourceLocation& location) override {
40
    inner.PostDelayedTaskOnWorkerThreadImpl(priority, kj::mv(task), delay_in_seconds, location);
41
  }
42
 
43
  std::unique_ptr<v8::JobHandle> CreateJobImpl(v8::TaskPriority priority,
44
      std::unique_ptr<v8::JobTask> job_task,
45
      const v8::SourceLocation& location) override {
46
    return inner.CreateJobImpl(
47
        priority, std::make_unique<JobTaskWrapper>(kj::mv(job_task)), location);
48
  }
49
 
50
  bool IdleTasksEnabled(v8::Isolate* isolate) override {
51
    return inner.IdleTasksEnabled(isolate);
52
  }
53
 
54
  double MonotonicallyIncreasingTime() override {
55
    return inner.MonotonicallyIncreasingTime();
56
  }
57
 
58
  int64_t CurrentClockTimeMilliseconds() override {
59
    return inner.CurrentClockTimeMilliseconds();
60
  }
61
 
62
  double CurrentClockTimeMillis() override {
63
    return inner.CurrentClockTimeMillis();
64
  }
65
 
66
  double CurrentClockTimeMillisecondsHighResolution() override {
67
    return inner.CurrentClockTimeMillisecondsHighResolution();
68
  }
69
 
70
  v8::TracingController* GetTracingController() override {
71
    return inner.GetTracingController();
72
  }
73
 
74
 private:
75
  v8::Platform& inner;
76
 
77
  class JobTaskWrapper: public v8::JobTask {
78
   public:
79
    JobTaskWrapper(std::unique_ptr<v8::JobTask> inner);
80
 
81
    void Run(v8::JobDelegate*) override;
82
 
83
    size_t GetMaxConcurrency(size_t worker_count) const override {
84
      return inner->GetMaxConcurrency(worker_count);
85
    }
86
 
87
   private:
88
    std::unique_ptr<v8::JobTask> inner;
89
  };
90
};
91
 
92
}  // namespace workerd::jsg