[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/V8SnapshotUtil.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 59 matching lines @@
   v8::AccessorNameGetterCallback getter = config.getter;
   v8::AccessorNameSetterCallback setter = config.setter;
   v8::Local<v8::Value> data =
       v8::External::New(isolate, const_cast<WrapperTypeInfo*>(config.data));
   v8::PropertyAttribute attribute =
       static_cast<v8::PropertyAttribute>(config.attribute);
   unsigned location = config.property_location_configuration;
 
   DCHECK(location);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  if (location & V8DOMConfiguration::kOnInstance) {
+  if (location & V8DOMConfiguration::kOnInstance && !instance.IsEmpty()) {
     instance
         ->SetNativeDataProperty(context, name, getter, setter, data, attribute)
         .ToChecked();
   }
-  if (location & V8DOMConfiguration::kOnPrototype) {
+  if (location & V8DOMConfiguration::kOnPrototype && !prototype.IsEmpty()) {
     prototype
         ->SetNativeDataProperty(context, name, getter, setter, data, attribute)
         .ToChecked();
   }
   if (location & V8DOMConfiguration::kOnInterface)
     NOTREACHED();
 }
 
 void InstallLazyDataAttributeInternal(
     v8::Isolate* isolate,
@@ skipping 108 matching lines @@
 
   // Support [LenientThis] by not specifying the signature.  V8 does not do
   // the type checking against holder if no signature is specified.  Note that
   // info.Holder() passed to callbacks will be *unsafe*.
   if (accessor.holder_check_configuration ==
       V8DOMConfiguration::kDoNotCheckHolder)
     signature = v8::Local<v8::Signature>();
   v8::Local<v8::Value> data =
       v8::External::New(isolate, const_cast<WrapperTypeInfo*>(accessor.data));
 
-  DCHECK(accessor.property_location_configuration);
-  if (accessor.property_location_configuration &
+  const unsigned location = accessor.property_location_configuration;
+  DCHECK(location);
+  if (location &
       (V8DOMConfiguration::kOnInstance | V8DOMConfiguration::kOnPrototype)) {
     v8::Local<FunctionOrTemplate> getter =
         CreateAccessorFunctionOrTemplate<FunctionOrTemplate>(
             isolate, getter_callback, cached_property_key, data, signature, 0);
     v8::Local<FunctionOrTemplate> setter =
         CreateAccessorFunctionOrTemplate<FunctionOrTemplate>(
             isolate, setter_callback, nullptr, data, signature, 1);
-    if (accessor.property_location_configuration &
-        V8DOMConfiguration::kOnInstance) {
+    if (location & V8DOMConfiguration::kOnInstance &&
+        !instance_or_template.IsEmpty()) {
       instance_or_template->SetAccessorProperty(
           name, getter, setter,
           static_cast<v8::PropertyAttribute>(accessor.attribute));
     }
-    if (accessor.property_location_configuration &
-        V8DOMConfiguration::kOnPrototype) {
+    if (location & V8DOMConfiguration::kOnPrototype &&
+        !prototype_or_template.IsEmpty()) {
       prototype_or_template->SetAccessorProperty(
           name, getter, setter,
           static_cast<v8::PropertyAttribute>(accessor.attribute));
     }
   }
-  if (accessor.property_location_configuration &
-      V8DOMConfiguration::kOnInterface) {
+  if (location & V8DOMConfiguration::kOnInterface &&
+      !interface_or_template.IsEmpty()) {
     // Attributes installed on the interface object must be static
     // attributes, so no need to specify a signature, i.e. no need to do
     // type check against a holder.
     v8::Local<FunctionOrTemplate> getter =
         CreateAccessorFunctionOrTemplate<FunctionOrTemplate>(
             isolate, getter_callback, nullptr, data, v8::Local<v8::Signature>(),
             0);
     v8::Local<FunctionOrTemplate> setter =
         CreateAccessorFunctionOrTemplate<FunctionOrTemplate>(
             isolate, setter_callback, nullptr, data, v8::Local<v8::Signature>(),
@@ skipping 152 matching lines @@
   v8::FunctionCallback callback = method.callback;
   // Promise-returning functions need to return a reject promise when
   // an exception occurs.  This includes a case that the receiver object is not
   // of the type.  So, we disable the type check of the receiver object on V8
   // side so that V8 won't throw.  Instead, we do the check on Blink side and
   // convert an exception to a reject promise.
   if (method.holder_check_configuration ==
       V8DOMConfiguration::kDoNotCheckHolder)
     signature = v8::Local<v8::Signature>();
 
-  DCHECK(method.property_location_configuration);
-  if (method.property_location_configuration &
+  const unsigned location = method.property_location_configuration;
+  DCHECK(location);
+  if (location &
       (V8DOMConfiguration::kOnInstance | V8DOMConfiguration::kOnPrototype)) {
     v8::Local<v8::FunctionTemplate> function_template =
         v8::FunctionTemplate::New(isolate, callback, v8::Local<v8::Value>(),
                                   signature, method.length);
     function_template->RemovePrototype();
     if (method.access_check_configuration == V8DOMConfiguration::kCheckAccess)
       function_template->SetAcceptAnyReceiver(false);
     v8::Local<v8::Function> function =
         function_template->GetFunction(isolate->GetCurrentContext())
             .ToLocalChecked();
-    if (method.property_location_configuration &
-        V8DOMConfiguration::kOnInstance)
+    if (location & V8DOMConfiguration::kOnInstance && !instance.IsEmpty()) {
       instance
           ->DefineOwnProperty(
               isolate->GetCurrentContext(), name, function,
               static_cast<v8::PropertyAttribute>(method.attribute))
           .ToChecked();
-    if (method.property_location_configuration &
-        V8DOMConfiguration::kOnPrototype)
+    }
+    if (location & V8DOMConfiguration::kOnPrototype && !prototype.IsEmpty()) {
       prototype
           ->DefineOwnProperty(
               isolate->GetCurrentContext(), name, function,
               static_cast<v8::PropertyAttribute>(method.attribute))
           .ToChecked();
+    }
   }
-  if (method.property_location_configuration &
-      V8DOMConfiguration::kOnInterface) {
+  if (location & V8DOMConfiguration::kOnInterface && !interface.IsEmpty()) {
     // Operations installed on the interface object must be static
     // operations, so no need to specify a signature, i.e. no need to do
     // type check against a holder.
     v8::Local<v8::FunctionTemplate> function_template =
         v8::FunctionTemplate::New(isolate, callback, v8::Local<v8::Value>(),
                                   v8::Local<v8::Signature>(), method.length);
     function_template->RemovePrototype();
     v8::Local<v8::Function> function =
         function_template->GetFunction(isolate->GetCurrentContext())
             .ToLocalChecked();
@@ skipping 244 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;
+  interface_template = V8SnapshotUtil::InterfaceTemplateFromSnapshot(

[Yuki, 2017/06/20 14:20:11]

Do we really need this code?
V8SnapshotUtil::EnsureInterfaceTemplates() registers all interfaces in the
snapshot, then we shouldn't need this.  You can EnsureInterfaceTemplates for
both of main and non-main world.

[peria, 2017/06/21 07:19:16]

Done.

+      isolate, world, wrapper_type_info);
+
+  if (interface_template.IsEmpty()) {
+    interface_template = v8::FunctionTemplate::New(
+        isolate, V8ObjectConstructor::IsValidConstructorMode);
+    configure_dom_class_template(isolate, world, interface_template);
+  }
+  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