Remove first argument for shoudCreateCustomElement()

third_party/WebKit/Source/core/dom/custom/CustomElement.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/CustomElement.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/QualifiedName.h"
 #include "core/dom/custom/CEReactionsScope.h"
 #include "core/dom/custom/CustomElementDefinition.h"
@@ skipping 60 matching lines @@
         "font-face",
         "font-face-src",
         "font-face-uri",
         "font-face-format",
         "font-face-name",
         "missing-glyph",
     }));
     return !hyphenContainingElementNames.contains(name);
 }
 
-bool CustomElement::shouldCreateCustomElement(Document& document, const AtomicString& localName)
+bool CustomElement::shouldCreateCustomElement(const AtomicString& localName)
 {
     return RuntimeEnabledFeatures::customElementsV1Enabled()
         && isValidName(localName);
 }
 
-bool CustomElement::shouldCreateCustomElement(Document& document, const QualifiedName& tagName)
+bool CustomElement::shouldCreateCustomElement(const QualifiedName& tagName)
 {
-    return shouldCreateCustomElement(document, tagName.localName())
+    return shouldCreateCustomElement(tagName.localName())
         && tagName.namespaceURI() == HTMLNames::xhtmlNamespaceURI;
 }
 
 static CustomElementDefinition* definitionForName(const Document& document, const QualifiedName& name)
 {
     if (CustomElementsRegistry* registry = CustomElement::registry(document))
         return registry->definitionForName(name.localName());
     return nullptr;
 }
 
 HTMLElement* CustomElement::createCustomElementSync(Document& document, const AtomicString& localName, ExceptionState& exceptionState)
 {
     return createCustomElementSync(document,
         QualifiedName(nullAtom, localName, HTMLNames::xhtmlNamespaceURI),
         exceptionState);
 }
 
 HTMLElement* CustomElement::createCustomElementSync(Document& document, const QualifiedName& tagName, ExceptionState& exceptionState)
 {
-    CHECK(shouldCreateCustomElement(document, tagName));
+    CHECK(shouldCreateCustomElement(tagName));
 
     // To create an element:
     // https://dom.spec.whatwg.org/#concept-create-element
     // 6. If definition is non-null, then:
     // 6.1. If the synchronous custom elements flag is set:
     if (CustomElementDefinition* definition = definitionForName(document, tagName))
         return definition->createElementSync(document, tagName, exceptionState);
 
     return createUndefinedElement(document, tagName);
 }
 
 HTMLElement* CustomElement::createCustomElementSync(Document& document, const QualifiedName& tagName)
 {
-    CHECK(shouldCreateCustomElement(document, tagName));
+    CHECK(shouldCreateCustomElement(tagName));
 
     // When invoked from "create an element for a token":
     // https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token
     // 7. If this step throws an exception, then report the exception,
     // and let element be instead a new element that implements
     // HTMLUnknownElement.
     if (CustomElementDefinition* definition = definitionForName(document, tagName))
         return definition->createElementSync(document, tagName);
 
     return createUndefinedElement(document, tagName);
 }
 
 HTMLElement* CustomElement::createCustomElementAsync(Document& document, const QualifiedName& tagName)
 {
-    CHECK(shouldCreateCustomElement(document, tagName));
+    CHECK(shouldCreateCustomElement(tagName));
 
     // To create an element:
     // https://dom.spec.whatwg.org/#concept-create-element
     // 6. If definition is non-null, then:
     // 6.2. If the synchronous custom elements flag is not set:
     if (CustomElementDefinition* definition = definitionForName(document, tagName))
         return definition->createElementAsync(document, tagName);
 
     return createUndefinedElement(document, tagName);
 }
 
 HTMLElement* CustomElement::createUndefinedElement(Document& document, const QualifiedName& tagName)
 {
-    DCHECK(shouldCreateCustomElement(document, tagName));
+    DCHECK(shouldCreateCustomElement(tagName));
 
     HTMLElement* element;
     if (V0CustomElement::isValidName(tagName.localName()) && document.registrationContext()) {
         Element* v0element = document.registrationContext()->createCustomTagElement(document, tagName);
         SECURITY_DCHECK(v0element->isHTMLElement());
         element = toHTMLElement(v0element);
     } else {
         element = HTMLElement::create(tagName, document);
     }
 
     element->setCustomElementState(CustomElementState::Undefined);
 
     return element;
 }
 
 HTMLElement* CustomElement::createFailedElement(Document& document, const QualifiedName& tagName)
 {
-    DCHECK(shouldCreateCustomElement(document, tagName));
+    DCHECK(shouldCreateCustomElement(tagName));
 
     // "create an element for a token":
     // https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token
 
     // 7. If this step throws an exception, let element be instead a new element
     // that implements HTMLUnknownElement, with no attributes, namespace set to
     // given namespace, namespace prefix set to null, custom element state set
     // to "failed", and node document set to document.
 
     HTMLElement* element = HTMLUnknownElement::create(tagName, document);
@@ skipping 59 matching lines @@
     CustomElementsRegistry* registry = CustomElement::registry(*element);
     if (!registry)
         return;
     if (CustomElementDefinition* definition = registry->definitionForName(element->localName()))
         definition->enqueueUpgradeReaction(element);
     else
         registry->addCandidate(element);
 }
 
 } // namespace blink