OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "gin/public/isolate_holder.h" | 5 #include "gin/public/isolate_holder.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdlib.h> | 8 #include <stdlib.h> |
9 #include <string.h> | 9 #include <string.h> |
10 | 10 |
11 #include <memory> | 11 #include <memory> |
12 #include <utility> | 12 #include <utility> |
13 | 13 |
14 #include "base/logging.h" | 14 #include "base/logging.h" |
15 #include "base/message_loop/message_loop.h" | 15 #include "base/message_loop/message_loop.h" |
16 #include "base/single_thread_task_runner.h" | 16 #include "base/single_thread_task_runner.h" |
17 #include "base/sys_info.h" | 17 #include "base/sys_info.h" |
| 18 #include "build/build_config.h" |
18 #include "gin/debug_impl.h" | 19 #include "gin/debug_impl.h" |
19 #include "gin/function_template.h" | 20 #include "gin/function_template.h" |
20 #include "gin/per_isolate_data.h" | 21 #include "gin/per_isolate_data.h" |
21 #include "gin/run_microtasks_observer.h" | 22 #include "gin/run_microtasks_observer.h" |
22 #include "gin/v8_initializer.h" | 23 #include "gin/v8_initializer.h" |
23 #include "gin/v8_isolate_memory_dump_provider.h" | 24 #include "gin/v8_isolate_memory_dump_provider.h" |
24 | 25 |
25 namespace gin { | 26 namespace gin { |
26 | 27 |
27 namespace { | 28 namespace { |
28 v8::ArrayBuffer::Allocator* g_array_buffer_allocator = nullptr; | 29 v8::ArrayBuffer::Allocator* g_array_buffer_allocator = nullptr; |
29 } // namespace | 30 } // namespace |
30 | 31 |
31 IsolateHolder::IsolateHolder( | 32 IsolateHolder::IsolateHolder( |
32 scoped_refptr<base::SingleThreadTaskRunner> task_runner) | 33 scoped_refptr<base::SingleThreadTaskRunner> task_runner) |
33 : IsolateHolder(std::move(task_runner), AccessMode::kSingleThread) {} | 34 : IsolateHolder(std::move(task_runner), AccessMode::kSingleThread) {} |
34 | 35 |
35 IsolateHolder::IsolateHolder( | 36 IsolateHolder::IsolateHolder( |
36 scoped_refptr<base::SingleThreadTaskRunner> task_runner, | 37 scoped_refptr<base::SingleThreadTaskRunner> task_runner, |
37 AccessMode access_mode) | 38 AccessMode access_mode) |
38 : IsolateHolder(std::move(task_runner), access_mode, kAllowAtomicsWait) {} | 39 : IsolateHolder(std::move(task_runner), |
| 40 access_mode, |
| 41 kAllowAtomicsWait, |
| 42 nullptr, |
| 43 nullptr) {} |
39 | 44 |
40 IsolateHolder::IsolateHolder( | 45 IsolateHolder::IsolateHolder( |
41 scoped_refptr<base::SingleThreadTaskRunner> task_runner, | 46 scoped_refptr<base::SingleThreadTaskRunner> task_runner, |
42 AccessMode access_mode, | 47 AccessMode access_mode, |
43 AllowAtomicsWaitMode atomics_wait_mode) | 48 AllowAtomicsWaitMode atomics_wait_mode, |
| 49 intptr_t* reference, |
| 50 v8::StartupData* startup_data) |
44 : access_mode_(access_mode) { | 51 : access_mode_(access_mode) { |
45 v8::ArrayBuffer::Allocator* allocator = g_array_buffer_allocator; | 52 v8::ArrayBuffer::Allocator* allocator = g_array_buffer_allocator; |
46 CHECK(allocator) << "You need to invoke gin::IsolateHolder::Initialize first"; | 53 CHECK(allocator) << "You need to invoke gin::IsolateHolder::Initialize first"; |
| 54 |
47 v8::Isolate::CreateParams params; | 55 v8::Isolate::CreateParams params; |
48 params.entry_hook = DebugImpl::GetFunctionEntryHook(); | 56 params.entry_hook = DebugImpl::GetFunctionEntryHook(); |
49 params.code_event_handler = DebugImpl::GetJitCodeEventHandler(); | 57 params.code_event_handler = DebugImpl::GetJitCodeEventHandler(); |
50 params.constraints.ConfigureDefaults(base::SysInfo::AmountOfPhysicalMemory(), | 58 params.constraints.ConfigureDefaults(base::SysInfo::AmountOfPhysicalMemory(), |
51 base::SysInfo::AmountOfVirtualMemory()); | 59 base::SysInfo::AmountOfVirtualMemory()); |
52 params.array_buffer_allocator = allocator; | 60 params.array_buffer_allocator = allocator; |
53 params.allow_atomics_wait = atomics_wait_mode == kAllowAtomicsWait; | 61 params.allow_atomics_wait = atomics_wait_mode == kAllowAtomicsWait; |
| 62 params.external_references = reference; |
| 63 |
| 64 if (startup_data) { |
| 65 CHECK(reference); |
| 66 V8Initializer::GetV8ContextSnapshotData(&startup_data->data, |
| 67 &startup_data->raw_size); |
| 68 if (startup_data->data) { |
| 69 params.snapshot_blob = startup_data; |
| 70 } |
| 71 } |
54 isolate_ = v8::Isolate::New(params); | 72 isolate_ = v8::Isolate::New(params); |
55 isolate_data_.reset( | 73 |
56 new PerIsolateData(isolate_, allocator, access_mode, task_runner)); | 74 SetUp(std::move(task_runner)); |
57 isolate_memory_dump_provider_.reset(new V8IsolateMemoryDumpProvider(this)); | |
58 #if defined(OS_WIN) | |
59 { | |
60 void* code_range; | |
61 size_t size; | |
62 isolate_->GetCodeRange(&code_range, &size); | |
63 Debug::CodeRangeCreatedCallback callback = | |
64 DebugImpl::GetCodeRangeCreatedCallback(); | |
65 if (code_range && size && callback) | |
66 callback(code_range, size); | |
67 } | |
68 #endif | |
69 } | 75 } |
70 | 76 |
71 IsolateHolder::IsolateHolder(intptr_t* reference_table, | 77 IsolateHolder::IsolateHolder(intptr_t* reference_table, |
72 v8::StartupData* existing_blob) | 78 v8::StartupData* existing_blob) |
73 : snapshot_creator_( | 79 : snapshot_creator_( |
74 new v8::SnapshotCreator(reference_table, existing_blob)), | 80 new v8::SnapshotCreator(reference_table, existing_blob)), |
75 access_mode_(kSingleThread) { | 81 isolate_(snapshot_creator_->GetIsolate()), |
76 v8::ArrayBuffer::Allocator* allocator = g_array_buffer_allocator; | 82 access_mode_(AccessMode::kSingleThread) { |
77 CHECK(allocator) << "You need to invoke gin::IsolateHolder::Initialize first"; | 83 SetUp(nullptr); |
78 isolate_ = snapshot_creator_->GetIsolate(); | |
79 isolate_data_.reset( | |
80 new PerIsolateData(isolate_, allocator, access_mode_, nullptr)); | |
81 isolate_memory_dump_provider_.reset(new V8IsolateMemoryDumpProvider(this)); | |
82 #if defined(OS_WIN) | |
83 { | |
84 void* code_range; | |
85 size_t size; | |
86 isolate_->GetCodeRange(&code_range, &size); | |
87 Debug::CodeRangeCreatedCallback callback = | |
88 DebugImpl::GetCodeRangeCreatedCallback(); | |
89 if (code_range && size && callback) | |
90 callback(code_range, size); | |
91 } | |
92 #endif | |
93 } | 84 } |
94 | 85 |
95 IsolateHolder::~IsolateHolder() { | 86 IsolateHolder::~IsolateHolder() { |
96 if (task_observer_.get()) | 87 if (task_observer_.get()) |
97 base::MessageLoop::current()->RemoveTaskObserver(task_observer_.get()); | 88 base::MessageLoop::current()->RemoveTaskObserver(task_observer_.get()); |
98 #if defined(OS_WIN) | 89 #if defined(OS_WIN) |
99 { | 90 { |
100 void* code_range; | 91 void* code_range; |
101 size_t size; | 92 size_t size; |
102 isolate_->GetCodeRange(&code_range, &size); | 93 isolate_->GetCodeRange(&code_range, &size); |
103 Debug::CodeRangeDeletedCallback callback = | 94 Debug::CodeRangeDeletedCallback callback = |
104 DebugImpl::GetCodeRangeDeletedCallback(); | 95 DebugImpl::GetCodeRangeDeletedCallback(); |
105 if (code_range && callback) | 96 if (code_range && callback) |
106 callback(code_range); | 97 callback(code_range); |
107 } | 98 } |
108 #endif | 99 #endif |
109 isolate_memory_dump_provider_.reset(); | 100 isolate_memory_dump_provider_.reset(); |
110 isolate_data_.reset(); | 101 isolate_data_.reset(); |
111 isolate_->Dispose(); | 102 isolate_->Dispose(); |
112 isolate_ = NULL; | 103 isolate_ = nullptr; |
113 } | 104 } |
114 | 105 |
115 // static | 106 // static |
116 void IsolateHolder::Initialize(ScriptMode mode, | 107 void IsolateHolder::Initialize(ScriptMode mode, |
117 V8ExtrasMode v8_extras_mode, | 108 V8ExtrasMode v8_extras_mode, |
118 v8::ArrayBuffer::Allocator* allocator) { | 109 v8::ArrayBuffer::Allocator* allocator) { |
119 CHECK(allocator); | 110 CHECK(allocator); |
120 V8Initializer::Initialize(mode, v8_extras_mode); | 111 V8Initializer::Initialize(mode, v8_extras_mode); |
121 g_array_buffer_allocator = allocator; | 112 g_array_buffer_allocator = allocator; |
122 } | 113 } |
123 | 114 |
124 void IsolateHolder::AddRunMicrotasksObserver() { | 115 void IsolateHolder::AddRunMicrotasksObserver() { |
125 DCHECK(!task_observer_.get()); | 116 DCHECK(!task_observer_.get()); |
126 task_observer_.reset(new RunMicrotasksObserver(isolate_)); | 117 task_observer_.reset(new RunMicrotasksObserver(isolate_)); |
127 base::MessageLoop::current()->AddTaskObserver(task_observer_.get()); | 118 base::MessageLoop::current()->AddTaskObserver(task_observer_.get()); |
128 } | 119 } |
129 | 120 |
130 void IsolateHolder::RemoveRunMicrotasksObserver() { | 121 void IsolateHolder::RemoveRunMicrotasksObserver() { |
131 DCHECK(task_observer_.get()); | 122 DCHECK(task_observer_.get()); |
132 base::MessageLoop::current()->RemoveTaskObserver(task_observer_.get()); | 123 base::MessageLoop::current()->RemoveTaskObserver(task_observer_.get()); |
133 task_observer_.reset(); | 124 task_observer_.reset(); |
134 } | 125 } |
135 | 126 |
136 void IsolateHolder::EnableIdleTasks( | 127 void IsolateHolder::EnableIdleTasks( |
137 std::unique_ptr<V8IdleTaskRunner> idle_task_runner) { | 128 std::unique_ptr<V8IdleTaskRunner> idle_task_runner) { |
138 DCHECK(isolate_data_.get()); | 129 DCHECK(isolate_data_.get()); |
139 isolate_data_->EnableIdleTasks(std::move(idle_task_runner)); | 130 isolate_data_->EnableIdleTasks(std::move(idle_task_runner)); |
140 } | 131 } |
141 | 132 |
| 133 void IsolateHolder::SetUp( |
| 134 scoped_refptr<base::SingleThreadTaskRunner> task_runner) { |
| 135 v8::ArrayBuffer::Allocator* allocator = g_array_buffer_allocator; |
| 136 CHECK(allocator) << "You need to invoke gin::IsolateHolder::Initialize first"; |
| 137 isolate_data_.reset( |
| 138 new PerIsolateData(isolate_, allocator, access_mode_, task_runner)); |
| 139 isolate_memory_dump_provider_.reset(new V8IsolateMemoryDumpProvider(this)); |
| 140 #if defined(OS_WIN) |
| 141 { |
| 142 void* code_range; |
| 143 size_t size; |
| 144 isolate_->GetCodeRange(&code_range, &size); |
| 145 Debug::CodeRangeCreatedCallback callback = |
| 146 DebugImpl::GetCodeRangeCreatedCallback(); |
| 147 if (code_range && size && callback) |
| 148 callback(code_range, size); |
| 149 } |
| 150 #endif |
| 151 } |
| 152 |
142 } // namespace gin | 153 } // namespace gin |
OLD | NEW |