Add callbacks to ScriptCustomElementDefinition

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/V8CustomElementsRegistry.h"
 #include "bindings/core/v8/V8HiddenValue.h"
@@ skipping 56 matching lines @@
     //
     // 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);
 }
 
+static void keepAlive(v8::Local<v8::Array>& array, uint32_t index,
+    const v8::Local<v8::Object>& value,
+    ScopedPersistent<v8::Object>& persistent,
+    ScriptState* scriptState)
+{
+    if (value.IsEmpty())
+        return;
+
+    v8CallOrCrash(array->Set(scriptState->context(), index, value));
+
+    persistent.set(scriptState->isolate(), value);
+    persistent.setPhantom();

[haraken, 2016/06/06 01:39:15]

Why do you need to create a phantom handle? I think that just setting the handle
on the array would be enough to keep the V8 object alive.

[kojii, 2016/06/06 11:12:34]

This is for perf to retrieve the value without going through v8 map, while v8
object is to keep it alive.

Should I just keep a pointer, not ScopedPersistent in this case?

+}
+
 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::Object>& prototype,
+    const v8::Local<v8::Object>& connectedCallback,
+    const v8::Local<v8::Object>& disconnectedCallback,
+    const v8::Local<v8::Object>& attributeChangedCallback,
+    const HashSet<AtomicString>& observedAttributes)
 {
     ScriptCustomElementDefinition* definition =
         new ScriptCustomElementDefinition(
             scriptState,
             descriptor,
             constructor,
-            prototype);
+            prototype,
+            connectedCallback,
+            disconnectedCallback,
+            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));
-    // We add the prototype here to keep it alive; we make it a value
-    // not a key so authors cannot return another constructor as a
-    // prototype to overwrite a constructor in this map. We use the
-    // name because it is unique per-registry.
-    v8CallOrCrash(map->Set(scriptState->context(), nameValue, prototype));
+    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);
+    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);
+    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::Object>& prototype,
+    const v8::Local<v8::Object>& connectedCallback,
+    const v8::Local<v8::Object>& disconnectedCallback,
+    const v8::Local<v8::Object>& attributeChangedCallback,
+    const HashSet<AtomicString>& observedAttributes)
     : CustomElementDefinition(descriptor)
     , m_scriptState(scriptState)
     , m_constructor(scriptState->isolate(), constructor)
-    , m_prototype(scriptState->isolate(), prototype)
+    , m_observedAttributes(observedAttributes)
 {
-    // These objects are kept alive by references from the
-    // CustomElementsRegistry wrapper set up by
-    // ScriptCustomElementDefinition::create.
-    m_constructor.setPhantom();
-    m_prototype.setPhantom();
 }
 
 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());
 }
 
 } // namespace blink