Rename CustomElementsRegistry to CustomElementRegistry

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"
+#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.
-static v8::Local<v8::Map> ensureCustomElementsRegistryMap(
+static v8::Local<v8::Map> ensureCustomElementRegistryMap(
     ScriptState* scriptState,
-    CustomElementsRegistry* registry)
+    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()) {
         map = v8::Map::New(scriptState->isolate());
         V8HiddenValue::setHiddenValue(scriptState, wrapper, name, map);
     }
     return map.As<v8::Map>();
 }
 
 ScriptCustomElementDefinition* ScriptCustomElementDefinition::forConstructor(
     ScriptState* scriptState,
-    CustomElementsRegistry* registry,
+    CustomElementRegistry* registry,
     const v8::Local<v8::Value>& constructor)
 {
     v8::Local<v8::Map> map =
-        ensureCustomElementsRegistryMap(scriptState, registry);
+        ensureCustomElementRegistryMap(scriptState, registry);
     v8::Local<v8::Value> nameValue = map->Get(scriptState->context(), constructor).ToLocalChecked();
     if (!nameValue->IsString())
         return nullptr;
     AtomicString name = toCoreAtomicString(nameValue.As<v8::String>());
 
     // This downcast is safe because only
     // ScriptCustomElementDefinitions have a name associated with a V8
     // constructor in the map; see
     // ScriptCustomElementDefinition::create. This relies on three
     // things:
     //
     // 1. Only ScriptCustomElementDefinition adds entries to the map.
     //    Audit the use of V8HiddenValue/hidden values in general and
     //    how the map is handled--it should never be leaked to script.
     //
-    // 2. CustomElementsRegistry does not overwrite definitions with a
-    //    given name--see the CHECK in CustomElementsRegistry::define
+    // 2. CustomElementRegistry does not overwrite definitions with a
+    //    given name--see the CHECK in CustomElementRegistry::define
     //    --and adds ScriptCustomElementDefinitions to the map without
     //    fail.
     //
-    // 3. The relationship between the CustomElementsRegistry and its
+    // 3. The relationship between the CustomElementRegistry and its
     //    map is never mixed up; this is guaranteed by the bindings
     //    system which provides a stable wrapper, and the map hangs
     //    off the wrapper.
     //
     // 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);
@@ skipping 10 matching lines @@
         return;
 
     array->Set(scriptState->context(), index, value).ToChecked();
 
     persistent.set(scriptState->isolate(), value);
     persistent.setPhantom();
 }
 
 ScriptCustomElementDefinition* ScriptCustomElementDefinition::create(
     ScriptState* scriptState,
-    CustomElementsRegistry* registry,
+    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,
             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);
+        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.
     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, adoptedCallback, definition->m_adoptedCallback, scriptState);
@@ skipping 231 matching lines @@
         v8String(isolate, name.localName()),
         v8StringOrNull(isolate, oldValue),
         v8StringOrNull(isolate, newValue),
         v8String(isolate, name.namespaceURI()),
     };
     runCallback(m_attributeChangedCallback.newLocal(isolate), element,
         argc, argv);
 }
 
 } // namespace blink