IDL: Add support for [Unscopeable] on attributes and methods

Source/bindings/templates/interface.cpp

 {% extends 'interface_base.cpp' %}
 
 
 {##############################################################################}
 {% block indexed_property_getter %}
 {% if indexed_property_getter and not indexed_property_getter.is_custom %}
 {% set getter = indexed_property_getter %}
 static void indexedPropertyGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     {{cpp_class}}* impl = {{v8_class}}::toImpl(info.Holder());
@@ skipping 456 matching lines @@
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block named_constructor %}
 {% from 'methods.cpp' import generate_constructor with context %}
 {% if named_constructor %}
 {% set to_active_dom_object = '%s::toActiveDOMObject' % v8_class
                               if is_active_dom_object else '0' %}
-const WrapperTypeInfo {{v8_class}}Constructor::wrapperTypeInfo = { gin::kEmbedderBlink, {{v8_class}}Constructor::domTemplate, {{v8_class}}::refObject, {{v8_class}}::derefObject, {{v8_class}}::trace, {{to_active_dom_object}}, 0, {{v8_class}}::installConditionallyEnabledMethods, {{v8_class}}::installConditionallyEnabledProperties, "{{interface_name}}", 0, WrapperTypeInfo::WrapperTypeObjectPrototype, WrapperTypeInfo::{{wrapper_class_id}}, WrapperTypeInfo::{{event_target_inheritance}}, WrapperTypeInfo::{{lifetime}}, WrapperTypeInfo::{{gc_type}} };
+const WrapperTypeInfo {{v8_class}}Constructor::wrapperTypeInfo = { gin::kEmbedderBlink, {{v8_class}}Constructor::domTemplate, {{v8_class}}::refObject, {{v8_class}}::derefObject, {{v8_class}}::trace, {{to_active_dom_object}}, 0, {{v8_class}}::preparePrototypeObject, {{v8_class}}::installConditionallyEnabledProperties, "{{interface_name}}", 0, WrapperTypeInfo::WrapperTypeObjectPrototype, WrapperTypeInfo::{{wrapper_class_id}}, WrapperTypeInfo::{{event_target_inheritance}}, WrapperTypeInfo::{{lifetime}}, WrapperTypeInfo::{{gc_type}} };
 
 {{generate_constructor(named_constructor)}}
 v8::Local<v8::FunctionTemplate> {{v8_class}}Constructor::domTemplate(v8::Isolate* isolate)
 {
     static int domTemplateKey; // This address is used for a key to look up the dom template.
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     v8::Local<v8::FunctionTemplate> result = data->existingDOMTemplate(&domTemplateKey);
     if (!result.IsEmpty())
         return result;
 
@@ skipping 431 matching lines @@
     {% endfilter %}
     {% endfilter %}
     {% endfor %}
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
+{% block prepare_prototype_object %}
+{% from 'methods.cpp' import install_conditionally_enabled_methods with context %}

[haraken, 2015/04/22 10:54:51]

install_conditionally_enabled_methods => prepare_prototype_object

[Jens Widell, 2015/04/22 13:04:51]

My thinking here is that the macro imported from methods.cpp really is (still)
dealing with specifically conditionally enabled methods. This block here
combines it with other things. Hence not changing the name.

But if you prefer renaming the macro (which isn't wrong; that is the
method-specific preparation of the prototype object) I'll happily change it.

[haraken, 2015/04/22 13:10:32]

Makes sense, let's keep it. (Alternately I want to remove [PerContextEnabled]
and install_conditionally_enabled_methods.)

[Jens Widell, 2015/04/22 14:22:10]

Yes, it would certainly be great to eliminate [PerContextEnabled]. But not in
this CL, I think. :-)

