[Bindings] Create and use V8 context snapshots

gin/isolate_holder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gin/public/isolate_holder.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 17 matching lines @@
 v8::ArrayBuffer::Allocator* g_array_buffer_allocator = nullptr;
 }  // namespace
 
 IsolateHolder::IsolateHolder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : IsolateHolder(std::move(task_runner), AccessMode::kSingleThread) {}
 
 IsolateHolder::IsolateHolder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     AccessMode access_mode)
-    : IsolateHolder(std::move(task_runner), access_mode, kAllowAtomicsWait) {}
+    : IsolateHolder(std::move(task_runner),
+                    access_mode,
+                    kAllowAtomicsWait,
+                    nullptr,
+                    kDefault) {}
 
 IsolateHolder::IsolateHolder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     AccessMode access_mode,
-    AllowAtomicsWaitMode atomics_wait_mode)
-    : access_mode_(access_mode) {
+    AllowAtomicsWaitMode atomics_wait_mode,
+    intptr_t* reference,
+    V8ContextMode context_mode)
+    : access_mode_(access_mode), v8_context_mode_(context_mode) {
   v8::ArrayBuffer::Allocator* allocator = g_array_buffer_allocator;
-  CHECK(allocator) << "You need to invoke gin::IsolateHolder::Initialize first";
-  v8::Isolate::CreateParams params;
-  params.entry_hook = DebugImpl::GetFunctionEntryHook();
-  params.code_event_handler = DebugImpl::GetJitCodeEventHandler();
-  params.constraints.ConfigureDefaults(base::SysInfo::AmountOfPhysicalMemory(),
-                                       base::SysInfo::AmountOfVirtualMemory());
-  params.array_buffer_allocator = allocator;
-  params.allow_atomics_wait = atomics_wait_mode == kAllowAtomicsWait;
-  isolate_ = v8::Isolate::New(params);
+
+  if (v8_context_mode_ == kTakeSnapshot) {
+    DCHECK(reference);
+    snapshot_creator_.reset(new v8::SnapshotCreator(reference));

[haraken, 2017/05/20 19:10:02]

It looks strange that we have to create the snapshot when instantiating the
IsolateHolder. Can we delay creating the snapshot to when
blink::SnapshotCreator::TakeSnapshot gets called?

I think it will simplify the code. e.g., I think we can remove
blink::SnapshotCreator::SetTakingSnapshot(true) from gin_prepare_main.cc.

[peria, 2017/05/30 08:25:43]

Done.

+    isolate_ = snapshot_creator_->GetIsolate();
+    isolate_->Exit();

[haraken, 2017/05/20 19:10:02]

Just to confirm: Does "new v8::SnapshotCreator(reference)" do all the work to
take the snapshot and thus we no longer need the isolate (and can exit
immediately) here, right?

Also is there any reason you have to call isolate->Exit()? It might be okay but
looks a bit strange because the isolate is used afterwards.

[peria, 2017/05/30 08:25:43]

Acknowledged.

+  } else {
+    CHECK(allocator)
+        << "You need to invoke gin::IsolateHolder::Initialize first";
+    v8::Isolate::CreateParams params;
+    params.entry_hook = DebugImpl::GetFunctionEntryHook();
+    params.code_event_handler = DebugImpl::GetJitCodeEventHandler();
+    params.constraints.ConfigureDefaults(
+        base::SysInfo::AmountOfPhysicalMemory(),
+        base::SysInfo::AmountOfVirtualMemory());
+    params.array_buffer_allocator = allocator;
+    params.allow_atomics_wait = atomics_wait_mode == kAllowAtomicsWait;
+
+    params.external_references = reference;
+    if (v8_context_mode_ == kUseSnapshot) {
+      CHECK(reference);
+      V8Initializer::GetV8ContextData(&startup_data_.data,
+                                      &startup_data_.raw_size);

[haraken, 2017/05/20 19:10:02]

Can we move this code to when LocalWindowProxy uses the snapshot?

In general it looks strange to do context-snapshot-related things when
instantiating IsolateHolder. I hope all the changes to this file are moved to
other places.

[peria, 2017/05/30 08:25:43]

Function name seems wrong, but this actually loads the snapshot blob file, and
does not create contexts.

+      if (startup_data_.data) {
+        params.snapshot_blob = &startup_data_;
+      } else {
+        params.snapshot_blob = nullptr;
+        v8_context_mode_ = kDefault;

[haraken, 2017/05/20 19:10:02]

Why do we need to overwrite v8_context_mode_ here?

[peria, 2017/05/30 08:25:43]

it is used to handle context creation (FromSnapshot() or New())
If it fails to load Snapshot file, we can't do Context::FromSnapshot()

+      }
+    }
+    isolate_ = v8::Isolate::New(params);
+  }
+
   isolate_data_.reset(
       new PerIsolateData(isolate_, allocator, access_mode, task_runner));
   isolate_memory_dump_provider_.reset(new V8IsolateMemoryDumpProvider(this));
 #if defined(OS_WIN)
   {
     void* code_range;
     size_t size;
     isolate_->GetCodeRange(&code_range, &size);
     Debug::CodeRangeCreatedCallback callback =
         DebugImpl::GetCodeRangeCreatedCallback();
@@ skipping 13 matching lines @@
     isolate_->GetCodeRange(&code_range, &size);
     Debug::CodeRangeDeletedCallback callback =
         DebugImpl::GetCodeRangeDeletedCallback();
     if (code_range && callback)
       callback(code_range);
   }
 #endif
   isolate_memory_dump_provider_.reset();
   isolate_data_.reset();
   isolate_->Dispose();
-  isolate_ = NULL;
+  isolate_ = nullptr;
 }
 
 // static
 void IsolateHolder::Initialize(ScriptMode mode,
                                V8ExtrasMode v8_extras_mode,
                                v8::ArrayBuffer::Allocator* allocator) {
   CHECK(allocator);
   V8Initializer::Initialize(mode, v8_extras_mode);
   g_array_buffer_allocator = allocator;
 }
@@ skipping 10 matching lines @@
   task_observer_.reset();
 }
 
 void IsolateHolder::EnableIdleTasks(
     std::unique_ptr<V8IdleTaskRunner> idle_task_runner) {
   DCHECK(isolate_data_.get());
   isolate_data_->EnableIdleTasks(std::move(idle_task_runner));
 }
 
 }  // namespace gin