CustomElements: adopt node

third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinition.cpp

 // 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/V8CustomElementsRegistry.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> ensureCustomElementsRegistryMap(
     ScriptState* scriptState,
@@ skipping 71 matching lines @@
 }
 
 ScriptCustomElementDefinition* ScriptCustomElementDefinition::create(
     ScriptState* scriptState,
     CustomElementsRegistry* 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 =
         ensureCustomElementsRegistryMap(scriptState, registry);
     v8CallOrCrash(map->Set(scriptState->context(), constructor, nameValue));
     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(), 4);
+    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, attributeChangedCallback, definition->m_attributeChangedCallback, scriptState);
+    keepAlive(array, 4, adoptedCallback, definition->m_adoptedCallback, scriptState);
     v8CallOrCrash(map->Set(scriptState->context(), nameValue, array));
 
     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,
@@ skipping 58 matching lines @@
         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();
-    if (!result)
+
+    // To report exception thrown from runConstructor()
+    if (tryCatch.HasCaught())
         return false;
 
+    // To report InvalidStateError Exception, when the constructor returns some differnt object

[dominicc (has gone to gerrit), 2016/08/02 07:48:57]

Spelling: different

     if (result != element) {
-        V8ThrowException::throwException(
-            V8ThrowException::createDOMException(
-                m_scriptState->isolate(),
-                InvalidStateError,
-                "custom element constructors must call super() first and must "
-                "not return a different object",
-                constructor()),
-            m_scriptState->isolate());
+        const String& message = "custom element constructors must call super() first and must "
+            "not return a different object";
+

[dominicc (has gone to gerrit), 2016/08/02 07:48:57]

Maybe delete this blank line; since the message and location are
related--they're all for configuring the error.

+        std::unique_ptr<SourceLocation> location = SourceLocation::fromFunction(constructor().As<v8::Function>());
+        v8::Local<v8::Value> exception =  V8ThrowException::createDOMException(
+            m_scriptState->isolate(),
+            InvalidStateError,
+            message,
+            constructor());
+        fireErrorEvent(m_scriptState.get(), message, exception, std::move(location));
         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);
 }
 
+void ScriptCustomElementDefinition::fireErrorEvent(ScriptState* scriptState, const String& message, v8::Local<v8::Value> exception, std::unique_ptr<SourceLocation> location)
+{
+    ErrorEvent* event = ErrorEvent::create(message, std::move(location), &scriptState->world());
+    V8ErrorHandler::storeExceptionOnErrorEventWrapper(scriptState, event, exception, scriptState->context()->Global());
+    ExecutionContext* executionContext = scriptState->getExecutionContext();
+    executionContext->reportException(event, NotSharableCrossOrigin);
+}
+
 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.
@@ skipping 21 matching lines @@
 
 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)
+{
+    if (!m_scriptState->contextIsValid())
+        return;
+    ScriptState::Scope scope(m_scriptState.get());
+    v8::Isolate* isolate = m_scriptState->isolate();
+    runCallback(m_adoptedCallback.newLocal(isolate), element);
+}
+
 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();
     const int argc = 4;
     v8::Local<v8::Value> argv[argc] = {
         v8String(isolate, name.localName()),
         v8StringOrNull(isolate, oldValue),
         v8StringOrNull(isolate, newValue),
         v8String(isolate, name.namespaceURI()),
     };
     runCallback(m_attributeChangedCallback.newLocal(isolate), element,
         argc, argv);
 }
 
 } // namespace blink