Introduce CustomElementRegistry#get() method

third_party/WebKit/Source/core/dom/custom/CustomElementsRegistry.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 "core/dom/custom/CustomElementsRegistry.h"
 
 // TODO(dominicc): Stop including Document.h when
 // v0CustomElementIsDefined has been removed.
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "core/dom/Document.h"
 #include "core/dom/ElementRegistrationOptions.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/dom/custom/CustomElementDefinition.h"
 #include "core/dom/custom/V0CustomElementRegistrationContext.h"
 #include "core/dom/custom/V0CustomElementRegistry.h"
 
 namespace blink {
 
+namespace {
+
+const int kConstructorIndex = 0;
+const int kPrototypeIndex = 1;
+const int kSizeOfIdMapEntry = 2;
+
+} // namespace
+
+
 CustomElementsRegistry* CustomElementsRegistry::create(
     ScriptState* scriptState,
     V0CustomElementRegistrationContext* v0)
 {
     DCHECK(scriptState->world().isMainWorld());
     CustomElementsRegistry* registry = new CustomElementsRegistry(v0);
     if (v0)
         v0->setV1(registry);
 
     v8::Isolate* isolate = scriptState->isolate();
@@ skipping 94 matching lines @@
 
     Id id = m_definitions.size();
     v8::Local<v8::Value> idValue = v8::Integer::NewFromUnsigned(isolate, id);
     m_definitions.append(new CustomElementDefinition(
         this,
         id,
         CustomElementDescriptor(name, name)));
     // This map is stored in a hidden reference from the
     // CustomElementsRegistry wrapper.
     v8::Local<v8::Map> map = idMap(scriptState);
+    v8::Local<v8::Array> mapEntry = v8::Array::New(isolate, kSizeOfIdMapEntry);
+    v8CallOrCrash(mapEntry->Set(context, kConstructorIndex, constructor));
+    v8CallOrCrash(mapEntry->Set(context, kPrototypeIndex, prototype));
     // The map keeps the constructor and prototypes alive.
     v8CallOrCrash(map->Set(context, constructor, idValue));
-    v8CallOrCrash(map->Set(context, idValue, prototype));
-    m_names.add(name);
+    v8CallOrCrash(map->Set(context, idValue, mapEntry));
+    m_names.add(name, id);
 
     // TODO(dominicc): Implement steps:
     // 20: when-defined promise processing
     DCHECK(!tryCatch.HasCaught() || tryCatch.HasTerminated());
 }
 
 CustomElementDefinition* CustomElementsRegistry::definitionForConstructor(
     ScriptState* scriptState,
     v8::Local<v8::Value> constructor)
 {
     Id id;
     if (!idForConstructor(scriptState, constructor, id))
         return nullptr;
     return m_definitions[id];
 }
 
+// https://html.spec.whatwg.org/multipage/scripting.html#dom-customelementsregistry-get
+ScriptValue CustomElementsRegistry::get(
+    ScriptState* scriptState,
+    const AtomicString& name)
+{
+    DCHECK(scriptState->world().isMainWorld());
+    const auto& it = m_names.find(name);
+    if (it == m_names.end())
+        return ScriptValue(scriptState, v8Undefined());
+    v8::Local<v8::Context> context = scriptState->context();
+    v8::Local<v8::Map> map = idMap(scriptState);
+    v8::Local<v8::Value> mapEntry = v8CallOrCrash(
+        map->Get(context, toV8(it->value, scriptState)));
+    DCHECK(mapEntry->IsArray()) << *v8::String::Utf8Value(mapEntry);
+    v8::Local<v8::Value> result = v8CallOrCrash(
+        mapEntry.As<v8::Array>()->Get(context, kConstructorIndex));
+    return ScriptValue(scriptState, result);
+}
+
 v8::Local<v8::Object> CustomElementsRegistry::prototype(
     ScriptState* scriptState,
     const CustomElementDefinition& def)
 {
-    v8::Local<v8::Value> idValue =
-        v8::Integer::NewFromUnsigned(scriptState->isolate(), def.id());
-    return v8CallOrCrash(
-        idMap(scriptState)->Get(scriptState->context(), idValue))
-        .As<v8::Object>();
+    v8::Local<v8::Value> idValue = toV8(def.id(), scriptState);
+    v8::Local<v8::Value> mapEntry = v8CallOrCrash(
+        idMap(scriptState)->Get(scriptState->context(), idValue));
+    return mapEntry.As<v8::Array>()->Get(kPrototypeIndex).As<v8::Object>();
 }
 
 bool CustomElementsRegistry::nameIsDefined(const AtomicString& name) const
 {
     return m_names.contains(name);
 }
 
+// Note: Since |toV8(this, scriptState)| requires non-const pointer, we can't
+// make |idMap()| as const function.
 v8::Local<v8::Map> CustomElementsRegistry::idMap(ScriptState* scriptState)
 {
     DCHECK(scriptState->world().isMainWorld());
     v8::Local<v8::Object> wrapper =
         toV8(this, scriptState).As<v8::Object>();
     v8::Local<v8::String> name = V8HiddenValue::customElementsRegistryMap(
         scriptState->isolate());
     return V8HiddenValue::getHiddenValue(scriptState, wrapper, name)
         .As<v8::Map>();
 }
@@ skipping 16 matching lines @@
     return m_v0.get() && m_v0->nameIsDefined(name);
 }
 
 DEFINE_TRACE(CustomElementsRegistry)
 {
     visitor->trace(m_definitions);
     visitor->trace(m_v0);
 }
 
 } // namespace blink