[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 1 | // Copyright 2013 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 | |
ulan | 3cbdcd0 | 2015-07-20 11:32:58 | [diff] [blame] | 5 | #include "gin/per_isolate_data.h" |
| 6 | |
dcheng | e4860045 | 2015-12-28 02:24:50 | [diff] [blame] | 7 | #include <utility> |
| 8 | |
[email protected] | 5c969b8 | 2014-03-12 04:59:05 | [diff] [blame] | 9 | #include "base/logging.h" |
skyostil | a389986 | 2015-06-12 18:21:58 | [diff] [blame] | 10 | #include "base/single_thread_task_runner.h" |
gab | 54909b72 | 2016-05-11 18:34:11 | [diff] [blame] | 11 | #include "base/threading/thread_task_runner_handle.h" |
[email protected] | f04b0e9 | 2013-11-22 14:20:55 | [diff] [blame] | 12 | #include "gin/public/gin_embedders.h" |
Andreas Haas | c13cae8 | 2017-11-16 12:54:38 | [diff] [blame] | 13 | #include "gin/v8_foreground_task_runner.h" |
| 14 | #include "gin/v8_foreground_task_runner_with_locker.h" |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 15 | |
[email protected] | 73dcce9 | 2014-02-20 08:24:04 | [diff] [blame] | 16 | using v8::ArrayBuffer; |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 17 | using v8::Eternal; |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 18 | using v8::Isolate; |
| 19 | using v8::Local; |
| 20 | using v8::Object; |
[email protected] | 97f21ca | 2013-11-17 17:46:07 | [diff] [blame] | 21 | using v8::FunctionTemplate; |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 22 | using v8::ObjectTemplate; |
| 23 | |
| 24 | namespace gin { |
| 25 | |
altimin | 124814c | 2017-01-03 14:06:54 | [diff] [blame] | 26 | PerIsolateData::PerIsolateData( |
| 27 | Isolate* isolate, |
| 28 | ArrayBuffer::Allocator* allocator, |
| 29 | IsolateHolder::AccessMode access_mode, |
| 30 | scoped_refptr<base::SingleThreadTaskRunner> task_runner) |
Andreas Haas | c13cae8 | 2017-11-16 12:54:38 | [diff] [blame] | 31 | : isolate_(isolate), allocator_(allocator) { |
[email protected] | f04b0e9 | 2013-11-22 14:20:55 | [diff] [blame] | 32 | isolate_->SetData(kEmbedderNativeGin, this); |
Andreas Haas | c13cae8 | 2017-11-16 12:54:38 | [diff] [blame] | 33 | |
Siddhartha | 031fecd6 | 2018-01-04 22:02:47 | [diff] [blame] | 34 | DCHECK(task_runner); |
Andreas Haas | c13cae8 | 2017-11-16 12:54:38 | [diff] [blame] | 35 | if (access_mode == IsolateHolder::kUseLocker) { |
| 36 | task_runner_ = std::make_shared<V8ForegroundTaskRunnerWithLocker>( |
| 37 | isolate, task_runner); |
| 38 | } else { |
| 39 | task_runner_ = std::make_shared<V8ForegroundTaskRunner>(task_runner); |
| 40 | } |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 41 | } |
| 42 | |
| 43 | PerIsolateData::~PerIsolateData() { |
[email protected] | f04b0e9 | 2013-11-22 14:20:55 | [diff] [blame] | 44 | isolate_->SetData(kEmbedderNativeGin, NULL); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 45 | } |
| 46 | |
| 47 | PerIsolateData* PerIsolateData::From(Isolate* isolate) { |
[email protected] | f04b0e9 | 2013-11-22 14:20:55 | [diff] [blame] | 48 | return static_cast<PerIsolateData*>(isolate->GetData(kEmbedderNativeGin)); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 49 | } |
| 50 | |
[email protected] | e87f312 | 2013-11-12 00:41:27 | [diff] [blame] | 51 | void PerIsolateData::SetObjectTemplate(WrapperInfo* info, |
| 52 | Local<ObjectTemplate> templ) { |
| 53 | object_templates_[info] = Eternal<ObjectTemplate>(isolate_, templ); |
| 54 | } |
| 55 | |
[email protected] | 97f21ca | 2013-11-17 17:46:07 | [diff] [blame] | 56 | void PerIsolateData::SetFunctionTemplate(WrapperInfo* info, |
| 57 | Local<FunctionTemplate> templ) { |
| 58 | function_templates_[info] = Eternal<FunctionTemplate>(isolate_, templ); |
| 59 | } |
| 60 | |
[email protected] | e87f312 | 2013-11-12 00:41:27 | [diff] [blame] | 61 | v8::Local<v8::ObjectTemplate> PerIsolateData::GetObjectTemplate( |
| 62 | WrapperInfo* info) { |
| 63 | ObjectTemplateMap::iterator it = object_templates_.find(info); |
| 64 | if (it == object_templates_.end()) |
| 65 | return v8::Local<v8::ObjectTemplate>(); |
| 66 | return it->second.Get(isolate_); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 67 | } |
| 68 | |
[email protected] | 97f21ca | 2013-11-17 17:46:07 | [diff] [blame] | 69 | v8::Local<v8::FunctionTemplate> PerIsolateData::GetFunctionTemplate( |
| 70 | WrapperInfo* info) { |
| 71 | FunctionTemplateMap::iterator it = function_templates_.find(info); |
| 72 | if (it == function_templates_.end()) |
| 73 | return v8::Local<v8::FunctionTemplate>(); |
| 74 | return it->second.Get(isolate_); |
| 75 | } |
| 76 | |
[email protected] | 5c969b8 | 2014-03-12 04:59:05 | [diff] [blame] | 77 | void PerIsolateData::SetIndexedPropertyInterceptor( |
| 78 | WrappableBase* base, |
| 79 | IndexedPropertyInterceptor* interceptor) { |
| 80 | indexed_interceptors_[base] = interceptor; |
| 81 | } |
| 82 | |
| 83 | void PerIsolateData::SetNamedPropertyInterceptor( |
| 84 | WrappableBase* base, |
| 85 | NamedPropertyInterceptor* interceptor) { |
| 86 | named_interceptors_[base] = interceptor; |
| 87 | } |
| 88 | |
| 89 | void PerIsolateData::ClearIndexedPropertyInterceptor( |
| 90 | WrappableBase* base, |
| 91 | IndexedPropertyInterceptor* interceptor) { |
| 92 | IndexedPropertyInterceptorMap::iterator it = indexed_interceptors_.find(base); |
| 93 | if (it != indexed_interceptors_.end()) |
| 94 | indexed_interceptors_.erase(it); |
| 95 | else |
| 96 | NOTREACHED(); |
| 97 | } |
| 98 | |
| 99 | void PerIsolateData::ClearNamedPropertyInterceptor( |
| 100 | WrappableBase* base, |
| 101 | NamedPropertyInterceptor* interceptor) { |
| 102 | NamedPropertyInterceptorMap::iterator it = named_interceptors_.find(base); |
| 103 | if (it != named_interceptors_.end()) |
| 104 | named_interceptors_.erase(it); |
| 105 | else |
| 106 | NOTREACHED(); |
| 107 | } |
| 108 | |
| 109 | IndexedPropertyInterceptor* PerIsolateData::GetIndexedPropertyInterceptor( |
| 110 | WrappableBase* base) { |
| 111 | IndexedPropertyInterceptorMap::iterator it = indexed_interceptors_.find(base); |
| 112 | if (it != indexed_interceptors_.end()) |
| 113 | return it->second; |
| 114 | else |
| 115 | return NULL; |
| 116 | } |
| 117 | |
| 118 | NamedPropertyInterceptor* PerIsolateData::GetNamedPropertyInterceptor( |
| 119 | WrappableBase* base) { |
| 120 | NamedPropertyInterceptorMap::iterator it = named_interceptors_.find(base); |
| 121 | if (it != named_interceptors_.end()) |
| 122 | return it->second; |
| 123 | else |
| 124 | return NULL; |
| 125 | } |
| 126 | |
ulan | 3cbdcd0 | 2015-07-20 11:32:58 | [diff] [blame] | 127 | void PerIsolateData::EnableIdleTasks( |
mostynb | c862da8 | 2016-04-03 15:54:33 | [diff] [blame] | 128 | std::unique_ptr<V8IdleTaskRunner> idle_task_runner) { |
Andreas Haas | c13cae8 | 2017-11-16 12:54:38 | [diff] [blame] | 129 | task_runner_->EnableIdleTasks(std::move(idle_task_runner)); |
ulan | 3cbdcd0 | 2015-07-20 11:32:58 | [diff] [blame] | 130 | } |
| 131 | |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 132 | } // namespace gin |