+{% if unscopeables or conditionally_enabled_methods %}
+void {{v8_class}}::preparePrototypeObject(v8::Isolate* isolate, v8::Local<v8::Object> prototypeObject)
+{
+{% if unscopeables %}
+    {{install_unscopeables() | indent}}
+{% endif %}
+{% if conditionally_enabled_methods %}

[haraken, 2015/04/22 10:54:51]

Once we remove [PerContextEnabled], can we remove this branch completely?

[Jens Widell, 2015/04/22 13:04:51]

Yes, I imagine we could do that then.

+    {{install_conditionally_enabled_methods() | indent}}
+{% endif %}
+}
+
+{% endif %}
+{% endblock %}
+
+
+{##############################################################################}
+{% macro install_unscopeables() %}
+v8::Local<v8::Context> v8Context(prototypeObject->CreationContext());
+v8::Local<v8::Name> unscopablesSymbol(v8::Symbol::GetUnscopables(isolate));
+{% if is_partial %}

[haraken, 2015/04/22 10:54:51]

Why do we need a different logic between partial and non-partial?

[Jens Widell, 2015/04/22 13:04:52]

We don't; the partial variant works for both, but is unnecessarily complex
(runtime) for the non-partial case, which can always assume there isn't already
a @@unscopables property/object on the prototype.

[haraken, 2015/04/22 13:10:32]

Just to confirm: If we have X and PartialX, is it guaranteed that the
preparePrototypeObject of X is always called before the preparePrototypeObject
of PartialX?

If that is true, the preparePrototypeObject of PartialX will never hit the
branch for v8::Object::New(isolate).

[Jens Widell, 2015/04/22 14:22:10]

Yes. V8FooPartial::preparePrototypeObject() calls
V8Foo::preparePrototypeObject() as its first action, before looking for
@@unscopable on the prototype object.
It will if only the partial interface has unscopeable members.

[haraken, 2015/04/22 15:36:10]

ok, understood.

I still prefer not introducing differnt logics between partial and non-partial
unless it really matters for performance. Can we do something like:

unscopeables = prototypeObject->Get(...);
if (!unscopeables.IsUndefined()) {
  unscopeables = v8::Object::New(isolate);
}

?

[Jens Widell, 2015/04/22 16:37:07]

We need to make sure to only read an own @@unscopables property from the
prototype object, hence my use of HasOwnProperty() before using Get() to
actually read the property.

But like I said above, we can use the current is_partial path for all cases;
HasOwnProperty() will just never return true for the !is_partial case.

[haraken, 2015/04/22 17:02:26]

Makes sense. Then shall we use the current is_partial path for both cases?

[Jens Widell, 2015/04/22 17:08:04]

Sure, I'll make that change.

[Jens Widell, 2015/04/22 17:15:13]

Done.

+bool hasUnscopables = v8CallBoolean(prototypeObject->HasOwnProperty(v8Context, unscopablesSymbol));
+v8::Local<v8::Object> unscopeables;
+if (hasUnscopables)

[haraken, 2015/04/22 10:54:51]

if (!v8CallBoolean(...))

?

[Jens Widell, 2015/04/22 13:04:51]

We can inline the HasOwnProperty() call here, yes. Negating would be wrong
though unless the true/false branches are swapped.

[Jens Widell, 2015/04/22 17:15:13]

Done.

+    unscopeables = prototypeObject->Get(v8Context, unscopablesSymbol).ToLocalChecked();
+else
+    unscopeables = v8::Object::New(isolate);
+{% else %}
+v8::Local<v8::Object> unscopeables(v8::Object::New(isolate));
+{% endif %}
+{% for name in unscopeables %}
+unscopeables->ForceSet(v8Context, v8AtomicString(isolate, "{{name}}"), v8::True(isolate)).FromJust();
+{% endfor %}
+prototypeObject->ForceSet(v8Context, v8::Symbol::GetUnscopables(isolate), unscopeables).FromJust();
+{% endmacro %}
+
+
+{##############################################################################}
 {% block to_active_dom_object %}
 {% if is_active_dom_object %}
 ActiveDOMObject* {{v8_class}}::toActiveDOMObject(v8::Local<v8::Object> wrapper)
 {
     return toImpl(wrapper);
 }
 
 {% endif %}
 {% endblock %}
 
@@ skipping 54 matching lines @@
 {% endif %}
 }
 
 {% endblock %}
 
 {##############################################################################}
 {% block partial_interface %}
 {% if has_partial_interface %}
 InstallTemplateFunction {{v8_class}}::install{{v8_class}}TemplateFunction = (InstallTemplateFunction)&{{v8_class}}::install{{v8_class}}Template;
 
-void {{v8_class}}::updateWrapperTypeInfo(InstallTemplateFunction installTemplateFunction, InstallConditionallyEnabledMethodsFunction installConditionallyEnabledMethodsFunction)
+void {{v8_class}}::updateWrapperTypeInfo(InstallTemplateFunction installTemplateFunction, PreparePrototypeObjectFunction preparePrototypeObjectFunction)
 {
     {{v8_class}}::install{{v8_class}}TemplateFunction = installTemplateFunction;
-    if (installConditionallyEnabledMethodsFunction)
-        {{v8_class}}::wrapperTypeInfo.installConditionallyEnabledMethodsFunction = installConditionallyEnabledMethodsFunction;
+    if (preparePrototypeObjectFunction)
+        {{v8_class}}::wrapperTypeInfo.preparePrototypeObjectFunction = preparePrototypeObjectFunction;
 }
 
 {% for method in methods if method.overloads and method.overloads.has_partial_overloads %}
 void {{v8_class}}::register{{method.name | blink_capitalize}}MethodForPartialInterface(void (*method)(const v8::FunctionCallbackInfo<v8::Value>&))
 {
     {{cpp_class}}V8Internal::{{method.name}}MethodForPartialInterface = method;
 }
 {% endfor %}
 {% endif %}
 {% endblock %}