third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinition.cpp - chromium/src - Git at Google

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "bindings/core/v8/ScriptCustomElementDefinition.h"

 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8CustomElementRegistry.h"
 #include "bindings/core/v8/V8Element.h"
 #include "bindings/core/v8/V8ErrorHandler.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/events/ErrorEvent.h"
 #include "core/html/HTMLElement.h"
 #include "v8.h"
 #include "wtf/Allocator.h"

 namespace blink {

 // Retrieves the custom elements constructor -> name map, creating it
 // if necessary. The same map is used to keep prototypes alive.
 static v8::Local<v8::Map> ensureCustomElementRegistryMap(
     ScriptState* scriptState,
     CustomElementRegistry* registry) {
   CHECK(scriptState->world().isMainWorld());
   v8::Local<v8::String> name =
       V8HiddenValue::customElementsRegistryMap(scriptState->isolate());
   v8::Local<v8::Object> wrapper = toV8(registry, scriptState).As<v8::Object>();
   v8::Local<v8::Value> map =
       V8HiddenValue::getHiddenValue(scriptState, wrapper, name);
   if (map.IsEmpty()) {
     map = v8::Map::New(scriptState->isolate());
     V8HiddenValue::setHiddenValue(scriptState, wrapper, name, map);
   }
   return map.As<v8::Map>();
 }

 ScriptCustomElementDefinition* ScriptCustomElementDefinition::forConstructor(
     ScriptState* scriptState,
     CustomElementRegistry* registry,
     const v8::Local<v8::Value>& constructor) {
   v8::Local<v8::Map> map =
       ensureCustomElementRegistryMap(scriptState, registry);
   v8::Local<v8::Value> nameValue =
       map->Get(scriptState->context(), constructor).ToLocalChecked();
   if (!nameValue->IsString())
     return nullptr;
   AtomicString name = toCoreAtomicString(nameValue.As<v8::String>());

   // This downcast is safe because only
   // ScriptCustomElementDefinitions have a name associated with a V8
   // constructor in the map; see
   // ScriptCustomElementDefinition::create. This relies on three
   // things:
   //
   // 1. Only ScriptCustomElementDefinition adds entries to the map.
   //    Audit the use of V8HiddenValue/hidden values in general and
   //    how the map is handled--it should never be leaked to script.
   //
   // 2. CustomElementRegistry does not overwrite definitions with a
   //    given name--see the CHECK in CustomElementRegistry::define
   //    --and adds ScriptCustomElementDefinitions to the map without
   //    fail.
   //
   // 3. The relationship between the CustomElementRegistry and its
   //    map is never mixed up; this is guaranteed by the bindings
   //    system which provides a stable wrapper, and the map hangs
   //    off the wrapper.
   //
   // At a meta-level, this downcast is safe because there is
   // currently only one implementation of CustomElementDefinition in
   // product code and that is ScriptCustomElementDefinition. But
   // that may change in the future.
   CustomElementDefinition* definition = registry->definitionForName(name);
   CHECK(definition);
   return static_cast<ScriptCustomElementDefinition*>(definition);
 }

 template <typename T>
 static void keepAlive(v8::Local<v8::Array>& array,
                       uint32_t index,
                       const v8::Local<T>& value,
                       ScopedPersistent<T>& persistent,
                       ScriptState* scriptState) {
   if (value.IsEmpty())
     return;

   array->Set(scriptState->context(), index, value).ToChecked();

   persistent.set(scriptState->isolate(), value);
   persistent.setPhantom();
 }

 ScriptCustomElementDefinition* ScriptCustomElementDefinition::create(
     ScriptState* scriptState,
     CustomElementRegistry* registry,
     const CustomElementDescriptor& descriptor,
     const v8::Local<v8::Object>& constructor,
     const v8::Local<v8::Object>& prototype,
     const v8::Local<v8::Function>& connectedCallback,
     const v8::Local<v8::Function>& disconnectedCallback,
     const v8::Local<v8::Function>& adoptedCallback,
     const v8::Local<v8::Function>& attributeChangedCallback,
     const HashSet<AtomicString>& observedAttributes) {
   ScriptCustomElementDefinition* definition = new ScriptCustomElementDefinition(
       scriptState, descriptor, constructor, prototype, connectedCallback,
       disconnectedCallback, adoptedCallback, attributeChangedCallback,
       observedAttributes);

   // Add a constructor -> name mapping to the registry.
   v8::Local<v8::Value> nameValue =
       v8String(scriptState->isolate(), descriptor.name());
   v8::Local<v8::Map> map =
       ensureCustomElementRegistryMap(scriptState, registry);
   map->Set(scriptState->context(), constructor, nameValue).ToLocalChecked();
   definition->m_constructor.setPhantom();

   // We add the prototype and callbacks here to keep them alive. We use the
   // name as the key because it is unique per-registry.
   v8::Local<v8::Array> array = v8::Array::New(scriptState->isolate(), 5);
   keepAlive(array, 0, prototype, definition->m_prototype, scriptState);
   keepAlive(array, 1, connectedCallback, definition->m_connectedCallback,
             scriptState);
   keepAlive(array, 2, disconnectedCallback, definition->m_disconnectedCallback,
             scriptState);
   keepAlive(array, 3, adoptedCallback, definition->m_adoptedCallback,
             scriptState);
   keepAlive(array, 4, attributeChangedCallback,
             definition->m_attributeChangedCallback, scriptState);
   map->Set(scriptState->context(), nameValue, array).ToLocalChecked();

   return definition;
 }

 ScriptCustomElementDefinition::ScriptCustomElementDefinition(
     ScriptState* scriptState,
     const CustomElementDescriptor& descriptor,
     const v8::Local<v8::Object>& constructor,
     const v8::Local<v8::Object>& prototype,
     const v8::Local<v8::Function>& connectedCallback,
     const v8::Local<v8::Function>& disconnectedCallback,
     const v8::Local<v8::Function>& adoptedCallback,
     const v8::Local<v8::Function>& attributeChangedCallback,
     const HashSet<AtomicString>& observedAttributes)
     : CustomElementDefinition(descriptor, observedAttributes),
       m_scriptState(scriptState),
       m_constructor(scriptState->isolate(), constructor) {}

 HTMLElement* ScriptCustomElementDefinition::createElementSync(
     Document& document,
     const QualifiedName& tagName,
     ExceptionState& exceptionState) {
   DCHECK(ScriptState::current(m_scriptState->isolate()) == m_scriptState);

   // Create an element
   // https://dom.spec.whatwg.org/#concept-create-element
   // 6. If definition is non-null
   // 6.1. If the synchronous custom elements flag is set:
   // 6.1.2. Set result to Construct(C). Rethrow any exceptions.

   // Create an element and push to the construction stack.
   // V8HTMLElement::constructorCustom() can only refer to
   // window.document(), but it is different from the document here
   // when it is an import document.  This is not exactly what the
   // spec defines, but the public behavior matches to the spec.
   Element* element = createElementForConstructor(document);
   {
     ConstructionStackScope constructionStackScope(this, element);
     v8::TryCatch tryCatch(m_scriptState->isolate());
     element = runConstructor();
     if (tryCatch.HasCaught()) {
       exceptionState.rethrowV8Exception(tryCatch.Exception());
       return nullptr;
     }
   }

   // 6.1.3. through 6.1.9.
   checkConstructorResult(element, document, tagName, exceptionState);
   if (exceptionState.hadException())
     return nullptr;

   DCHECK_EQ(element->getCustomElementState(), CustomElementState::Custom);
   return toHTMLElement(element);
 }

 static void dispatchErrorEvent(v8::Isolate* isolate,
                                v8::Local<v8::Value> exception,
                                v8::Local<v8::Object> constructor) {
   v8::TryCatch tryCatch(isolate);
   tryCatch.SetVerbose(true);
   V8ScriptRunner::throwException(
       isolate, exception, constructor.As<v8::Function>()->GetScriptOrigin());
 }

 HTMLElement* ScriptCustomElementDefinition::createElementSync(
     Document& document,
     const QualifiedName& tagName) {
   ScriptState::Scope scope(m_scriptState.get());
   v8::Isolate* isolate = m_scriptState->isolate();

   // When invoked from "create an element for a token":
   // https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token

   ExceptionState exceptionState(ExceptionState::ConstructionContext,
                                 "CustomElement", constructor(), isolate);
   HTMLElement* element = createElementSync(document, tagName, exceptionState);

   if (exceptionState.hadException()) {
     DCHECK(!element);
     // 7. If this step throws an exception, then report the exception, ...
     dispatchErrorEvent(isolate, exceptionState.getException(), constructor());
     exceptionState.clearException();
     // and return HTMLUnknownElement.
     return CustomElement::createFailedElement(document, tagName);
   }
   DCHECK(element);
   return element;
 }

 // https://html.spec.whatwg.org/multipage/scripting.html#upgrades
 bool ScriptCustomElementDefinition::runConstructor(Element* element) {
   if (!m_scriptState->contextIsValid())
     return false;
   ScriptState::Scope scope(m_scriptState.get());
   v8::Isolate* isolate = m_scriptState->isolate();

   // Step 5 says to rethrow the exception; but there is no one to
   // catch it. The side effect is to report the error.
   v8::TryCatch tryCatch(isolate);
   tryCatch.SetVerbose(true);

   Element* result = runConstructor();

   // To report exception thrown from runConstructor()
   if (tryCatch.HasCaught())
     return false;

   // To report InvalidStateError Exception, when the constructor returns some
   // different object
   if (result != element) {
     const String& message =
         "custom element constructors must call super() first and must "
         "not return a different object";
     v8::Local<v8::Value> exception = V8ThrowException::createDOMException(
         m_scriptState->isolate(), InvalidStateError, message);
     dispatchErrorEvent(isolate, exception, constructor());
     return false;
   }

   return true;
 }

 Element* ScriptCustomElementDefinition::runConstructor() {
   v8::Isolate* isolate = m_scriptState->isolate();
   DCHECK(ScriptState::current(isolate) == m_scriptState);
   ExecutionContext* executionContext = m_scriptState->getExecutionContext();
   v8::Local<v8::Value> result;
   if (!v8Call(V8ScriptRunner::callAsConstructor(isolate, constructor(),
                                                 executionContext, 0, nullptr),
               result)) {
     return nullptr;
   }
   return V8Element::toImplWithTypeCheck(isolate, result);
 }

 v8::Local<v8::Object> ScriptCustomElementDefinition::constructor() const {
   DCHECK(!m_constructor.isEmpty());
   return m_constructor.newLocal(m_scriptState->isolate());
 }

 v8::Local<v8::Object> ScriptCustomElementDefinition::prototype() const {
   DCHECK(!m_prototype.isEmpty());
   return m_prototype.newLocal(m_scriptState->isolate());
 }

 // CustomElementDefinition
 ScriptValue ScriptCustomElementDefinition::getConstructorForScript() {
   return ScriptValue(m_scriptState.get(), constructor());
 }

 bool ScriptCustomElementDefinition::hasConnectedCallback() const {
   return !m_connectedCallback.isEmpty();
 }

 bool ScriptCustomElementDefinition::hasDisconnectedCallback() const {
   return !m_disconnectedCallback.isEmpty();
 }

 bool ScriptCustomElementDefinition::hasAdoptedCallback() const {
   return !m_adoptedCallback.isEmpty();
 }

 void ScriptCustomElementDefinition::runCallback(
     v8::Local<v8::Function> callback,
     Element* element,
     int argc,
     v8::Local<v8::Value> argv[]) {
   DCHECK(ScriptState::current(m_scriptState->isolate()) == m_scriptState);
   v8::Isolate* isolate = m_scriptState->isolate();

   // Invoke custom element reactions
   // https://html.spec.whatwg.org/multipage/scripting.html#invoke-custom-element-reactions
   // If this throws any exception, then report the exception.
   v8::TryCatch tryCatch(isolate);
   tryCatch.SetVerbose(true);

   ExecutionContext* executionContext = m_scriptState->getExecutionContext();
   v8::Local<v8::Value> elementHandle =
       toV8(element, m_scriptState->context()->Global(), isolate);
   V8ScriptRunner::callFunction(callback, executionContext, elementHandle, argc,
                                argv, isolate);
 }

 void ScriptCustomElementDefinition::runConnectedCallback(Element* element) {
   if (!m_scriptState->contextIsValid())
     return;
   ScriptState::Scope scope(m_scriptState.get());
   v8::Isolate* isolate = m_scriptState->isolate();
   runCallback(m_connectedCallback.newLocal(isolate), element);
 }

 void ScriptCustomElementDefinition::runDisconnectedCallback(Element* element) {
   if (!m_scriptState->contextIsValid())
     return;
   ScriptState::Scope scope(m_scriptState.get());
   v8::Isolate* isolate = m_scriptState->isolate();
   runCallback(m_disconnectedCallback.newLocal(isolate), element);
 }

 void ScriptCustomElementDefinition::runAdoptedCallback(Element* element,
                                                        Document* oldOwner,
                                                        Document* newOwner) {
   if (!m_scriptState->contextIsValid())
     return;
   ScriptState::Scope scope(m_scriptState.get());
   v8::Isolate* isolate = m_scriptState->isolate();
   v8::Local<v8::Value> argv[] = {
       toV8(oldOwner, m_scriptState->context()->Global(), isolate),
       toV8(newOwner, m_scriptState->context()->Global(), isolate)};
   runCallback(m_adoptedCallback.newLocal(isolate), element,
               WTF_ARRAY_LENGTH(argv), argv);
 }

 void ScriptCustomElementDefinition::runAttributeChangedCallback(
     Element* element,
     const QualifiedName& name,
     const AtomicString& oldValue,
     const AtomicString& newValue) {
   if (!m_scriptState->contextIsValid())
     return;
   ScriptState::Scope scope(m_scriptState.get());
   v8::Isolate* isolate = m_scriptState->isolate();
   v8::Local<v8::Value> argv[] = {
       v8String(isolate, name.localName()), v8StringOrNull(isolate, oldValue),
       v8StringOrNull(isolate, newValue),
       v8StringOrNull(isolate, name.namespaceURI()),
   };
   runCallback(m_attributeChangedCallback.newLocal(isolate), element,
               WTF_ARRAY_LENGTH(argv), argv);
 }

 }  // namespace blink
	// Copyright 2016 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "bindings/core/v8/ScriptCustomElementDefinition.h"

	#include "bindings/core/v8/ScriptState.h"
	#include "bindings/core/v8/V8Binding.h"
	#include "bindings/core/v8/V8BindingMacros.h"
	#include "bindings/core/v8/V8CustomElementRegistry.h"
	#include "bindings/core/v8/V8Element.h"
	#include "bindings/core/v8/V8ErrorHandler.h"
	#include "bindings/core/v8/V8HiddenValue.h"
	#include "bindings/core/v8/V8ScriptRunner.h"
	#include "bindings/core/v8/V8ThrowException.h"
	#include "core/dom/ExceptionCode.h"
	#include "core/dom/custom/CustomElement.h"
	#include "core/events/ErrorEvent.h"
	#include "core/html/HTMLElement.h"
	#include "v8.h"
	#include "wtf/Allocator.h"

	namespace blink {

	// Retrieves the custom elements constructor -> name map, creating it
	// if necessary. The same map is used to keep prototypes alive.
	static v8::Local<v8::Map> ensureCustomElementRegistryMap(
	ScriptState* scriptState,
	CustomElementRegistry* registry) {
	CHECK(scriptState->world().isMainWorld());
	v8::Local<v8::String> name =
	V8HiddenValue::customElementsRegistryMap(scriptState->isolate());
	v8::Local<v8::Object> wrapper = toV8(registry, scriptState).As<v8::Object>();
	v8::Local<v8::Value> map =
	V8HiddenValue::getHiddenValue(scriptState, wrapper, name);
	if (map.IsEmpty()) {
	map = v8::Map::New(scriptState->isolate());
	V8HiddenValue::setHiddenValue(scriptState, wrapper, name, map);
	}
	return map.As<v8::Map>();
	}

	ScriptCustomElementDefinition* ScriptCustomElementDefinition::forConstructor(
	ScriptState* scriptState,
	CustomElementRegistry* registry,
	const v8::Local<v8::Value>& constructor) {
	v8::Local<v8::Map> map =
	ensureCustomElementRegistryMap(scriptState, registry);
	v8::Local<v8::Value> nameValue =
	map->Get(scriptState->context(), constructor).ToLocalChecked();
	if (!nameValue->IsString())
	return nullptr;
	AtomicString name = toCoreAtomicString(nameValue.As<v8::String>());

	// This downcast is safe because only
	// ScriptCustomElementDefinitions have a name associated with a V8
	// constructor in the map; see
	// ScriptCustomElementDefinition::create. This relies on three
	// things:
	//
	// 1. Only ScriptCustomElementDefinition adds entries to the map.
	// Audit the use of V8HiddenValue/hidden values in general and
	// how the map is handled--it should never be leaked to script.
	//
	// 2. CustomElementRegistry does not overwrite definitions with a
	// given name--see the CHECK in CustomElementRegistry::define
	// --and adds ScriptCustomElementDefinitions to the map without
	// fail.
	//
	// 3. The relationship between the CustomElementRegistry and its
	// map is never mixed up; this is guaranteed by the bindings
	// system which provides a stable wrapper, and the map hangs
	// off the wrapper.
	//
	// At a meta-level, this downcast is safe because there is
	// currently only one implementation of CustomElementDefinition in
	// product code and that is ScriptCustomElementDefinition. But
	// that may change in the future.
	CustomElementDefinition* definition = registry->definitionForName(name);
	CHECK(definition);
	return static_cast<ScriptCustomElementDefinition*>(definition);
	}

	template <typename T>
	static void keepAlive(v8::Local<v8::Array>& array,
	uint32_t index,
	const v8::Local<T>& value,
	ScopedPersistent<T>& persistent,
	ScriptState* scriptState) {
	if (value.IsEmpty())
	return;

	array->Set(scriptState->context(), index, value).ToChecked();

	persistent.set(scriptState->isolate(), value);
	persistent.setPhantom();
	}

	ScriptCustomElementDefinition* ScriptCustomElementDefinition::create(
	ScriptState* scriptState,
	CustomElementRegistry* registry,
	const CustomElementDescriptor& descriptor,
	const v8::Local<v8::Object>& constructor,
	const v8::Local<v8::Object>& prototype,
	const v8::Local<v8::Function>& connectedCallback,
	const v8::Local<v8::Function>& disconnectedCallback,
	const v8::Local<v8::Function>& adoptedCallback,
	const v8::Local<v8::Function>& attributeChangedCallback,
	const HashSet<AtomicString>& observedAttributes) {
	ScriptCustomElementDefinition* definition = new ScriptCustomElementDefinition(
	scriptState, descriptor, constructor, prototype, connectedCallback,
	disconnectedCallback, adoptedCallback, attributeChangedCallback,
	observedAttributes);

	// Add a constructor -> name mapping to the registry.
	v8::Local<v8::Value> nameValue =
	v8String(scriptState->isolate(), descriptor.name());
	v8::Local<v8::Map> map =
	ensureCustomElementRegistryMap(scriptState, registry);
	map->Set(scriptState->context(), constructor, nameValue).ToLocalChecked();
	definition->m_constructor.setPhantom();

	// We add the prototype and callbacks here to keep them alive. We use the
	// name as the key because it is unique per-registry.
	v8::Local<v8::Array> array = v8::Array::New(scriptState->isolate(), 5);
	keepAlive(array, 0, prototype, definition->m_prototype, scriptState);
	keepAlive(array, 1, connectedCallback, definition->m_connectedCallback,
	scriptState);
	keepAlive(array, 2, disconnectedCallback, definition->m_disconnectedCallback,
	scriptState);
	keepAlive(array, 3, adoptedCallback, definition->m_adoptedCallback,
	scriptState);
	keepAlive(array, 4, attributeChangedCallback,
	definition->m_attributeChangedCallback, scriptState);
	map->Set(scriptState->context(), nameValue, array).ToLocalChecked();

	return definition;
	}

	ScriptCustomElementDefinition::ScriptCustomElementDefinition(
	ScriptState* scriptState,
	const CustomElementDescriptor& descriptor,
	const v8::Local<v8::Object>& constructor,
	const v8::Local<v8::Object>& prototype,
	const v8::Local<v8::Function>& connectedCallback,
	const v8::Local<v8::Function>& disconnectedCallback,
	const v8::Local<v8::Function>& adoptedCallback,
	const v8::Local<v8::Function>& attributeChangedCallback,
	const HashSet<AtomicString>& observedAttributes)
	: CustomElementDefinition(descriptor, observedAttributes),
	m_scriptState(scriptState),
	m_constructor(scriptState->isolate(), constructor) {}

	HTMLElement* ScriptCustomElementDefinition::createElementSync(
	Document& document,
	const QualifiedName& tagName,
	ExceptionState& exceptionState) {
	DCHECK(ScriptState::current(m_scriptState->isolate()) == m_scriptState);

	// Create an element
	// https://dom.spec.whatwg.org/#concept-create-element
	// 6. If definition is non-null
	// 6.1. If the synchronous custom elements flag is set:
	// 6.1.2. Set result to Construct(C). Rethrow any exceptions.

	// Create an element and push to the construction stack.
	// V8HTMLElement::constructorCustom() can only refer to
	// window.document(), but it is different from the document here
	// when it is an import document. This is not exactly what the
	// spec defines, but the public behavior matches to the spec.
	Element* element = createElementForConstructor(document);
	{
	ConstructionStackScope constructionStackScope(this, element);
	v8::TryCatch tryCatch(m_scriptState->isolate());
	element = runConstructor();
	if (tryCatch.HasCaught()) {
	exceptionState.rethrowV8Exception(tryCatch.Exception());
	return nullptr;
	}
	}

	// 6.1.3. through 6.1.9.
	checkConstructorResult(element, document, tagName, exceptionState);
	if (exceptionState.hadException())
	return nullptr;

	DCHECK_EQ(element->getCustomElementState(), CustomElementState::Custom);
	return toHTMLElement(element);
	}

	static void dispatchErrorEvent(v8::Isolate* isolate,
	v8::Local<v8::Value> exception,
	v8::Local<v8::Object> constructor) {
	v8::TryCatch tryCatch(isolate);
	tryCatch.SetVerbose(true);
	V8ScriptRunner::throwException(
	isolate, exception, constructor.As<v8::Function>()->GetScriptOrigin());
	}

	HTMLElement* ScriptCustomElementDefinition::createElementSync(
	Document& document,
	const QualifiedName& tagName) {
	ScriptState::Scope scope(m_scriptState.get());
	v8::Isolate* isolate = m_scriptState->isolate();

	// When invoked from "create an element for a token":
	// https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token

	ExceptionState exceptionState(ExceptionState::ConstructionContext,
	"CustomElement", constructor(), isolate);
	HTMLElement* element = createElementSync(document, tagName, exceptionState);

	if (exceptionState.hadException()) {
	DCHECK(!element);
	// 7. If this step throws an exception, then report the exception, ...
	dispatchErrorEvent(isolate, exceptionState.getException(), constructor());
	exceptionState.clearException();
	// and return HTMLUnknownElement.
	return CustomElement::createFailedElement(document, tagName);
	}
	DCHECK(element);
	return element;
	}

	// https://html.spec.whatwg.org/multipage/scripting.html#upgrades
	bool ScriptCustomElementDefinition::runConstructor(Element* element) {
	if (!m_scriptState->contextIsValid())
	return false;
	ScriptState::Scope scope(m_scriptState.get());
	v8::Isolate* isolate = m_scriptState->isolate();

	// Step 5 says to rethrow the exception; but there is no one to
	// catch it. The side effect is to report the error.
	v8::TryCatch tryCatch(isolate);
	tryCatch.SetVerbose(true);

	Element* result = runConstructor();

	// To report exception thrown from runConstructor()
	if (tryCatch.HasCaught())
	return false;

	// To report InvalidStateError Exception, when the constructor returns some
	// different object
	if (result != element) {
	const String& message =
	"custom element constructors must call super() first and must "
	"not return a different object";
	v8::Local<v8::Value> exception = V8ThrowException::createDOMException(
	m_scriptState->isolate(), InvalidStateError, message);
	dispatchErrorEvent(isolate, exception, constructor());
	return false;
	}

	return true;
	}

	Element* ScriptCustomElementDefinition::runConstructor() {
	v8::Isolate* isolate = m_scriptState->isolate();
	DCHECK(ScriptState::current(isolate) == m_scriptState);
	ExecutionContext* executionContext = m_scriptState->getExecutionContext();
	v8::Local<v8::Value> result;
	if (!v8Call(V8ScriptRunner::callAsConstructor(isolate, constructor(),
	executionContext, 0, nullptr),
	result)) {
	return nullptr;
	}
	return V8Element::toImplWithTypeCheck(isolate, result);
	}

	v8::Local<v8::Object> ScriptCustomElementDefinition::constructor() const {
	DCHECK(!m_constructor.isEmpty());
	return m_constructor.newLocal(m_scriptState->isolate());
	}

	v8::Local<v8::Object> ScriptCustomElementDefinition::prototype() const {
	DCHECK(!m_prototype.isEmpty());
	return m_prototype.newLocal(m_scriptState->isolate());
	}

	// CustomElementDefinition
	ScriptValue ScriptCustomElementDefinition::getConstructorForScript() {
	return ScriptValue(m_scriptState.get(), constructor());
	}

	bool ScriptCustomElementDefinition::hasConnectedCallback() const {
	return !m_connectedCallback.isEmpty();
	}

	bool ScriptCustomElementDefinition::hasDisconnectedCallback() const {
	return !m_disconnectedCallback.isEmpty();
	}

	bool ScriptCustomElementDefinition::hasAdoptedCallback() const {
	return !m_adoptedCallback.isEmpty();
	}

	void ScriptCustomElementDefinition::runCallback(
	v8::Local<v8::Function> callback,
	Element* element,
	int argc,
	v8::Local<v8::Value> argv[]) {
	DCHECK(ScriptState::current(m_scriptState->isolate()) == m_scriptState);
	v8::Isolate* isolate = m_scriptState->isolate();

	// Invoke custom element reactions
	// https://html.spec.whatwg.org/multipage/scripting.html#invoke-custom-element-reactions
	// If this throws any exception, then report the exception.
	v8::TryCatch tryCatch(isolate);
	tryCatch.SetVerbose(true);

	ExecutionContext* executionContext = m_scriptState->getExecutionContext();
	v8::Local<v8::Value> elementHandle =
	toV8(element, m_scriptState->context()->Global(), isolate);
	V8ScriptRunner::callFunction(callback, executionContext, elementHandle, argc,
	argv, isolate);
	}

	void ScriptCustomElementDefinition::runConnectedCallback(Element* element) {
	if (!m_scriptState->contextIsValid())
	return;
	ScriptState::Scope scope(m_scriptState.get());
	v8::Isolate* isolate = m_scriptState->isolate();
	runCallback(m_connectedCallback.newLocal(isolate), element);
	}

	void ScriptCustomElementDefinition::runDisconnectedCallback(Element* element) {
	if (!m_scriptState->contextIsValid())
	return;
	ScriptState::Scope scope(m_scriptState.get());
	v8::Isolate* isolate = m_scriptState->isolate();
	runCallback(m_disconnectedCallback.newLocal(isolate), element);
	}

	void ScriptCustomElementDefinition::runAdoptedCallback(Element* element,
	Document* oldOwner,
	Document* newOwner) {
	if (!m_scriptState->contextIsValid())
	return;
	ScriptState::Scope scope(m_scriptState.get());
	v8::Isolate* isolate = m_scriptState->isolate();
	v8::Local<v8::Value> argv[] = {
	toV8(oldOwner, m_scriptState->context()->Global(), isolate),
	toV8(newOwner, m_scriptState->context()->Global(), isolate)};
	runCallback(m_adoptedCallback.newLocal(isolate), element,
	WTF_ARRAY_LENGTH(argv), argv);
	}

	void ScriptCustomElementDefinition::runAttributeChangedCallback(
	Element* element,
	const QualifiedName& name,
	const AtomicString& oldValue,
	const AtomicString& newValue) {
	if (!m_scriptState->contextIsValid())
	return;
	ScriptState::Scope scope(m_scriptState.get());
	v8::Isolate* isolate = m_scriptState->isolate();
	v8::Local<v8::Value> argv[] = {
	v8String(isolate, name.localName()), v8StringOrNull(isolate, oldValue),
	v8StringOrNull(isolate, newValue),
	v8StringOrNull(isolate, name.namespaceURI()),
	};
	runCallback(m_attributeChangedCallback.newLocal(isolate), element,
	WTF_ARRAY_LENGTH(argv), argv);
	}

	} // namespace blink