Change [ConstructorCallWith={Document => ExecutionContext}]

Source/bindings/templates/methods.cpp

 {##############################################################################}
 {% macro generate_method(method, world_suffix) %}
 {% filter conditional(method.conditional_string) %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     {# Local variables #}
     {% if method.has_exception_state %}
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{method.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
     {% endif %}
     {# Overloaded methods have length checked during overload resolution #}
@@ skipping 478 matching lines @@
         {{throw_minimum_arity_type_error(constructor, interface_length)}};
         return;
     }
     {% endif %}
     {% if constructor.arguments %}
     {{generate_arguments(constructor) | indent}}
     {% endif %}
     {% if is_constructor_call_with_execution_context %}
     ExecutionContext* executionContext = currentExecutionContext(isolate);
     {% endif %}
-    {% if is_constructor_call_with_document %}
-    Document& document = *toDocument(currentExecutionContext(isolate));
-    {% endif %}
     {{constructor.cpp_type}} impl = {{constructor.cpp_value}};
     {% if is_constructor_raises_exception %}
     if (exceptionState.throwIfNeeded())
         return;
     {% endif %}
 
     {{generate_constructor_wrapper(constructor) | indent}}
 }
 {% endmacro %}
 
@@ skipping 21 matching lines @@
     if (!info.IsConstructCall()) {
         throwTypeError(ExceptionMessages::constructorNotCallableAsFunction("{{constructor.name}}"), isolate);
         return;
     }
 
     if (ConstructorMode::current(isolate) == ConstructorMode::WrapExistingObject) {
         v8SetReturnValue(info, info.Holder());
         return;
     }
 
-    Document* documentPtr = currentDOMWindow(isolate)->document();
+    ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
+
+    Document* documentPtr = toDocument(executionContext);
     ASSERT(documentPtr);
-    Document& document = *documentPtr;
 
     // Make sure the document is added to the DOM Node map. Otherwise, the {{cpp_class}} instance
     // may end up being the only node in the map and get garbage-collected prematurely.
     toV8(documentPtr, info.Holder(), isolate);

[Jens Widell, 2014/06/18 10:39:08]

I don't really understand what this code is about, so I left it intact.

[haraken, 2014/06/18 10:49:21]

This is complicated to explain, but basically this code makes sure that a
document wrapper exists. This is needed for making the object grouping algorithm
workable (See V8GCController.cpp).

[Jens Widell, 2014/06/18 11:14:38]

Why would this only be needed for "named" constructors, and not for the pretty
similar regular constructors that used to have ConstructorCallWith=Document, and
now have ConstructorCallWith=ExecutionContext but still use the document? That
is, how is "new Comment(...)" different from "new Image(...)"?

[haraken, 2014/06/18 11:24:52]

That is because Nodes can have named constructors but cannot ahve (non-named)
constructors (e.g., Comment is not a Node but Image is a Node). Once we
introduce a (non-named) constructor for Nodes, I think we need to add the
toV8(document) into the (non-named) constructor.

[Jens Widell, 2014/06/18 11:29:02]

I don't understand. In what sense is Comment (and Text or DocumentFragment) not
a Node?

 
     {% if constructor.has_exception_state %}
     ExceptionState exceptionState(ExceptionState::ConstructionContext, "{{interface_name}}", info.Holder(), isolate);
     {% endif %}
     {% if constructor.number_of_required_arguments %}
     if (UNLIKELY(info.Length() < {{constructor.number_of_required_arguments}})) {
         {{throw_minimum_arity_type_error(constructor, constructor.number_of_required_arguments)}};
         return;
     }
     {% endif %}
     {% if constructor.arguments %}
     {{generate_arguments(constructor) | indent}}
     {% endif %}
     {{constructor.cpp_type}} impl = {{constructor.cpp_value}};
     {% if is_constructor_raises_exception %}
     if (exceptionState.throwIfNeeded())
         return;
     {% endif %}
 
     {{generate_constructor_wrapper(constructor) | indent}}
 }
 {% endmacro %}