First implementation of lazily cached accessor for DOM attributes.

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 139 matching lines @@
   if (attribute.property_location_configuration &
       V8DOMConfiguration::kOnInterface)
     NOTREACHED();
 }
 
 template <class FunctionOrTemplate>
 v8::Local<FunctionOrTemplate> CreateAccessorFunctionOrTemplate(
     v8::Isolate*,
     v8::FunctionCallback,
     V8DOMConfiguration::CachedPropertyKey,
+    V8DOMConfiguration::CachedAccessorInitCallback,
     v8::Local<v8::Value> data,
     v8::Local<v8::Signature>,
     int length);
 
 template <>
 v8::Local<v8::FunctionTemplate>
 CreateAccessorFunctionOrTemplate<v8::FunctionTemplate>(
     v8::Isolate* isolate,
     v8::FunctionCallback callback,
     V8DOMConfiguration::CachedPropertyKey cached_property_key,
+    V8DOMConfiguration::CachedAccessorInitCallback
+        cached_accessor_init_callback,
     v8::Local<v8::Value> data,
     v8::Local<v8::Signature> signature,
     int length) {
   v8::Local<v8::FunctionTemplate> function_template;
   if (callback) {
     if (cached_property_key) {
-      function_template = v8::FunctionTemplate::NewWithCache(
-          isolate, callback, cached_property_key(isolate), data, signature,
-          length);
+      if (cached_accessor_init_callback) {
+        function_template = v8::FunctionTemplate::NewWithLazyCache(
+            isolate, callback, cached_property_key(isolate),
+            cached_accessor_init_callback, data, signature, length);
+      } else {
+        function_template = v8::FunctionTemplate::NewWithCache(
+            isolate, callback, cached_property_key(isolate), data, signature,
+            length);
+      }
     } else {
       function_template =
           v8::FunctionTemplate::New(isolate, callback, data, signature, length);
     }
 
     if (!function_template.IsEmpty()) {
       function_template->RemovePrototype();
       function_template->SetAcceptAnyReceiver(false);
     }
   }
   return function_template;
 }
 
 template <>
 v8::Local<v8::Function> CreateAccessorFunctionOrTemplate<v8::Function>(
     v8::Isolate* isolate,
     v8::FunctionCallback callback,
     V8DOMConfiguration::CachedPropertyKey,
+    V8DOMConfiguration::CachedAccessorInitCallback,
     v8::Local<v8::Value> data,
     v8::Local<v8::Signature> signature,
     int length) {
   if (!callback)
     return v8::Local<v8::Function>();
 
   v8::Local<v8::FunctionTemplate> function_template =
       CreateAccessorFunctionOrTemplate<v8::FunctionTemplate>(
-          isolate, callback, nullptr, data, signature, length);
+          isolate, callback, nullptr, nullptr, data, signature, length);
   if (function_template.IsEmpty())
     return v8::Local<v8::Function>();
 
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Function> function;
   if (!function_template->GetFunction(context).ToLocal(&function))
     return v8::Local<v8::Function>();
   return function;
 }
 
 template <class ObjectOrTemplate, class FunctionOrTemplate>
 void InstallAccessorInternal(
     v8::Isolate* isolate,
     v8::Local<ObjectOrTemplate> instance_or_template,
     v8::Local<ObjectOrTemplate> prototype_or_template,
     v8::Local<FunctionOrTemplate> interface_or_template,
     v8::Local<v8::Signature> signature,
     const V8DOMConfiguration::AccessorConfiguration& accessor,
     const DOMWrapperWorld& world) {
   if (!WorldConfigurationApplies(accessor, world))
     return;
   v8::Local<v8::Name> name = V8AtomicString(isolate, accessor.name);
   v8::FunctionCallback getter_callback = accessor.getter;
   v8::FunctionCallback setter_callback = accessor.setter;
   V8DOMConfiguration::CachedPropertyKey cached_property_key = nullptr;
+  V8DOMConfiguration::CachedAccessorInitCallback cached_accessor_init_callback =
+      nullptr;
   if (world.IsMainWorld()) {
     cached_property_key = accessor.cached_property_key;
+    cached_accessor_init_callback = accessor.cached_accessor_init_callback;
   }
 
   // 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 &
       (V8DOMConfiguration::kOnInstance | V8DOMConfiguration::kOnPrototype)) {
     v8::Local<FunctionOrTemplate> getter =
         CreateAccessorFunctionOrTemplate<FunctionOrTemplate>(
-            isolate, getter_callback, cached_property_key, data, signature, 0);
+            isolate, getter_callback, cached_property_key,
+            cached_accessor_init_callback, data, signature, 0);
     v8::Local<FunctionOrTemplate> setter =
         CreateAccessorFunctionOrTemplate<FunctionOrTemplate>(
-            isolate, setter_callback, nullptr, data, signature, 1);
+            isolate, setter_callback, nullptr, nullptr, data, signature, 1);
     if (accessor.property_location_configuration &
         V8DOMConfiguration::kOnInstance) {
       instance_or_template->SetAccessorProperty(
           name, getter, setter,
           static_cast<v8::PropertyAttribute>(accessor.attribute));
     }
     if (accessor.property_location_configuration &
         V8DOMConfiguration::kOnPrototype) {
       prototype_or_template->SetAccessorProperty(
           name, getter, setter,
           static_cast<v8::PropertyAttribute>(accessor.attribute));
     }
   }
   if (accessor.property_location_configuration &
       V8DOMConfiguration::kOnInterface) {
     // 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);
+            isolate, getter_callback, nullptr, nullptr, data,
+            v8::Local<v8::Signature>(), 0);
     v8::Local<FunctionOrTemplate> setter =
         CreateAccessorFunctionOrTemplate<FunctionOrTemplate>(
-            isolate, setter_callback, nullptr, data, v8::Local<v8::Signature>(),
-            1);
+            isolate, setter_callback, nullptr, nullptr, data,
+            v8::Local<v8::Signature>(), 1);
     interface_or_template->SetAccessorProperty(
         name, getter, setter,
         static_cast<v8::PropertyAttribute>(accessor.attribute));
   }
 }
 
 v8::Local<v8::Primitive> ValueForConstant(
     v8::Isolate* isolate,
     const V8DOMConfiguration::ConstantConfiguration& constant) {
   v8::Local<v8::Primitive> value;
@@ skipping 405 matching lines @@
     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