[Bindings] Create and use V8 context snapshots

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

 /*
  * Copyright (C) 2012 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
@@ skipping 10 matching lines @@
  * 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 "bindings/core/v8/V8DOMConfiguration.h"
 
+#include "bindings/core/v8/V8Document.h"
+#include "bindings/core/v8/V8EventTarget.h"
+#include "bindings/core/v8/V8HTMLDocument.h"
+#include "bindings/core/v8/V8Node.h"
+#include "bindings/core/v8/V8SnapshotCreator.h"
+#include "bindings/core/v8/V8Window.h"
 #include "platform/bindings/V8ObjectConstructor.h"
 #include "platform/bindings/V8PerContextData.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 
 namespace blink {
 
 namespace {
 
 template <class Configuration>
 bool WorldConfigurationApplies(const Configuration& config,
@@ skipping 630 matching lines @@
     prototype_template->SetInternalFieldCount(kV8PrototypeInternalFieldcount);
   }
 }
 
 v8::Local<v8::FunctionTemplate> V8DOMConfiguration::DomClassTemplate(
     v8::Isolate* isolate,
     const DOMWrapperWorld& world,
     WrapperTypeInfo* wrapper_type_info,
     InstallTemplateFunction configure_dom_class_template) {
   V8PerIsolateData* data = V8PerIsolateData::From(isolate);
-  v8::Local<v8::FunctionTemplate> result =
+  v8::Local<v8::FunctionTemplate> interface_template =
       data->FindInterfaceTemplate(world, wrapper_type_info);
-  if (!result.IsEmpty())
-    return result;
+  if (!interface_template.IsEmpty())
+    return interface_template;
 
-  result = v8::FunctionTemplate::New(
-      isolate, V8ObjectConstructor::IsValidConstructorMode);
-  configure_dom_class_template(isolate, world, result);
-  data->SetInterfaceTemplate(world, wrapper_type_info, result);
-  return result;
+  if (V8SnapshotCreator::TakingSnapshot()) {

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

Curious.  Why V8SnapshotCreator::TakingSnapshot() is a static member while
data->UseSnapshot() is a non-static member?  A little asymmetric.

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

Acknowledged.

+    interface_template =
+        data->FindInterfaceTemplateTemp(world, wrapper_type_info);

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

I think it's better not to expose FindInterfaceTemplateTemp.  It's better to
make this hidden in V8PerIsolateData.

V8PerIsolateData::FindInterfaceTemplate(...) {
  if (V8SnapshotCreator::TakingSnapshot()) {
    return ...new code...;
  } else {
    return ...old code...;
  }
}

Ditto for SetInterfaceTemplate.

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

Done.

+    if (!interface_template.IsEmpty())
+      return interface_template;
+  } else if (data->UseSnapshot()) {
+    static const WrapperTypeInfo* snapshot_types[] = {

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

These things should be hidden in V8SnapshotCreator.

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

Done.

+        &V8EventTarget::wrapperTypeInfo,  &V8Window::wrapperTypeInfo,
+        &V8Node::wrapperTypeInfo,         &V8Document::wrapperTypeInfo,
+        &V8HTMLDocument::wrapperTypeInfo,
+    };
+    const int index_offset =
+        world.IsMainWorld() ? 0 : WTF_ARRAY_LENGTH(snapshot_types);
+
+    // Snapshotted templates are expected to be used just to get
+    // wrapper_type_info.
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(snapshot_types); ++i) {

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

nit: I think you can use range-based for-loop.
for (const auto& wrapper_type_info : snapshotted_types)

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

no. this routine requires the index number.

+      if (snapshot_types[i]->Equals(wrapper_type_info)) {
+        if (v8::FunctionTemplate::FromSnapshot(isolate, index_offset + i)
+                .ToLocal(&interface_template)) {

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

nit: ToLocalChecked()?

Or are we really going to support a fallback mechanism, seriously?

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

Done.

+        }
+        break;
+      }
+    }
+  }
+
+  if (interface_template.IsEmpty()) {
+    interface_template = v8::FunctionTemplate::New(
+        isolate, V8ObjectConstructor::IsValidConstructorMode);
+    configure_dom_class_template(isolate, world, interface_template);
+  }
+  CHECK(!interface_template.IsEmpty());
+
+  if (V8SnapshotCreator::TakingSnapshot()) {
+    data->SetInterfaceTemplateTemp(world, wrapper_type_info,
+                                   interface_template);
+  } else {
+    data->SetInterfaceTemplate(world, wrapper_type_info, interface_template);
+  }
+
+  return interface_template;
 }
 
 void V8DOMConfiguration::SetClassString(
     v8::Isolate* isolate,
     v8::Local<v8::ObjectTemplate> object_template,
     const char* class_string) {
   object_template->Set(
       v8::Symbol::GetToStringTag(isolate),
       V8AtomicString(isolate, class_string),
       static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 }
 
 }  // namespace blink