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"
@@ skipping 88 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);
     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(), 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, 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,
@@ skipping 63 matching lines @@
     // 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 differnt object
+    // 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";
-
         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;
     }
 
@@ skipping 47 matching lines @@
 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