[Bindings] Create and use V8 context snapshots

third_party/WebKit/Source/bindings/core/v8/V8SnapshotCreator.cpp

+// Copyright 2017 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 "bindings/core/v8/V8SnapshotCreator.h"
+
+#include <cstring>
+
+#include "bindings/core/v8/GeneratedCodeHelper.h"
+#include "bindings/core/v8/V8Document.h"
+#include "bindings/core/v8/V8HTMLDocument.h"
+#include "bindings/core/v8/V8Initializer.h"
+#include "bindings/core/v8/V8Node.h"
+#include "bindings/core/v8/V8Window.h"
+#include "platform/bindings/DOMWrapperWorld.h"
+#include "platform/bindings/V8ObjectConstructor.h"
+#include "platform/bindings/V8PerIsolateData.h"
+#include "platform/bindings/V8PrivateProperty.h"
+#include "v8/include/v8.h"
+
+namespace blink {
+
+namespace {
+
+// This value must be accessed only on the main thread, and is
+// true when the process (not a renderer) is to take a snapshot.
+bool g_taking_snapshot = false;

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

Shall we move this flag to gin/isolate_holder.h? Then we can remove
TakingSnapshot() and SetTakingSnapshot() from V8SnapshotCreator.

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

Acknowledged.

+
+intptr_t* g_snapshot_reference_table = nullptr;
+
+// NOTE(peria): This method is almost a copy of
+// V8PerContext::ConstructorForTypeSlowCase().
+// TODO(peria): Merge with it.
+v8::Local<v8::Function> ConstructPlainType(v8::Isolate* isolate,
+                                           const DOMWrapperWorld& world,
+                                           v8::Local<v8::Context> context,
+                                           const WrapperTypeInfo* type) {
+  v8::Context::Scope scope(context);
+  // We shouldn't reach this point for the types that are implemented in v8 such
+  // as typed arrays and hence don't have domTemplateFunction.
+  DCHECK(type->dom_template_function);
+  v8::Local<v8::FunctionTemplate> interface_template =
+      type->domTemplate(isolate, world);
+  // Getting the function might fail if we're running out of stack or memory.
+  v8::Local<v8::Function> interface_object;
+  if (!interface_template->GetFunction(context).ToLocal(&interface_object))
+    return v8::Local<v8::Function>();
+
+  if (type->parent_class) {
+    v8::Local<v8::Object> prototype_template =
+        ConstructPlainType(isolate, world, context, type->parent_class);
+    CHECK(interface_object->SetPrototype(context, prototype_template)
+              .ToChecked());
+  }
+
+  v8::Local<v8::Value> prototype_value;
+  CHECK(interface_object->Get(context, V8AtomicString(isolate, "prototype"))
+            .ToLocal(&prototype_value));
+  CHECK(prototype_value->IsObject());
+  v8::Local<v8::Object> prototype_object = prototype_value.As<v8::Object>();
+  if (prototype_object->InternalFieldCount() ==
+          kV8PrototypeInternalFieldcount &&
+      type->wrapper_type_prototype ==
+          WrapperTypeInfo::kWrapperTypeObjectPrototype) {
+    prototype_object->SetAlignedPointerInInternalField(
+        kV8PrototypeTypeIndex, const_cast<WrapperTypeInfo*>(type));
+  }
+  type->PreparePrototypeAndInterfaceObject(
+      context, world, prototype_object, interface_object, interface_template);
+
+  return interface_object;
+}
+
+// NOTE(peria): This method is almost a copy of
+// V8PerContext::CreateWrapperFromCacheSlowCase().
+// TODO(peria): Merge with it.
+v8::Local<v8::Object> CreatePlainWrapper(v8::Isolate* isolate,
+                                         const DOMWrapperWorld& world,
+                                         v8::Local<v8::Context> context,
+                                         const WrapperTypeInfo* type) {
+  CHECK(V8HTMLDocument::wrapperTypeInfo.Equals(type));
+
+  v8::Context::Scope scope(context);
+  v8::Local<v8::Function> interface_object =
+      ConstructPlainType(isolate, world, context, type);
+  CHECK(!interface_object.IsEmpty());
+  v8::Local<v8::Object> instance_template;
+  CHECK(V8ObjectConstructor::NewInstance(isolate, interface_object)
+            .ToLocal(&instance_template));
+  v8::Local<v8::Object> wrapper = instance_template->Clone();
+  wrapper->SetAlignedPointerInInternalField(kV8DOMWrapperTypeIndex,
+                                            const_cast<WrapperTypeInfo*>(type));
+  return wrapper;
+}
+
+int GetSnapshotIndexForWorld(const DOMWrapperWorld& world) {
+  return world.IsMainWorld() ? 0 : 1;
+}
+
+constexpr const WrapperTypeInfo* kSnapshotWrapperTypes[] = {
+    &V8EventTarget::wrapperTypeInfo,  &V8Window::wrapperTypeInfo,
+    &V8Node::wrapperTypeInfo,         &V8Document::wrapperTypeInfo,
+    &V8HTMLDocument::wrapperTypeInfo,
+};
+
+enum class InternalFieldType : uint8_t {
+  kNone,
+  kNodeType,
+  kDocumentType,
+  kHTMLDocumentType,
+  kHTMLDocumentObject,
+};
+
+const WrapperTypeInfo* FieldTypeToWrapperTypeInfo(InternalFieldType type) {
+  switch (type) {
+    case InternalFieldType::kNodeType:
+      return &V8Node::wrapperTypeInfo;
+    case InternalFieldType::kDocumentType:
+      return &V8Document::wrapperTypeInfo;
+    case InternalFieldType::kHTMLDocumentType:
+      return &V8HTMLDocument::wrapperTypeInfo;
+    case InternalFieldType::kHTMLDocumentObject:
+      return &V8HTMLDocument::wrapperTypeInfo;
+    case InternalFieldType::kNone:
+      NOTREACHED();
+      break;
+  }
+  NOTREACHED();
+  return nullptr;
+}
+
+}  // namespace
+
+void V8SnapshotCreator::TakeSnapshotForWorld(v8::SnapshotCreator* creator,
+                                             const DOMWrapperWorld& world) {
+  CHECK(TakingSnapshot());
+  v8::Isolate* isolate = creator->GetIsolate();
+  CHECK_EQ(isolate, v8::Isolate::GetCurrent());
+
+  // Function templates
+  v8::HandleScope handleScope(isolate);
+  Vector<v8::Local<v8::FunctionTemplate>> interface_templates;
+  for (const WrapperTypeInfo* wrapper_type_info : kSnapshotWrapperTypes) {
+    v8::Local<v8::FunctionTemplate> interface_template =
+        wrapper_type_info->domTemplate(isolate, world);
+    CHECK(!interface_template.IsEmpty());
+    interface_templates.push_back(interface_template);
+  }
+
+  // FIXME: Confirm interface_tempaltes[1] is a template of V8Window.
+  v8::Local<v8::ObjectTemplate> window_template =
+      interface_templates[1]->InstanceTemplate();
+  CHECK(!window_template.IsEmpty());
+
+  v8::Local<v8::Context> context;
+  {
+    V8PerIsolateData::UseCounterDisabledScope use_counter_disabled(
+        V8PerIsolateData::From(isolate));
+    context = v8::Context::New(isolate, nullptr, window_template);
+  }
+  CHECK(!context.IsEmpty());
+
+  if (world.IsMainWorld()) {
+    context->Enter();
+    v8::Context::Scope scope(context);
+    v8::Local<v8::Object> document_wrapper = CreatePlainWrapper(
+        isolate, world, context, &V8HTMLDocument::wrapperTypeInfo);
+    int indices[] = {kV8DOMWrapperObjectIndex, kV8DOMWrapperTypeIndex};
+    void* values[] = {nullptr, const_cast<WrapperTypeInfo*>(
+                                   &V8HTMLDocument::wrapperTypeInfo)};
+    document_wrapper->SetAlignedPointerInInternalFields(
+        WTF_ARRAY_LENGTH(indices), indices, values);
+
+    // Update the cached accessor for window.document.
+    CHECK(V8PrivateProperty::GetWindowDocumentCachedAccessor(isolate).Set(
+        context->Global(), document_wrapper));
+    context->Exit();
+  }
+
+  for (auto& interface_template : interface_templates) {
+    creator->AddTemplate(interface_template);
+  }
+  creator->AddContext(context, SerializeInternalField);
+
+  V8PerIsolateData::From(isolate)->ClearPersistents();
+
+  // Snapshot is taken on the main thread, but it can be used on other threads.
+  // So we remove a message handler for the main thread.
+  isolate->RemoveMessageListeners(V8Initializer::MessageHandlerInMainThread);
+}
+
+v8::StartupData V8SnapshotCreator::TakeSnapshot(v8::SnapshotCreator* creator) {
+  v8::Isolate* isolate = creator->GetIsolate();
+  CHECK_EQ(isolate, v8::Isolate::GetCurrent());
+
+  // Disable all runtime enabled featuers
+  RuntimeEnabledFeatures::setStableFeaturesEnabled(false);
+  RuntimeEnabledFeatures::setExperimentalFeaturesEnabled(false);
+  RuntimeEnabledFeatures::setTestFeaturesEnabled(false);
+
+  {
+    v8::HandleScope handleScope(isolate);
+    creator->SetDefaultContext(v8::Context::New(isolate));
+
+    TakeSnapshotForWorld(creator, DOMWrapperWorld::MainWorld());
+    // For non main worlds, we can use any type to create a context.
+    TakeSnapshotForWorld(creator,
+                         *DOMWrapperWorld::Create(
+                             isolate, DOMWrapperWorld::WorldType::kTesting));
+  }
+
+  return creator->CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
+}
+
+void V8SnapshotCreator::EnsureInterfaceTemplates(v8::Isolate* isolate,
+                                                 const DOMWrapperWorld& world) {
+  if (V8PerIsolateData::From(isolate)->GetV8ContextMode() !=
+      gin::IsolateHolder::kUseSnapshot) {
+    return;
+  }
+
+  // TODO(peria): Skip this method if all templates are already created.
+  for (const WrapperTypeInfo* wrapper_type_info : kSnapshotWrapperTypes) {
+    v8::Local<v8::FunctionTemplate> interface =
+        wrapper_type_info->domTemplate(isolate, world);
+    CHECK(!interface.IsEmpty());
+  }
+}
+
+v8::Local<v8::FunctionTemplate> V8SnapshotCreator::CreateInterfaceTemplate(
+    v8::Isolate* isolate,
+    const DOMWrapperWorld& world,
+    WrapperTypeInfo* wrapper_type_info) {
+  if (V8PerIsolateData::From(isolate)->GetV8ContextMode() !=
+      gin::IsolateHolder::kUseSnapshot) {
+    return v8::Local<v8::FunctionTemplate>();
+  }
+
+  const int index_offset =
+      world.IsMainWorld() ? 0 : WTF_ARRAY_LENGTH(kSnapshotWrapperTypes);
+
+  // Snapshotted templates are expected to be used just to get
+  // wrapper_type_info.
+  for (size_t i = 0; i < WTF_ARRAY_LENGTH(kSnapshotWrapperTypes); ++i) {
+    if (kSnapshotWrapperTypes[i]->Equals(wrapper_type_info)) {
+      return v8::FunctionTemplate::FromSnapshot(isolate, index_offset + i)
+          .ToLocalChecked();
+    }
+  }
+  return v8::Local<v8::FunctionTemplate>();
+}
+
+v8::SnapshotCreator* V8SnapshotCreator::GetSnapshotCreator() {
+  CHECK(TakingSnapshot());
+  return V8PerIsolateData::From(V8PerIsolateData::MainThreadIsolate())
+      ->GetSnapshotCreator();
+}
+
+bool V8SnapshotCreator::TakingSnapshot() {
+  // CHECK(IsMainThread());
+  return g_taking_snapshot;
+}
+
+void V8SnapshotCreator::SetTakingSnapshot(bool value) {
+  // CHECK(IsMainThread());
+  g_taking_snapshot = value;
+}
+
+v8::StartupData V8SnapshotCreator::SerializeInternalField(
+    v8::Local<v8::Object> holder,
+    int index,
+    void* /*data*/) {
+  InternalFieldType field_type = InternalFieldType::kNone;
+  const WrapperTypeInfo* wrapper_type = ToWrapperTypeInfo(holder);
+  if (kV8DOMWrapperObjectIndex == index) {
+    if (blink::V8HTMLDocument::wrapperTypeInfo.Equals(wrapper_type)) {
+      field_type = InternalFieldType::kHTMLDocumentObject;
+    }
+  } else if (kV8DOMWrapperTypeIndex == index) {
+    if (blink::V8HTMLDocument::wrapperTypeInfo.Equals(wrapper_type)) {
+      field_type = InternalFieldType::kHTMLDocumentType;
+    } else if (blink::V8Document::wrapperTypeInfo.Equals(wrapper_type)) {
+      field_type = InternalFieldType::kDocumentType;
+    } else if (blink::V8Node::wrapperTypeInfo.Equals(wrapper_type)) {
+      field_type = InternalFieldType::kNodeType;
+    }
+  }
+
+  // To confirm covering all patterns to be serialized.
+  CHECK_NE(field_type, InternalFieldType::kNone);
+
+  int size = sizeof(InternalFieldType);
+  char* data = new char[size];
+  std::memcpy(data, &field_type, size);
+
+  return {data, size};
+}
+
+void V8SnapshotCreator::DeserializeInternalField(v8::Local<v8::Object> wrapper,
+                                                 int index,
+                                                 v8::StartupData payload,
+                                                 void* ptr) {
+  CHECK_EQ(payload.raw_size, static_cast<int>(sizeof(InternalFieldType)));
+  InternalFieldType type =
+      *reinterpret_cast<const InternalFieldType*>(payload.data);
+
+  const WrapperTypeInfo* wrapper_type_info = FieldTypeToWrapperTypeInfo(type);
+  switch (type) {
+    case InternalFieldType::kNodeType:
+    case InternalFieldType::kDocumentType:
+    case InternalFieldType::kHTMLDocumentType: {
+      CHECK_EQ(index, kV8DOMWrapperTypeIndex);
+      wrapper->SetAlignedPointerInInternalField(
+          index, const_cast<WrapperTypeInfo*>(wrapper_type_info));
+      wrapper_type_info->WrapperCreated();
+      return;
+    }
+    case InternalFieldType::kHTMLDocumentObject: {
+      CHECK_EQ(index, kV8DOMWrapperObjectIndex);
+      v8::Isolate* isolate = v8::Isolate::GetCurrent();
+      DataForDeserializer* data = static_cast<DataForDeserializer*>(ptr);
+      ScriptWrappable* document = data->document;
+
+      // Make reference from wrapper to document
+      wrapper->SetAlignedPointerInInternalField(index, document);
+      // Make reference from document to wrapper
+      CHECK(document->SetWrapper(isolate, wrapper_type_info, wrapper));
+      return;
+    }
+    case InternalFieldType::kNone:
+      NOTREACHED();
+      return;
+  }
+
+  NOTREACHED();
+}
+
+v8::Local<v8::Context> V8SnapshotCreator::CreateContext(
+    v8::Isolate* isolate,
+    const DOMWrapperWorld& world,
+    v8::ExtensionConfiguration* extension_configuration,
+    v8::Local<v8::Object> global_proxy,
+    Document* document) {
+  if (V8PerIsolateData::From(isolate)->GetV8ContextMode() !=
+      gin::IsolateHolder::kUseSnapshot) {
+    return v8::Local<v8::Context>();
+  }
+  if (world.IsMainWorld() && !(document && document->IsHTMLDocument())) {
+    return v8::Local<v8::Context>();
+  }
+
+  v8::Local<v8::Context> context;
+  const int index = GetSnapshotIndexForWorld(world);
+  DataForDeserializer data{document};
+  CHECK(v8::Context::FromSnapshot(isolate, index,
+                                  v8::DeserializeInternalFieldsCallback(
+                                      &DeserializeInternalField, &data),
+                                  extension_configuration, global_proxy)
+            .ToLocal(&context));
+
+  return context;
+}
+
+void V8SnapshotCreator::InstallRuntimeEnabledFeaturesOnDocument(
+    ScriptState* script_state,
+    v8::Local<v8::Object> wrapper) {
+  v8::Isolate* isolate = script_state->GetIsolate();
+  if (V8PerIsolateData::From(isolate)->GetV8ContextMode() !=
+      gin::IsolateHolder::kUseSnapshot) {
+    return;
+  }
+
+  v8::Local<v8::Context> context = script_state->GetContext();
+  DOMWrapperWorld& world = script_state->World();
+
+  v8::Local<v8::Object> htmldocument_prototype =
+      wrapper->GetPrototype().As<v8::Object>();
+  v8::Local<v8::Function> htmldocument_interface =
+      V8HTMLDocument::domTemplate(isolate, world)->GetFunction();
+  V8HTMLDocument::installRuntimeEnabledFeatures(
+      isolate, world, wrapper, htmldocument_prototype, htmldocument_interface);
+
+  v8::Local<v8::Object> document_prototype =
+      htmldocument_prototype->GetPrototype().As<v8::Object>();
+  v8::Local<v8::Function> document_interface =
+      V8Document::domTemplate(isolate, world)->GetFunction();
+  V8Document::installRuntimeEnabledFeatures(
+      isolate, world, wrapper, document_prototype, document_interface);
+
+  V8Document::preparePrototypeAndInterfaceObject(
+      context, world, document_prototype, document_interface,
+      v8::Local<v8::FunctionTemplate>());
+}
+
+void V8SnapshotCreator::InstallRuntimeEnabledFeaturesOnGlobal(
+    ScriptState* script_state,
+    v8::Local<v8::Object> global) {
+  v8::Isolate* isolate = script_state->GetIsolate();
+  if (V8PerIsolateData::From(isolate)->GetV8ContextMode() !=
+      gin::IsolateHolder::kUseSnapshot) {
+    return;
+  }
+
+  DOMWrapperWorld& world = script_state->World();
+
+  v8::Local<v8::Object> window_prototype =
+      global->GetPrototype().As<v8::Object>();
+  v8::Local<v8::Function> window_interface =
+      V8Window::domTemplate(isolate, world)->GetFunction();
+  V8Window::installV8WindowRuntimeEnabledFunction(
+      isolate, world, global, window_prototype, window_interface);
+}
+
+void V8SnapshotCreator::SetReferenceTable(intptr_t* table) {
+  g_snapshot_reference_table = table;
+}
+
+intptr_t* V8SnapshotCreator::GetReferenceTable() {
+  return g_snapshot_reference_table;
+}
+
+}  // namespace blink