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

Source/bindings/templates/interface.cpp

Index: Source/bindings/templates/interface.cpp
diff --git a/Source/bindings/templates/interface.cpp b/Source/bindings/templates/interface.cpp
index 5894565abbf1e40edcc3dc18d7bfc34b2827a7ca..e219a57f733523c19a042e0af8fd436c714e1fd4 100644
--- a/Source/bindings/templates/interface.cpp
+++ b/Source/bindings/templates/interface.cpp
@@ -474,7 +474,7 @@ static void {{cpp_class}}OriginSafeMethodSetterCallback(v8::Local<v8::Name> name
 {% 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)
@@ -926,6 +926,45 @@ void {{v8_class}}::installConditionallyEnabledProperties(v8::Local<v8::Object> i
 
 
 {##############################################################################}
+{% 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)
@@ -1000,11 +1039,11 @@ void {{v8_class}}::derefObject(ScriptWrappable* scriptWrappable)
 {% 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 %}