[Bindings] Create and use V8 context snapshots

third_party/WebKit/Source/platform/bindings/V8PerIsolateData.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/bindings/V8PerIsolateData.h"
 
 #include <memory>
 
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/bindings/DOMDataStore.h"
 #include "platform/bindings/V8Binding.h"
 #include "platform/bindings/V8ObjectConstructor.h"
 #include "platform/bindings/V8PrivateProperty.h"
 #include "platform/bindings/V8ValueCache.h"
 #include "platform/wtf/LeakAnnotations.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "v8/include/v8-debug.h"
 
 namespace blink {
 
 static V8PerIsolateData* g_main_thread_per_isolate_data = 0;
 
 static void BeforeCallEnteredCallback(v8::Isolate* isolate) {
   CHECK(!ScriptForbiddenScope::IsScriptForbidden());
 }
 
 static void MicrotasksCompletedCallback(v8::Isolate* isolate) {
   V8PerIsolateData::From(isolate)->RunEndOfScopeTasks();
 }
 
-V8PerIsolateData::V8PerIsolateData(WebTaskRunner* task_runner)
+V8PerIsolateData::V8PerIsolateData(WebTaskRunner* task_runner,
+                                   intptr_t* table,
+                                   V8ContextMode context_mode)
     : isolate_holder_(
           task_runner ? task_runner->ToSingleThreadTaskRunner() : nullptr,
           gin::IsolateHolder::kSingleThread,
           IsMainThread() ? gin::IsolateHolder::kDisallowAtomicsWait
-                         : gin::IsolateHolder::kAllowAtomicsWait),
+                         : gin::IsolateHolder::kAllowAtomicsWait,
+          table,
+          context_mode == V8ContextMode::kUseSnapshot ? &startup_data_

[Yuki, 2017/05/30 14:35:58]

Better to set v8_context_mode_ first, and use members rather than arguments.
  v8_context_mode_(context_mode),
  isolate_holder_(... v8_context_mode_ ...),

[peria, 2017/06/01 08:33:34]

Done.

+                                                      : nullptr),
+      v8_context_mode_(context_mode),
       string_cache_(WTF::WrapUnique(new StringCache(GetIsolate()))),
       private_property_(V8PrivateProperty::Create()),
       constructor_mode_(ConstructorMode::kCreateNewObject),
       use_counter_disabled_(false),
       is_handling_recursion_level_error_(false),
       is_reporting_exception_(false) {
+  // In case if failed to load snapshot file
+  if (v8_context_mode_ == V8ContextMode::kUseSnapshot && !startup_data_.data) {
+    v8_context_mode_ = V8ContextMode::kDontUseSnapshot;

[Yuki, 2017/05/30 14:35:58]

Probably I asked this question before.
Do we really want to fall back rather than CHECK / NOTREACHED?

[peria, 2017/06/01 08:33:34]

Let's chat again.

+  }
+
   // FIXME: Remove once all v8::Isolate::GetCurrent() calls are gone.
   GetIsolate()->Enter();
   GetIsolate()->AddBeforeCallEnteredCallback(&BeforeCallEnteredCallback);
   GetIsolate()->AddMicrotasksCompletedCallback(&MicrotasksCompletedCallback);
   if (IsMainThread())
     g_main_thread_per_isolate_data = this;
 }
 
+V8PerIsolateData::V8PerIsolateData(intptr_t* table)
+    : snapshot_creator_(new v8::SnapshotCreator(table)),
+      isolate_holder_(snapshot_creator_->GetIsolate()),
+      v8_context_mode_(V8ContextMode::kTakeSnapshot),
+      string_cache_(WTF::WrapUnique(new StringCache(GetIsolate()))),
+      private_property_(V8PrivateProperty::Create()),
+      constructor_mode_(ConstructorMode::kCreateNewObject),
+      use_counter_disabled_(false),
+      is_handling_recursion_level_error_(false),
+      is_reporting_exception_(false) {
+  // FIXME: Remove once all v8::Isolate::GetCurrent() calls are gone.
+  // SnapshotCreator enters the isolate, so don't do it again.
+  GetIsolate()->AddBeforeCallEnteredCallback(&BeforeCallEnteredCallback);
+  GetIsolate()->AddMicrotasksCompletedCallback(&MicrotasksCompletedCallback);
+  g_main_thread_per_isolate_data = this;
+}
+
 V8PerIsolateData::~V8PerIsolateData() {}
 
 v8::Isolate* V8PerIsolateData::MainThreadIsolate() {
   DCHECK(g_main_thread_per_isolate_data);
   return g_main_thread_per_isolate_data->GetIsolate();
 }
 
