Revert of Implement script-side of callback reactions for Custom Elements V1

third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinitionBuilder.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/ScriptCustomElementDefinitionBuilder.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptCustomElementDefinition.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 95 matching lines @@
             "constructor prototype is not an object");
         return false;
     }
     m_prototype = prototypeValue.As<v8::Object>();
     // If retrieving the prototype destroyed the context, indicate that
     // defining the element should not proceed.
     return true;
 }
 
 bool ScriptCustomElementDefinitionBuilder::callableForName(const String& name,
-    v8::Local<v8::Function>& callback) const
+    v8::Local<v8::Object>& callback) const
 {
     v8::Local<v8::Value> value;
     if (!valueForName(m_prototype, name, value))
         return false;
     // "undefined" means "omitted", so return true.
     if (value->IsUndefined())
         return true;
-    if (!value->IsFunction()) {
+    if (!value->IsObject()) {
         m_exceptionState.throwTypeError(
-            String::format("\"%s\" is not a callable object", name.ascii().data()));
+            String::format("\"%s\" is not an object", name.ascii().data()));
         return false;
     }
-    callback = value.As<v8::Function>();
+    callback = value.As<v8::Object>();
+    if (!callback->IsCallable()) {
+        m_exceptionState.throwTypeError(
+            String::format("\"%s\" is not callable", name.ascii().data()));
+        return false;
+    }
     return true;
 }
 
 bool ScriptCustomElementDefinitionBuilder::retrieveObservedAttributes()
 {
     const String kObservedAttributes = "observedAttributes";
     v8::Local<v8::Value> observedAttributesValue;
     if (!valueForName(m_constructor, kObservedAttributes, observedAttributesValue))
         return false;
     if (observedAttributesValue->IsUndefined())
@@ skipping 10 matching lines @@
     return true;
 }
 
 bool ScriptCustomElementDefinitionBuilder::rememberOriginalProperties()
 {
     // Spec requires to use values of these properties at the point
     // CustomElementDefinition is built, even if JS changes them afterwards.
     const String kConnectedCallback = "connectedCallback";
     const String kDisconnectedCallback = "disconnectedCallback";
     const String kAttributeChangedCallback = "attributeChangedCallback";
-    return callableForName(kConnectedCallback, m_connectedCallback)
+    return retrieveObservedAttributes()
+        && callableForName(kConnectedCallback, m_connectedCallback)
         && callableForName(kDisconnectedCallback, m_disconnectedCallback)
-        && callableForName(kAttributeChangedCallback, m_attributeChangedCallback)
-        && (m_attributeChangedCallback.IsEmpty() || retrieveObservedAttributes());
+        && callableForName(kAttributeChangedCallback, m_attributeChangedCallback);
 }
 
 CustomElementDefinition* ScriptCustomElementDefinitionBuilder::build(
     const CustomElementDescriptor& descriptor)
 {
     return ScriptCustomElementDefinition::create(
         m_scriptState.get(),
         m_registry,
         descriptor,
         m_constructor,
         m_prototype,
         m_connectedCallback,
         m_disconnectedCallback,
         m_attributeChangedCallback,
         m_observedAttributes);
 }
 
 } // namespace blink