gin/per_isolate_data.cc

   1 // Copyright 2013 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/per_isolate_data.h"
   6
   7 #include <utility>
   8
   9 #include "base/check.h"
  10 #include "base/notreached.h"
  11 #include "base/task/single_thread_task_runner.h"
  12 #include "gin/public/gin_embedders.h"
  13 #include "gin/v8_foreground_task_runner.h"
  14 #include "gin/v8_foreground_task_runner_with_locker.h"
  15 #include "v8/include/v8-isolate.h"
  16
  17 using v8::ArrayBuffer;
  18 using v8::Eternal;
  19 using v8::Isolate;
  20 using v8::Local;
  21 using v8::Object;
  22 using v8::FunctionTemplate;
  23 using v8::ObjectTemplate;
  24
  25 namespace {
  26 std::shared_ptr<gin::V8ForegroundTaskRunnerBase> CreateV8ForegroundTaskRunner(
  27     v8::Isolate* isolate,
  28     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
  29     gin::IsolateHolder::AccessMode access_mode) {
  30   if (access_mode == gin::IsolateHolder::kUseLocker) {
  31     return std::make_shared<gin::V8ForegroundTaskRunnerWithLocker>(
  32         isolate, std::move(task_runner));
  33   } else {
  34     return std::make_shared<gin::V8ForegroundTaskRunner>(
  35         std::move(task_runner));
  36   }
  37 }
  38 }  // namespace
  39
  40 namespace gin {
  41
  42 PerIsolateData::PerIsolateData(
  43     Isolate* isolate,
  44     ArrayBuffer::Allocator* allocator,
  45     IsolateHolder::AccessMode access_mode,
  46     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
  47     scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner)
  48     : isolate_(isolate), allocator_(allocator) {
  49   isolate_->SetData(kEmbedderNativeGin, this);
  50
  51   DCHECK(task_runner);
  52   task_runner_ = CreateV8ForegroundTaskRunner(isolate_, std::move(task_runner),
  53                                               access_mode);
  54   if (low_priority_task_runner) {
  55     low_priority_task_runner_ = CreateV8ForegroundTaskRunner(
  56         isolate_, std::move(low_priority_task_runner), access_mode);
  57   }
  58 }
  59
  60 PerIsolateData::~PerIsolateData() = default;
  61
  62 PerIsolateData* PerIsolateData::From(Isolate* isolate) {
  63   return static_cast<PerIsolateData*>(isolate->GetData(kEmbedderNativeGin));
  64 }
  65
  66 void PerIsolateData::SetObjectTemplate(WrapperInfo* info,
  67                                        Local<ObjectTemplate> templ) {
  68   object_templates_[info] = Eternal<ObjectTemplate>(isolate_, templ);
  69 }
  70
  71 void PerIsolateData::SetFunctionTemplate(WrapperInfo* info,
  72                                          Local<FunctionTemplate> templ) {
  73   function_templates_[info] = Eternal<FunctionTemplate>(isolate_, templ);
  74 }
  75
  76 v8::Local<v8::ObjectTemplate> PerIsolateData::GetObjectTemplate(
  77     WrapperInfo* info) {
  78   ObjectTemplateMap::iterator it = object_templates_.find(info);
  79   if (it == object_templates_.end())
  80     return v8::Local<v8::ObjectTemplate>();
  81   return it->second.Get(isolate_);
  82 }
  83
  84 v8::Local<v8::FunctionTemplate> PerIsolateData::GetFunctionTemplate(
  85     WrapperInfo* info) {
  86   FunctionTemplateMap::iterator it = function_templates_.find(info);
  87   if (it == function_templates_.end())
  88     return v8::Local<v8::FunctionTemplate>();
  89   return it->second.Get(isolate_);
  90 }
  91
  92 void PerIsolateData::SetIndexedPropertyInterceptor(
  93     WrappableBase* base,
  94     IndexedPropertyInterceptor* interceptor) {
  95   indexed_interceptors_[base] = interceptor;
  96 }
  97
  98 void PerIsolateData::SetNamedPropertyInterceptor(
  99     WrappableBase* base,
 100     NamedPropertyInterceptor* interceptor) {
 101   named_interceptors_[base] = interceptor;
 102 }
 103
 104 void PerIsolateData::ClearIndexedPropertyInterceptor(
 105     WrappableBase* base,
 106     IndexedPropertyInterceptor* interceptor) {
 107   IndexedPropertyInterceptorMap::iterator it = indexed_interceptors_.find(base);
 108   if (it != indexed_interceptors_.end())
 109     indexed_interceptors_.erase(it);
 110   else
 111     NOTREACHED();
 112 }
 113
 114 void PerIsolateData::ClearNamedPropertyInterceptor(
 115     WrappableBase* base,
 116     NamedPropertyInterceptor* interceptor) {
 117   NamedPropertyInterceptorMap::iterator it = named_interceptors_.find(base);
 118   if (it != named_interceptors_.end())
 119     named_interceptors_.erase(it);
 120   else
 121     NOTREACHED();
 122 }
 123
 124 IndexedPropertyInterceptor* PerIsolateData::GetIndexedPropertyInterceptor(
 125     WrappableBase* base) {
 126   IndexedPropertyInterceptorMap::iterator it = indexed_interceptors_.find(base);
 127   if (it != indexed_interceptors_.end())
 128     return it->second;
 129   else
 130     return NULL;
 131 }
 132
 133 NamedPropertyInterceptor* PerIsolateData::GetNamedPropertyInterceptor(
 134     WrappableBase* base) {
 135   NamedPropertyInterceptorMap::iterator it = named_interceptors_.find(base);
 136   if (it != named_interceptors_.end())
 137     return it->second;
 138   else
 139     return NULL;
 140 }
 141
 142 void PerIsolateData::EnableIdleTasks(
 143     std::unique_ptr<V8IdleTaskRunner> idle_task_runner) {
 144   task_runner_->EnableIdleTasks(std::move(idle_task_runner));
 145 }
 146
 147 }  // namespace gin