Split custom element script use and move it into bindings

third_party/WebKit/Source/core/dom/custom/README.md

 # Custom Elements
 
 Custom elements let authors create their own elements, with their own
 methods, behavior, and attribute handling. Custom elements shipped in
 M33. We colloquially refer to that version as "v0."
 
 Contact Dominic Cooney
 ([dominicc@chromium.org](mailto:dominicc@chromium.org)) with
 questions.
 
+### Code Location
+
+The custom elements implementation is split between core/dom and
+bindings/core/v8.
+
 ## Design
 
 ### Some Important Classes
 
 ###### CustomElementDefinition
 
-The definition of one ‘class’ of element; it consists of a
-tag name, and a prototype.
+The definition of one ‘class’ of element. This type is
+abstract to permit different kinds of definitions, although at the
+moment there is only one: ScriptCustomElementDefinition.
+
+ScriptCustomElementDefinition is linked to its constructor by an ID
+number. The ID number is stored in a map, keyed by constructor, in a
+hidden value of the CustomElementsRegistry wrapper. The ID is an index
+into a list of definitions stored in V8PerContextData.
+
+###### CustomElementDescriptor
+
+A tuple of local name, and custom element name. For autonomous custom
+elements, these strings are the same; for customized built-in elements
+these strings will be different. In that case, the local name is the
+element's tag name and the custom element name is related to the value
+of the “is” attribute.
 
 ###### CustomElementsRegistry
 
-Implements the `window.customElements` property. This maintains a list
-of definitions, and a mapping from constructors to an index in this
-list. The same map also has indexes as keys and prototypes as values.
+Implements the `window.customElements` property. This maintains the
+set of registered names. The wrapper of this object is used by
+ScriptCustomElementDefinition to cache state in V8.
 
 ###### V8HTMLElement Constructor
 
 The `HTMLElement` interface constructor. When a custom element is
 created from JavaScript all we have to go on is the constructor (in
-`new.target`); this uses CustomElementRegistry’s map to find
-which definition and prototype to use.
+`new.target`); this uses ScriptCustomElementDefinition's state to find
+the definition to use.
 
 ### Memory Management
 
 Once defined, custom element constructors and prototypes have to be
 kept around indefinitely because they could be created in future by
 the parser. On the other hand, we must not leak when a window can no
 longer run script.
 
 We use a V8HiddenValue on the CustomElementsRegistry wrapper which
-points to a map that keeps constructors and prototypes alive.
+points to a map that keeps constructors and prototypes alive. See
+ScriptCustomElementDefinition.
 
 ## Style Guide
 
 In comments and prose, write custom elements, not Custom Elements, to
 match the HTML standard.
 
 Prefix type names with CustomElement (singular). The one exception to
 this rule is CustomElementsRegistry, which uses a plural to match the
 name of the interface in the specification.
 
@@ skipping 77 matching lines @@
    may remove it even sooner, if we have evidence that sites are using
    feature detection correctly.
 
 ## References
 
 These have links to the parts of the DOM and HTML specs which define
 custom elements:
 
 * [WHATWG DOM Wiki: Custom Elements](https://github.com/whatwg/dom/wiki#custom-elements)
 * [WHATWG HTML Wiki: Custom Elements](https://github.com/whatwg/html/wiki#custom-elements)