-v8::Isolate* V8PerIsolateData::Initialize(WebTaskRunner* task_runner) {
-  V8PerIsolateData* data = new V8PerIsolateData(task_runner);
+v8::Isolate* V8PerIsolateData::Initialize(WebTaskRunner* task_runner,
+                                          intptr_t* table,
+                                          V8ContextMode context_mode) {
+  V8PerIsolateData* data = nullptr;
+  if (context_mode == V8ContextMode::kTakeSnapshot) {
+    CHECK(table);
+    data = new V8PerIsolateData(table);
+    v8::Isolate* isolate = data->GetIsolate();
+    CHECK(isolate);
+    isolate->SetData(gin::kEmbedderBlink, data);
+    return isolate;
+  }
+
+  if (!RuntimeEnabledFeatures::v8ContextSnapshotEnabled()) {
+    context_mode = V8ContextMode::kDontUseSnapshot;
+    table = nullptr;
+  }
+  data = new V8PerIsolateData(task_runner, table, context_mode);
   v8::Isolate* isolate = data->GetIsolate();
   isolate->SetData(gin::kEmbedderBlink, data);
   return isolate;
 }
 
 void V8PerIsolateData::EnableIdleTasks(
     v8::Isolate* isolate,
     std::unique_ptr<gin::V8IdleTaskRunner> task_runner) {
   From(isolate)->isolate_holder_.EnableIdleTasks(std::move(task_runner));
 }
@@ skipping 63 matching lines @@
   v8::Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(
       GetIsolate(), callback, data, signature, length);
   templ->RemovePrototype();
   map.insert(key, v8::Eternal<v8::FunctionTemplate>(GetIsolate(), templ));
   return templ;
 }
 
 v8::Local<v8::FunctionTemplate> V8PerIsolateData::FindInterfaceTemplate(
     const DOMWrapperWorld& world,
     const void* key) {
+  if (GetV8ContextMode() == V8ContextMode::kTakeSnapshot) {
+    auto& map = interface_template_persistent_map_;
+    auto result = map.find(key);
+    if (result != map.end())
+      return result->value.Get(GetIsolate());
+    return v8::Local<v8::FunctionTemplate>();
+  }
+
   auto& map = SelectInterfaceTemplateMap(world);
   auto result = map.find(key);
   if (result != map.end())
     return result->value.Get(GetIsolate());
   return v8::Local<v8::FunctionTemplate>();
 }
 
 void V8PerIsolateData::SetInterfaceTemplate(
     const DOMWrapperWorld& world,
     const void* key,
     v8::Local<v8::FunctionTemplate> value) {
-  auto& map = SelectInterfaceTemplateMap(world);
-  map.insert(key, v8::Eternal<v8::FunctionTemplate>(GetIsolate(), value));
+  if (GetV8ContextMode() == V8ContextMode::kTakeSnapshot) {
+    auto& map = interface_template_persistent_map_;
+    map.insert(key, CopyablePersistent(GetIsolate(), value));
+  } else {
+    auto& map = SelectInterfaceTemplateMap(world);
+    map.insert(key, v8::Eternal<v8::FunctionTemplate>(GetIsolate(), value));
+  }
+}
+
+void V8PerIsolateData::ClearPersistents() {
+  interface_template_persistent_map_.clear();
+  private_property_.reset();
 }
 
 const v8::Eternal<v8::Name>* V8PerIsolateData::FindOrCreateEternalNameCache(
     const void* lookup_key,
     const char* const names[],
     size_t count) {
   auto it = eternal_name_cache_.find(lookup_key);
   const Vector<v8::Eternal<v8::Name>>* vector = nullptr;
   if (UNLIKELY(it == eternal_name_cache_.end())) {
     v8::Isolate* isolate = this->GetIsolate();
@@ skipping 113 matching lines @@
   ScriptWrappableVisitor* current = CurrentVisitor();
   if (current)
     current->PerformCleanup();
 
   V8PerIsolateData::From(isolate_)->script_wrappable_visitor_.swap(
       saved_visitor_);
   isolate_->SetEmbedderHeapTracer(CurrentVisitor());
 }
 
 }  // namespace blink