Custom Elements: Lookup custom element definition algorithm

third_party/WebKit/Source/core/dom/custom/CustomElementTest.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/HTMLNames.h"
 #include "core/SVGNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/custom/CustomElementDefinition.h"
@@ skipping 211 matching lines @@
   EXPECT_NE(nullptr, definition) << "a-a should be registered";
 
   // create an element with an uppercase tag name
   Document& document = holder->document();
   EXPECT_TRUE(document.isHTMLDocument())
       << "this test requires a HTML document";
   Element* element = document.createElement("A-A", shouldNotThrow);
   EXPECT_EQ(definition, element->customElementDefinition());
 }
 
+TEST(CustomElementTest, CreateElement_LookupCustomElement) {

[dominicc (has gone to gerrit), 2016/10/27 04:33:14]

Could we put this in CustomElementRegistryTest? definitionFor is a
CustomElementRegistry method.

+  // register a definition
+  std::unique_ptr<DummyPageHolder> holder(DummyPageHolder::create());
+  CustomElementRegistry* registry =
+      holder->frame().localDOMWindow()->customElements();
+  NonThrowableExceptionState shouldNotThrow;
+  {
+    CEReactionsScope reactions;
+    TestCustomElementDefinitionBuilder builder;
+    registry->define("a-a", builder, ElementDefinitionOptions(),
+                     shouldNotThrow);
+    ElementDefinitionOptions options;
+    options.setExtends("div");
+    registry->define("b-b", builder, options, shouldNotThrow);
+  }
+  CustomElementDefinition* definition =
+      registry->definitionFor(CustomElementDescriptor("a-a", "a-a"));
+  // lookup defined autonomous custom element

[dominicc (has gone to gerrit), 2016/10/27 04:33:14]

lookup -> look up

+  EXPECT_NE(nullptr, definition) << "a-a, a-a should be registered";

[dominicc (has gone to gerrit), 2016/10/27 04:33:14]

It would be more precise to hang onto the definition and test equality with it.
Let's make define return a CustomElementDefinition*.

+  EXPECT_EQ(AtomicString("a-a"), definition->descriptor().name());

[dominicc (has gone to gerrit), 2016/10/27 04:33:14]

Just use EXPECT_EQ(..., definition->descriptor()) etc. it already knows how to
compare both name and local name.

+  EXPECT_EQ(AtomicString("a-a"), definition->descriptor().localName());
+  // lookup undefined autonomous custom element
+  definition = registry->definitionFor(CustomElementDescriptor("a-b", "a-b"));
+  EXPECT_EQ(nullptr, definition) << "a-b, a-b should not be registered";
+  // lookup defined customized built-in element
+  // TODO(yurak): uncomment once the define algorithm is committed

[dominicc (has gone to gerrit), 2016/10/27 04:33:14]

Maybe just omit this instead of adding commented out code. That way we'll get
new functionality, new test which makes for a nice patch.

+  /*definition = registry->definitionFor(CustomElementDescriptor("b-b", "div"));
+  EXPECT_NE(nullptr, definition) << "b-b, div should be registered";
+  EXPECT_EQ(AtomicString("b-b"), definition->descriptor()->name());
+  EXPECT_EQ(AtomicString("div"), definition->descriptor()->localName());*/
+  // lookup undefined customized built-in element
+  definition = registry->definitionFor(CustomElementDescriptor("a-a", "div"));
+  EXPECT_EQ(nullptr, definition) << "a-a, div should not be registered";
+}
+
 }  // namespace blink