[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
@@ skipping 33 matching lines @@
 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,
+                                   bool take_snapshot)
     : isolate_holder_(
           task_runner ? task_runner->ToSingleThreadTaskRunner() : nullptr,
           gin::IsolateHolder::kSingleThread,
           IsMainThread() ? gin::IsolateHolder::kDisallowAtomicsWait
-                         : gin::IsolateHolder::kAllowAtomicsWait),
+                         : gin::IsolateHolder::kAllowAtomicsWait,
+          table,
+          take_snapshot ? gin::IsolateHolder::kTakeSnapshot
+                        : gin::IsolateHolder::kDefault),
       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.
   GetIsolate()->Enter();
   GetIsolate()->AddBeforeCallEnteredCallback(&BeforeCallEnteredCallback);
   GetIsolate()->AddMicrotasksCompletedCallback(&MicrotasksCompletedCallback);
   if (IsMainThread())
     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,
+                                          bool take_snapshot) {
+  V8PerIsolateData* data =
+      new V8PerIsolateData(task_runner, table, take_snapshot);
   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 85 matching lines @@
 }
 
 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));
 }
 
+v8::Local<v8::FunctionTemplate> V8PerIsolateData::FindInterfaceTemplateTemp(
+    const DOMWrapperWorld& world,
+    const void* key) {
+  auto& map = interface_template_temp_map_;
+  auto result = map.find(key);
+  if (result != map.end())
+    return result->value.Get(GetIsolate());
+  return v8::Local<v8::FunctionTemplate>();
+}
+
+void V8PerIsolateData::SetInterfaceTemplateTemp(
+    const DOMWrapperWorld& world,
+    const void* key,
+    v8::Local<v8::FunctionTemplate> value) {
+  auto& map = interface_template_temp_map_;
+  map.insert(key, CopyablePersistent(GetIsolate(), value));
+}
+
+void V8PerIsolateData::ClearAll() {
+  interface_template_temp_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();
     Vector<v8::Eternal<v8::Name>> new_vector(count);
     std::transform(
@@ skipping 111 matching lines @@
   ScriptWrappableVisitor* current = CurrentVisitor();
   if (current)
     current->PerformCleanup();
 
   V8PerIsolateData::From(isolate_)->script_wrappable_visitor_.swap(
       saved_visitor_);
   isolate_->SetEmbedderHeapTracer(CurrentVisitor());
 }
 
 }  // namespace blink