Implement "create an element" when sync for Custom Element V1

third_party/WebKit/Source/core/dom/custom/CustomElement.h

 // 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.
 
 #ifndef CustomElement_h
 #define CustomElement_h
 
 #include "core/CoreExport.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Element.h"
@@ skipping 37 matching lines @@
         return isValidName(element.localName())
             && element.namespaceURI() == HTMLNames::xhtmlNamespaceURI;
     }
 
     static bool isValidName(const AtomicString& name);
 
     static bool shouldCreateCustomElement(Document&, const AtomicString& localName);
     static bool shouldCreateCustomElement(Document&, const QualifiedName&);
 
     static HTMLElement* createCustomElement(Document&, const AtomicString& localName, CreateElementFlags);
+    static HTMLElement* createCustomElement(Document&, const AtomicString& localName, CreateElementFlags, ExceptionState&);
     static HTMLElement* createCustomElement(Document&, const QualifiedName&, CreateElementFlags);
+    static HTMLElement* createCustomElement(Document&, const QualifiedName&, CreateElementFlags, ExceptionState&);
 
     static void enqueueUpgradeReaction(Element*, CustomElementDefinition*);
 
 private:
+    static HTMLElement* createCustomElement(Document&, const QualifiedName&, CreateElementFlags, ExceptionState*);

[dominicc (has gone to gerrit), 2016/06/10 06:13:28]

I don't like how things have ended up here. You have ExceptionState/no
ExceptionState variants because the caller needs us to swallow (and report)
exceptions or transmit them back.

Then you compress that down to this method with an optional exception state.

Then you decompress that to overloads which do/don't take ExceptionState.

Why not give these methods which behave really differently different names and
the right signatures, and have them each call the exactly right implementation?
So:

createCustomElementSync(..., ExceptionState&);
createCustomElementSync(...);
createCustomElementAsync(...);

This is better. It stops the caller from doing something weird like "create
custom element asynchronously and put exception state here." There's nothing
that needs that AFAIK, and we don't implement that, but your signatures support
that. Seems complex and error prone. Let's keep it simple.

I DON'T think we need the create element flags here (what are they used for
except sync/async?)

[kojii, 2016/06/10 19:01:45]

Done. It used to use CreatedByParser too, but that was replaced by optional
ExceptionState.

     static HTMLElement* createCustomElementAsync(Document&, CustomElementDefinition&, const QualifiedName&);
 };
 
 } // namespace blink
 
 #endif // CustomElement_h