Retrieve prototype during custom element construction.

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/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.
+// if necessary.
 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()) {
@@ skipping 57 matching lines @@
 
   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,
+      scriptState, descriptor, constructor, 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.
+  // We add the 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,
+  keepAlive(array, 0, connectedCallback, definition->m_connectedCallback,
             scriptState);
-  keepAlive(array, 2, disconnectedCallback, definition->m_disconnectedCallback,
+  keepAlive(array, 1, disconnectedCallback, definition->m_disconnectedCallback,
             scriptState);
-  keepAlive(array, 3, adoptedCallback, definition->m_adoptedCallback,
+  keepAlive(array, 2, adoptedCallback, definition->m_adoptedCallback,
             scriptState);
-  keepAlive(array, 4, attributeChangedCallback,
+  keepAlive(array, 3, 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) {}
 
 static void dispatchErrorEvent(v8::Isolate* isolate,
@@ skipping 104 matching lines @@
     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 {
@@ skipping 67 matching lines @@
   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