Make customElements.define faster

third_party/WebKit/Source/core/dom/custom/CustomElementRegistry.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/CustomElementRegistry.h"
 
+#include <limits>
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptCustomElementDefinitionBuilder.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/HTMLElementTypeHelpers.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementDefinitionOptions.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/custom/CEReactionsScope.h"
@@ skipping 69 matching lines @@
 DEFINE_TRACE(CustomElementRegistry) {
   visitor->Trace(definitions_);
   visitor->Trace(owner_);
   visitor->Trace(v0_);
   visitor->Trace(upgrade_candidates_);
   visitor->Trace(when_defined_promise_map_);
 }
 
 DEFINE_TRACE_WRAPPERS(CustomElementRegistry) {
   visitor->TraceWrappers(&CustomElementReactionStack::Current());
+  for (auto definition : definitions_)
+    visitor->TraceWrappers(definition);
 }
 
 CustomElementDefinition* CustomElementRegistry::define(
     ScriptState* script_state,
     const AtomicString& name,
     const ScriptValue& constructor,
     const ElementDefinitionOptions& options,
     ExceptionState& exception_state) {
   ScriptCustomElementDefinitionBuilder builder(script_state, this, constructor,
                                                exception_state);
@@ skipping 70 matching lines @@
       return nullptr;
 
     // "Then, perform the following substep, regardless of whether
     // the above steps threw an exception or not: Unset this
     // CustomElementRegistry's element definition is running
     // flag."
     // (ElementDefinitionIsRunning destructor does this.)
   }
 
   CustomElementDescriptor descriptor(name, local_name);
-  CustomElementDefinition* definition = builder.Build(descriptor);
+  if (UNLIKELY(definitions_.size() >= std::numeric_limits<uint32_t>::max()))
+    return nullptr;
+  uint32_t id = definitions_.size() + 1;
+  CustomElementDefinition* definition = builder.Build(descriptor, id);
   CHECK(!exception_state.HadException());
   CHECK(definition->Descriptor() == descriptor);
-  DefinitionMap::AddResult result =
-      definitions_.insert(descriptor.GetName(), definition);
+  definitions_.emplace_back(
+      TraceWrapperMember<CustomElementDefinition>(this, definition));
+  DefinitionMap::AddResult result = nameIdMap_.insert(descriptor.GetName(), id);
   CHECK(result.is_new_entry);
 
   HeapVector<Member<Element>> candidates;
   CollectCandidates(descriptor, &candidates);
   for (Element* candidate : candidates)
     definition->EnqueueUpgradeReaction(candidate);
 
   // 16: when-defined promise processing
   const auto& entry = when_defined_promise_map_.find(name);
   if (entry != when_defined_promise_map_.end()) {
@@ skipping 26 matching lines @@
     definition = DefinitionForName(desc.GetName());
   // 4&5. ...and local name equal to localName, return that definition
   if (definition and definition->Descriptor().LocalName() == desc.LocalName()) {
     return definition;
   }
   // 6. Return null
   return nullptr;
 }
 
 bool CustomElementRegistry::NameIsDefined(const AtomicString& name) const {
-  return definitions_.Contains(name);
+  return nameIdMap_.Contains(name);
 }
 
 void CustomElementRegistry::Entangle(V0CustomElementRegistrationContext* v0) {
   v0_->insert(v0);
   v0->SetV1(this);
 }
 
 bool CustomElementRegistry::V0NameIsDefined(const AtomicString& name) {
   for (const auto& v0 : *v0_) {
     if (v0->NameIsDefined(name))
       return true;
   }
   return false;
 }
 
 CustomElementDefinition* CustomElementRegistry::DefinitionForName(
     const AtomicString& name) const {
-  return definitions_.at(name);
+  return DefinitionForId(nameIdMap_.at(name));
+}
+
+CustomElementDefinition* CustomElementRegistry::DefinitionForId(
+    CustomElementDefinition::Id id) const {

[kochi, 2017/04/28 06:24:15]

Add DCHECK(id <= difinitions_.size())?

+  return id ? definitions_[id - 1].Get() : nullptr;
 }
 
 void CustomElementRegistry::AddCandidate(Element* candidate) {
   const AtomicString& name = candidate->localName();
   if (NameIsDefined(name) || V0NameIsDefined(name))
     return;
   UpgradeCandidateMap::iterator it = upgrade_candidates_->find(name);
   UpgradeCandidateSet* set;
   if (it != upgrade_candidates_->end()) {
     set = it->value;
@@ skipping 39 matching lines @@
   upgrade_candidates_->erase(it);
 
   Document* document = owner_->document();
   if (!document)
     return;
 
   sorter.Sorted(elements, document);
 }
 
 }  // namespace blink