[Bindings] Create and use V8 context snapshots

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

+#include "bindings/core/v8/V8SnapshotCreator.h"

[Yuki, 2017/05/12 15:20:10]

Copyright?

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

Done.

+
+#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.h>

[Yuki, 2017/05/12 15:20:10]

s|<v8.h>|"v8/include/v8.h"|

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

Done.

+
+namespace blink {
+
+namespace {
+
+bool g_taking_snapshot = false;

[Yuki, 2017/05/15 09:37:29]

Put a comment when this is true and what is guaranteed or constrained.

For example, this must be used only on the main thread.

The name looks like that it will be true only during taking a snapshot, but
actually seems like that it's true when the process is invoked in the mode to
take a snapshot.  It's ambiguous whether you're controlling timing of taking a
snapshot or controlling a mode of a process.

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

Done.

+
+// NOTE(peria): This method is almost a copy of
+// V8PerContext::CreateWrapperFromCacheSlowCase().
+v8::Local<v8::Function> ConstructPlainType(v8::Isolate* isolate,

[Yuki, 2017/05/15 09:37:29]

Let's merge this code into V8PerContextData::ConstructorForTypeSlowCase().
Let's create a common implementation function that is used by both of taking and
using a snapshot, and on the top of it, let's create two thin wrappers dedicated
to taking and using a snapshot.

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

Acknowledged.

+                                           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().
+v8::Local<v8::Object> CreatePlainWrapper(v8::Isolate* isolate,

[Yuki, 2017/05/15 09:37:29]

Ditto.

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

Acknowledged.

+                                         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;
+}
+
+}  // namespace
+
+void V8SnapshotCreator::TakeSnapshot(v8::SnapshotCreator* creator,
+                                     int world_id) {
+  DCHECK(g_taking_snapshot);
+  v8::Isolate* isolate = creator->GetIsolate();
+  CHECK_EQ(isolate, v8::Isolate::GetCurrent());
+
+  RefPtr<DOMWrapperWorld> world_ptr;
+  if (world_id == 0) {
+    world_ptr = &DOMWrapperWorld::MainWorld();
+  } else {
+    world_ptr = DOMWrapperWorld::EnsureIsolatedWorld(isolate, world_id);
+  }
+  const DOMWrapperWorld& world = *world_ptr;
+
+  // Function templates
+  v8::HandleScope handleScope(isolate);
+  v8::Local<v8::FunctionTemplate> event_target_function_template =

[Yuki, 2017/05/15 09:37:29]

nit: We could have an array of WrapperTypeInfo or V8T::domTemplate, and we could
write a single for-loop (at least except for HTMLDocument and Window).

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

Done.

+      V8EventTarget::domTemplate(isolate, world);
+  CHECK(!event_target_function_template.IsEmpty());
+
+  v8::Local<v8::FunctionTemplate> window_function_template =
+      V8Window::domTemplate(isolate, world);
+  CHECK(!window_function_template.IsEmpty());
+
+  v8::Local<v8::FunctionTemplate> node_function_template =
+      V8Node::domTemplate(isolate, world);
+  CHECK(!node_function_template.IsEmpty());
+
+  v8::Local<v8::FunctionTemplate> document_function_template =
+      V8Document::domTemplate(isolate, world);
+  CHECK(!document_function_template.IsEmpty());
+
+  v8::Local<v8::FunctionTemplate> html_document_function_template =
+      V8HTMLDocument::domTemplate(isolate, world);
+  CHECK(!html_document_function_template.IsEmpty());
+
+  v8::Local<v8::ObjectTemplate> window_template =
+      window_function_template->InstanceTemplate();
+  CHECK(!window_template.IsEmpty());
+
+  v8::Local<v8::Context> context;
+  v8::Local<v8::Object> wrapper;
+  {
+    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);
+    wrapper = CreatePlainWrapper(isolate, world, context,
+                                 &V8HTMLDocument::wrapperTypeInfo);
+    CHECK(!wrapper.IsEmpty());
+    int indices[] = {kV8DOMWrapperObjectIndex, kV8DOMWrapperTypeIndex};
+    void* values[] = {nullptr, const_cast<WrapperTypeInfo*>(
+                                   &V8HTMLDocument::wrapperTypeInfo)};
+    wrapper->SetAlignedPointerInInternalFields(WTF_ARRAY_LENGTH(indices),
+                                               indices, values);
+
+    V8PrivateProperty::Symbol symbol =
+        V8PrivateProperty::GetWindowDocumentCachedAccessor(isolate);
+    CHECK(V8CallBoolean(
+        context->Global()->SetPrivate(context, symbol.GetPrivate(), wrapper)));
+    context->Exit();
+  }
+
+  creator->AddTemplate(event_target_function_template);
+  creator->AddTemplate(window_function_template);
+  creator->AddTemplate(node_function_template);
+  creator->AddTemplate(document_function_template);
+  creator->AddTemplate(html_document_function_template);
+  creator->AddContext(context, Serialize);
+
+  V8PerIsolateData::From(isolate)->ClearAll();
+  isolate->RemoveMessageListeners(V8Initializer::MessageHandlerInMainThread);

[Yuki, 2017/05/15 09:37:29]

Please comment why we need to remove message listeners.

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

Done.

+}
+
+v8::StartupData V8SnapshotCreator::SetUpSnapshotCreator(
+    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);

[Yuki, 2017/05/15 09:37:29]

Is there any good way to confirm that we've not yet created any function
template before disabling runtime-enabled features?

[Yuki, 2017/05/15 09:37:29]

nit: We might want to define
RuntimeEnabledFeatures::setAllFeaturesEnabled(false);

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

Acknowledged.

[peria, 2017/06/20 10:20:13]

Acknowledged.

+
+  {
+    v8::HandleScope handleScope(isolate);
+    creator->SetDefaultContext(v8::Context::New(isolate));
+
+    TakeSnapshot(creator, 0);  // main world
+    TakeSnapshot(creator, 1);  // non main world

[Yuki, 2017/05/15 09:37:29]

I'm not happy with use of the magic numbers.  Shall we define an enum?

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

Done.

+  }
+
+  return creator->CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
+}
+
+v8::SnapshotCreator* V8SnapshotCreator::GetSnapshotCreator() {
+  DCHECK(g_taking_snapshot);

[Yuki, 2017/05/15 09:37:29]

Add a DCHECK to confirm that it's the main thread.

Maybe, all the member functions are expected to be used only on the main thread?
 Then, we'd like to have the DCHECK here and there.

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

Acknowledged.

+  return V8PerIsolateData::From(V8PerIsolateData::MainThreadIsolate())
+      ->GetSnapshotCreator();
+}
+
+bool V8SnapshotCreator::TakingSnapshot() {
+  return g_taking_snapshot;

[Yuki, 2017/05/15 09:37:29]

Add a DCHECK to confirm that it's the main thread.
Otherwise, racy.

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

Acknowledged.

+}
+
+void V8SnapshotCreator::SetTakingSnapshot(bool value) {
+  g_taking_snapshot = value;
+}
+
+v8::StartupData V8SnapshotCreator::Serialize(v8::Local<v8::Object> holder,

[Yuki, 2017/05/15 09:37:29]

s/Serialize/Serialize(An)InternalField/
Let's make it clear what this function serializes.

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

Done.

+                                             int index,
+                                             void* /*data*/) {
+  FieldType field_type = kNone;
+  const WrapperTypeInfo* wrapper_type = ToWrapperTypeInfo(holder);
+  if (blink::V8HTMLDocument::wrapperTypeInfo.Equals(wrapper_type)) {
+    if (kV8DOMWrapperObjectIndex == index) {
+      field_type = kHTMLDocumentObject;
+    } else if (kV8DOMWrapperTypeIndex == index) {
+      field_type = kHTMLDocumentType;
+    }
+  } else if (blink::V8Document::wrapperTypeInfo.Equals(wrapper_type) &&
+             kV8DOMWrapperTypeIndex == index) {
+    field_type = kDocumentType;
+  } else if (blink::V8Node::wrapperTypeInfo.Equals(wrapper_type) &&
+             kV8DOMWrapperTypeIndex == index) {
+    field_type = kNodeType;
+  }
+
+  // To confirm covering all patterns to be serialized.
+  CHECK_NE(field_type, kNone);
+
+  int size = sizeof(FieldType);
+  char* data = new char[size];
+  std::memcpy(data, &field_type, size);
+
+  return {data, size};
+}
+
+}  // namespace blink