Implement custom element construction and some 'define' checks

third_party/WebKit/Source/core/dom/custom/CustomElementsRegistry.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/CustomElementsRegistry.h"
 
+// TODO(dominicc): Stop including Document.h when
+// v0CustomElementIsDefined has been removed.
+#include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/ScriptValue.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "core/dom/Document.h"
 #include "core/dom/ElementRegistrationOptions.h"
+#include "core/dom/ExceptionCode.h"
+#include "core/dom/custom/CustomElement.h"
+#include "core/dom/custom/CustomElementDefinition.h"
+#include "core/dom/custom/V0CustomElementRegistrationContext.h"
+#include "core/dom/custom/V0CustomElementRegistry.h"
 
 namespace blink {
 
-CustomElementsRegistry::CustomElementsRegistry()
+CustomElementsRegistry* CustomElementsRegistry::create(
+    ScriptState* scriptState)
+{
+    if (!scriptState)
+        return nullptr;
+    ScriptState::Scope scope(scriptState);
+    ASSERT(DOMWrapperWorld::current(scriptState->isolate()).isMainWorld());
+    return new CustomElementsRegistry(scriptState->isolate());
+}
+
+CustomElementsRegistry::CustomElementsRegistry(v8::Isolate* isolate)
+    : m_constructorIdMap(isolate, v8::NativeWeakMap::New(isolate))
 {
 }
 
+static bool v0CustomElementIsDefined(
+    v8::Isolate* isolate,
+    const AtomicString& name)
+{
+    Document* doc = toDocument(currentExecutionContext(isolate));
+    V0CustomElementRegistrationContext* v0Context = doc->registrationContext();
+    return v0Context && v0Context->registry().nameIsDefined(name);
+}
+
+// http://w3c.github.io/webcomponents/spec/custom/#dfn-element-definition
 void CustomElementsRegistry::define(ScriptState* scriptState,
     const AtomicString& name, const ScriptValue& constructor,
     const ElementRegistrationOptions& options, ExceptionState& exceptionState)
 {
-    // TODO(kojii): Element definition process not implemented yet.
-    // http://w3c.github.io/webcomponents/spec/custom/#dfn-element-definition
+    if (!DOMWrapperWorld::current(scriptState->isolate()).isMainWorld()) {
+        exceptionState.throwDOMException(
+            NotSupportedError,
+            "defining custom elements from extensions is not supported");
+        return;
+    }
+    v8::Isolate* isolate = scriptState->isolate();
+    v8::Local<v8::Context> context = scriptState->context();
+
+    // TODO(dominicc): Make this check for constructors and not just
+    // functions when
+    // https://bugs.chromium.org/p/v8/issues/detail?id=4993 is fixed.
+    v8::Local<v8::Value> constructorValue = constructor.v8Value();
+    if (!constructorValue->IsFunction()) {
+        exceptionState.throwTypeError(
+            "constructor argument is not a constructor");
+        return;
+    }
+    v8::Local<v8::Object> constructorObject =
+        constructorValue.As<v8::Object>();
+
+    // Raise an exception if the name is not valid.
+    if (!CustomElement::isValidName(name)) {
+        exceptionState.throwSyntaxError(
+            "\"" + name + "\" is not a valid custom element name");
+        return;
+    }
+
+    // Raise an exception if the name is already in use.
+    if (nameIsDefined(name) || v0CustomElementIsDefined(isolate, name)) {
+        exceptionState.throwDOMException(
+            NotSupportedError,
+            "this name has already been used with this registry");
+        return;
+    }
+
+    // Raise an exception if the constructor is already registered.
+    if (definitionForConstructor(context, constructorObject)) {
+        exceptionState.throwDOMException(
+            NotSupportedError,
+            "this constructor has already been used with this registry");
+        return;
+    }
+
+    // TODO(dominicc): Implement steps:
+    // 5: localName
+    // 6-7: extends processing
+    // 8-9: observed attributes caching
+
+    v8::TryCatch tryCatch(isolate);
+    v8::MaybeLocal<v8::Value> maybePrototype = constructorObject->Get(
+        context,
+        v8AtomicString(isolate, "prototype"));
+    v8::Local<v8::Value> prototypeValue;
+    if (!maybePrototype.ToLocal(&prototypeValue)) {
+        ASSERT(tryCatch.HasCaught());
+        tryCatch.ReThrow();
+        return;
+    }
+    if (!prototypeValue->IsObject()) {
+        ASSERT(!tryCatch.HasCaught());
+        exceptionState.throwTypeError("constructor prototype is not an object");
+        return;
+    }
+    v8::Local<v8::Object> prototype = prototypeValue.As<v8::Object>();
+
+    // TODO(dominicc): Implement steps:
+    // 12-13: connected callback
+    // 14-15: disconnected callback
+    // 16-17: attribute changed callback
+
+    size_t id = m_definitions.size();
+    m_definitions.append(new CustomElementDefinition(name, isolate, prototype));
+    m_constructorIdMap.Get(isolate)->Set(
+        constructorObject,
+        v8::Integer::NewFromUnsigned(isolate, id));
+    m_names.add(name);
+
+    // TODO(dominicc): Implement steps:
+    // 20: when-defined promise processing
+    ASSERT(!tryCatch.HasCaught() || tryCatch.HasTerminated());
+}
+
+CustomElementDefinition* CustomElementsRegistry::definitionForConstructor(
+    v8::Handle<v8::Context> context,
+    v8::Handle<v8::Value> constructor)
+{
+    v8::Local<v8::Value> entry =
+        m_constructorIdMap.Get(context->GetIsolate())->Get(constructor);
+    if (!entry->IsUint32())
+        return nullptr;
+    return m_definitions[entry->Uint32Value(context).FromJust()];
+}
+
+bool CustomElementsRegistry::nameIsDefined(const AtomicString& name) const
+{
+    return m_names.contains(name);
+}
+
+void CustomElementsRegistry::setWrapperReferences(
+    v8::Isolate* isolate,
+    const v8::Persistent<v8::Object>& wrapper) const
+{
+    for (const auto& def : m_definitions) {
+        def->setReference(isolate, wrapper);
+    }
 }
 
 DEFINE_TRACE(CustomElementsRegistry)
 {
+    visitor->trace(m_definitions);
 }
 
 } // namespace blink