Make customElements.define faster

third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinition.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 "bindings/core/v8/ScriptCustomElementDefinition.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8CustomElementRegistry.h"
 #include "bindings/core/v8/V8Element.h"
 #include "bindings/core/v8/V8ErrorHandler.h"
 #include "bindings/core/v8/V8PrivateProperty.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/events/ErrorEvent.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "platform/wtf/Allocator.h"
 #include "v8.h"
 
 namespace blink {
 
-// Retrieves the custom elements constructor -> name map, creating it
-// if necessary.
-static v8::Local<v8::Map> EnsureCustomElementRegistryMap(
-    ScriptState* script_state,
-    CustomElementRegistry* registry) {
-  CHECK(script_state->World().IsMainWorld());
-  v8::Isolate* isolate = script_state->GetIsolate();
-
-  V8PrivateProperty::Symbol symbol =
-      V8PrivateProperty::GetCustomElementRegistryMap(isolate);
-  v8::Local<v8::Object> wrapper = ToV8(registry, script_state).As<v8::Object>();
-  v8::Local<v8::Value> map = symbol.GetOrUndefined(wrapper);
-  if (map->IsUndefined()) {
-    map = v8::Map::New(isolate);
-    symbol.Set(wrapper, map);
-  }
-  return map.As<v8::Map>();
-}
-
 ScriptCustomElementDefinition* ScriptCustomElementDefinition::ForConstructor(
     ScriptState* script_state,
     CustomElementRegistry* registry,
     const v8::Local<v8::Value>& constructor) {
-  v8::Local<v8::Map> map =
-      EnsureCustomElementRegistryMap(script_state, registry);
-  v8::Local<v8::Value> name_value =
-      map->Get(script_state->GetContext(), constructor).ToLocalChecked();
-  if (!name_value->IsString())
+  if (!constructor->IsObject())
     return nullptr;
-  AtomicString name = ToCoreAtomicString(name_value.As<v8::String>());
+  auto private_id =
+      script_state->PerContextData()->GetPrivateCustomElementDefinitionId();
+  v8::Local<v8::Value> id_value;
+  if (!V8Call(constructor.As<v8::Object>()->GetPrivate(
+                  script_state->GetContext(), private_id),
+              id_value))
+    return nullptr;
+  if (!id_value->IsUint32())
+    return nullptr;
+  uint32_t id = id_value.As<v8::Uint32>()->Value();
 
   // This downcast is safe because only
   // ScriptCustomElementDefinitions have a name associated with a V8
   // constructor in the map; see
   // ScriptCustomElementDefinition::create. This relies on three
   // things:
   //
   // 1. Only ScriptCustomElementDefinition adds entries to the map.
   //    Audit the use of private properties in general and how the
   //    map is handled--it should never be leaked to script.
   //
   // 2. CustomElementRegistry does not overwrite definitions with a
   //    given name--see the CHECK in CustomElementRegistry::define
   //    --and adds ScriptCustomElementDefinitions to the map without
   //    fail.
   //
   // 3. The relationship between the CustomElementRegistry and its
   //    map is never mixed up; this is guaranteed by the bindings
   //    system which provides a stable wrapper, and the map hangs
   //    off the wrapper.
   //
   // At a meta-level, this downcast is safe because there is
   // currently only one implementation of CustomElementDefinition in
   // product code and that is ScriptCustomElementDefinition. But
   // that may change in the future.
-  CustomElementDefinition* definition = registry->DefinitionForName(name);
+  CustomElementDefinition* definition = registry->DefinitionForId(id);
   CHECK(definition);
-  return static_cast<ScriptCustomElementDefinition*>(definition);
+  ScriptCustomElementDefinition* scriptDefinition =
+      static_cast<ScriptCustomElementDefinition*>(definition);
+  // v8::Object::GetPrivate notes that private properties may be
+  // inherited in future, so check that the definition's constructor
+  // is exactly the passed object.
+  return scriptDefinition->constructor_.Get() == constructor ? scriptDefinition
+                                                             : nullptr;
 }
 
 using SymbolGetter = V8PrivateProperty::Symbol (*)(v8::Isolate*);
 
 template <typename T>
 static void KeepAlive(v8::Local<v8::Object>& object,
                       SymbolGetter symbol_getter,
                       const v8::Local<T>& value,
                       ScopedPersistent<T>& persistent,
                       ScriptState* script_state) {
   if (value.IsEmpty())
     return;
 
   v8::Isolate* isolate = script_state->GetIsolate();
   symbol_getter(isolate).Set(object, value);
   persistent.Set(isolate, value);
   persistent.SetPhantom();
 }
 
 ScriptCustomElementDefinition* ScriptCustomElementDefinition::Create(
     ScriptState* script_state,
     CustomElementRegistry* registry,
     const CustomElementDescriptor& descriptor,
+    CustomElementDefinition::Id id,
     const v8::Local<v8::Object>& constructor,
     const v8::Local<v8::Function>& connected_callback,
     const v8::Local<v8::Function>& disconnected_callback,
     const v8::Local<v8::Function>& adopted_callback,
     const v8::Local<v8::Function>& attribute_changed_callback,
     const HashSet<AtomicString>& observed_attributes) {
-  ScriptCustomElementDefinition* definition = new ScriptCustomElementDefinition(
+  auto private_id =
+      script_state->PerContextData()->GetPrivateCustomElementDefinitionId();
+  CHECK(constructor
+            ->SetPrivate(
+                script_state->GetContext(), private_id,
+                v8::Integer::NewFromUnsigned(script_state->GetIsolate(), id))
+            .ToChecked());
+  return new ScriptCustomElementDefinition(
       script_state, descriptor, constructor, connected_callback,
       disconnected_callback, adopted_callback, attribute_changed_callback,
       observed_attributes);
-
-  // Add a constructor -> name mapping to the registry.
-  v8::Local<v8::Value> name_value =
-      V8String(script_state->GetIsolate(), descriptor.GetName());
-  v8::Local<v8::Map> map =
-      EnsureCustomElementRegistryMap(script_state, registry);
-  map->Set(script_state->GetContext(), constructor, name_value)
-      .ToLocalChecked();
-  definition->constructor_.SetPhantom();
-
-  // We add the callbacks here to keep them alive. We use the name as
-  // the key because it is unique per-registry.
-  v8::Local<v8::Object> object = v8::Object::New(script_state->GetIsolate());
-  KeepAlive(object, V8PrivateProperty::GetCustomElementConnectedCallback,
-            connected_callback, definition->connected_callback_, script_state);
-  KeepAlive(object, V8PrivateProperty::GetCustomElementDisconnectedCallback,
-            disconnected_callback, definition->disconnected_callback_,
-            script_state);
-  KeepAlive(object, V8PrivateProperty::GetCustomElementAdoptedCallback,
-            adopted_callback, definition->adopted_callback_, script_state);
-  KeepAlive(object, V8PrivateProperty::GetCustomElementAttributeChangedCallback,
-            attribute_changed_callback, definition->attribute_changed_callback_,
-            script_state);
-  map->Set(script_state->GetContext(), name_value, object).ToLocalChecked();
-
-  return definition;
 }
 
 ScriptCustomElementDefinition::ScriptCustomElementDefinition(
     ScriptState* script_state,
     const CustomElementDescriptor& descriptor,
     const v8::Local<v8::Object>& constructor,
     const v8::Local<v8::Function>& connected_callback,
     const v8::Local<v8::Function>& disconnected_callback,
     const v8::Local<v8::Function>& adopted_callback,
     const v8::Local<v8::Function>& attribute_changed_callback,
     const HashSet<AtomicString>& observed_attributes)
     : CustomElementDefinition(descriptor, observed_attributes),
       script_state_(script_state),
-      constructor_(script_state->GetIsolate(), constructor) {}
+      constructor_(script_state->GetIsolate(), this, constructor),
+      connected_callback_(this),
+      disconnected_callback_(this),
+      adopted_callback_(this),
+      attribute_changed_callback_(this) {
+  v8::Isolate* isolate = script_state->GetIsolate();
+  if (!connected_callback.IsEmpty())
+    connected_callback_.Set(isolate, connected_callback);
+  if (!disconnected_callback.IsEmpty())
+    disconnected_callback_.Set(isolate, disconnected_callback);
+  if (!adopted_callback.IsEmpty())
+    adopted_callback_.Set(isolate, adopted_callback);
+  if (!attribute_changed_callback.IsEmpty())
+    attribute_changed_callback_.Set(isolate, attribute_changed_callback);
+}
 
 static void DispatchErrorEvent(v8::Isolate* isolate,
                                v8::Local<v8::Value> exception,
                                v8::Local<v8::Object> constructor) {
   v8::TryCatch try_catch(isolate);
   try_catch.SetVerbose(true);
   V8ScriptRunner::ThrowException(
       isolate, exception, constructor.As<v8::Function>()->GetScriptOrigin());
 }
 
+DEFINE_TRACE_WRAPPERS(ScriptCustomElementDefinition) {
+  visitor->TraceWrappers(constructor_);
+  visitor->TraceWrappers(connected_callback_);

[Michael Lippautz, 2017/04/19 08:49:12]

Continued from the declaration: 
  visitor->TraceWrappers(connected_callback.Cast<v8::Value>());

+  visitor->TraceWrappers(disconnected_callback_);
+  visitor->TraceWrappers(adopted_callback_);
+  visitor->TraceWrappers(attribute_changed_callback_);
+}
+
 HTMLElement* ScriptCustomElementDefinition::HandleCreateElementSyncException(
     Document& document,
     const QualifiedName& tag_name,
     v8::Isolate* isolate,
     ExceptionState& exception_state) {
   DCHECK(exception_state.HadException());
   // 6.1."If any of these subsubsteps threw an exception".1
   // Report the exception.
   DispatchErrorEvent(isolate, exception_state.GetException(), Constructor());
   exception_state.ClearException();
@@ skipping 99 matching lines @@
   if (!V8Call(V8ScriptRunner::CallAsConstructor(isolate, Constructor(),
                                                 execution_context, 0, nullptr),
               result)) {
     return nullptr;
   }
   return V8Element::toImplWithTypeCheck(isolate, result);
 }
 
 v8::Local<v8::Object> ScriptCustomElementDefinition::Constructor() const {
   DCHECK(!constructor_.IsEmpty());
-  return constructor_.NewLocal(script_state_->GetIsolate());
+  return constructor_.NewLocal(script_state_->GetIsolate()).As<v8::Object>();

[Michael Lippautz, 2017/04/19 08:49:12]

This cast is not needed then. 

(And all below.)

 }
 
 // CustomElementDefinition
 ScriptValue ScriptCustomElementDefinition::GetConstructorForScript() {
   return ScriptValue(script_state_.Get(), Constructor());
 }
 
 bool ScriptCustomElementDefinition::HasConnectedCallback() const {
   return !connected_callback_.IsEmpty();
 }
@@ skipping 26 matching lines @@
       ToV8(element, script_state_->GetContext()->Global(), isolate);
   V8ScriptRunner::CallFunction(callback, execution_context, element_handle,
                                argc, argv, isolate);
 }
 
 void ScriptCustomElementDefinition::RunConnectedCallback(Element* element) {
   if (!script_state_->ContextIsValid())
     return;
   ScriptState::Scope scope(script_state_.Get());
   v8::Isolate* isolate = script_state_->GetIsolate();
-  RunCallback(connected_callback_.NewLocal(isolate), element);
+  RunCallback(connected_callback_.NewLocal(isolate).As<v8::Function>(),
+              element);
 }
 
 void ScriptCustomElementDefinition::RunDisconnectedCallback(Element* element) {
   if (!script_state_->ContextIsValid())
     return;
   ScriptState::Scope scope(script_state_.Get());
   v8::Isolate* isolate = script_state_->GetIsolate();
-  RunCallback(disconnected_callback_.NewLocal(isolate), element);
+  RunCallback(disconnected_callback_.NewLocal(isolate).As<v8::Function>(),
+              element);
 }
 
 void ScriptCustomElementDefinition::RunAdoptedCallback(Element* element,
                                                        Document* old_owner,
                                                        Document* new_owner) {
   if (!script_state_->ContextIsValid())
     return;
   ScriptState::Scope scope(script_state_.Get());
   v8::Isolate* isolate = script_state_->GetIsolate();
   v8::Local<v8::Value> argv[] = {
       ToV8(old_owner, script_state_->GetContext()->Global(), isolate),
       ToV8(new_owner, script_state_->GetContext()->Global(), isolate)};
-  RunCallback(adopted_callback_.NewLocal(isolate), element,
+  RunCallback(adopted_callback_.NewLocal(isolate).As<v8::Function>(), element,
               WTF_ARRAY_LENGTH(argv), argv);
 }
 
 void ScriptCustomElementDefinition::RunAttributeChangedCallback(
     Element* element,
     const QualifiedName& name,
     const AtomicString& old_value,
     const AtomicString& new_value) {
   if (!script_state_->ContextIsValid())
     return;
   ScriptState::Scope scope(script_state_.Get());
   v8::Isolate* isolate = script_state_->GetIsolate();
   v8::Local<v8::Value> argv[] = {
       V8String(isolate, name.LocalName()), V8StringOrNull(isolate, old_value),
       V8StringOrNull(isolate, new_value),
       V8StringOrNull(isolate, name.NamespaceURI()),
   };
-  RunCallback(attribute_changed_callback_.NewLocal(isolate), element,
-              WTF_ARRAY_LENGTH(argv), argv);
+  RunCallback(attribute_changed_callback_.NewLocal(isolate).As<v8::Function>(),
+              element, WTF_ARRAY_LENGTH(argv), argv);
 }
 
 }  // namespace blink