Make CustomElementsRegistry lazily initialize script state.

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 "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8HiddenValue.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::create(
-    ScriptState* scriptState,
     V0CustomElementRegistrationContext* v0)
 {
-    DCHECK(scriptState->world().isMainWorld());
     CustomElementsRegistry* registry = new CustomElementsRegistry(v0);
     if (v0)
         v0->setV1(registry);
-
-    v8::Isolate* isolate = scriptState->isolate();
-    v8::Local<v8::Object> wrapper =
-        toV8(registry, scriptState).As<v8::Object>();
-    v8::Local<v8::String> name =
-        V8HiddenValue::customElementsRegistryMap(isolate);
-    v8::Local<v8::Map> map = v8::Map::New(isolate);
-    bool didSetPrototype =
-        V8HiddenValue::setHiddenValue(scriptState, wrapper, name, map);
-    DCHECK(didSetPrototype);
-
     return registry;
 }
 
 CustomElementsRegistry::CustomElementsRegistry(
     const V0CustomElementRegistrationContext* v0)
     : m_v0(v0)
 {
 }
 
 // http://w3c.github.io/webcomponents/spec/custom/#dfn-element-definition
@@ skipping 111 matching lines @@
     return v8CallOrCrash(
         idMap(scriptState)->Get(scriptState->context(), idValue))
         .As<v8::Object>();
 }
 
 bool CustomElementsRegistry::nameIsDefined(const AtomicString& name) const
 {
     return m_names.contains(name);
 }
 
+void CustomElementsRegistry::initializeScript(

[haraken, 2016/05/23 01:46:37]

I'd rename the method to ensureConstructorMap() and make it return the map. Then
the caller site can just call it to get the map.

+    ScriptState* scriptState,
+    v8::Local<v8::Map>& map)
+{
+    CHECK(scriptState->world().isMainWorld());
+    v8::Local<v8::Object> wrapper = toV8(this, scriptState).As<v8::Object>();
+    v8::Isolate* isolate = scriptState->isolate();
+    v8::Local<v8::String> name =
+        V8HiddenValue::customElementsRegistryMap(isolate);
+    DCHECK(V8HiddenValue::getHiddenValue(scriptState, wrapper, name).IsEmpty());
+    map = v8::Map::New(isolate);
+    V8HiddenValue::setHiddenValue(scriptState, wrapper, name, map);
+}
+
 v8::Local<v8::Map> CustomElementsRegistry::idMap(ScriptState* scriptState)
 {
-    DCHECK(scriptState->world().isMainWorld());
-    v8::Local<v8::Object> wrapper =
-        toV8(this, scriptState).As<v8::Object>();
+    CHECK(scriptState->world().isMainWorld());
+    v8::Local<v8::Object> wrapper = toV8(this, scriptState).As<v8::Object>();
     v8::Local<v8::String> name = V8HiddenValue::customElementsRegistryMap(
         scriptState->isolate());
-    return V8HiddenValue::getHiddenValue(scriptState, wrapper, name)
-        .As<v8::Map>();
+    v8::Local<v8::Value> mapValue =
+        V8HiddenValue::getHiddenValue(scriptState, wrapper, name);
+    v8::Local<v8::Map> map;
+    if (!mapValue.IsEmpty())
+        map = mapValue.As<v8::Map>();
+    else
+        initializeScript(scriptState, map);
+    return map;
 }
 
 bool CustomElementsRegistry::idForConstructor(
     ScriptState* scriptState,
     v8::Local<v8::Value> constructor,
     Id& id)
 {
     v8::Local<v8::Value> entry = v8CallOrCrash(
         idMap(scriptState)->Get(scriptState->context(), constructor));
     if (!entry->IsUint32())
         return false;
     id = v8CallOrCrash(entry->Uint32Value(scriptState->context()));
     return true;
 }
 
 bool CustomElementsRegistry::v0NameIsDefined(const AtomicString& name)
 {
     return m_v0.get() && m_v0->nameIsDefined(name);
 }
 
 DEFINE_TRACE(CustomElementsRegistry)
 {
     visitor->trace(m_definitions);
     visitor->trace(m_v0);
 }
 
 } // namespace blink