Make DOMWrapperWorld::current() return a reference instead of a pointer

Source/bindings/templates/interface.cpp

 {% extends 'interface_base.cpp' %}
 
 
 {##############################################################################}
 {% macro attribute_configuration(attribute) %}
 {% set getter_callback =
        '%sV8Internal::%sAttributeGetterCallback' %
             (cpp_class, attribute.name)
        if not attribute.constructor_type else
        ('%sV8Internal::%sConstructorGetterCallback' %
@@ skipping 644 matching lines @@
     {% if any_type_attributes and not interface_name == 'ErrorEvent' %}
     {# If we're in an isolated world, create a SerializedScriptValue and store
        it in the event for later cloning if the property is accessed from
        another world. The main world case is handled lazily (in custom code).
 
        We do not clone Error objects (exceptions), for 2 reasons:
        1) Errors carry a reference to the isolated world's global object, and
           thus passing it around would cause leakage.
        2) Errors cannot be cloned (or serialized):
        http://www.whatwg.org/specs/web-apps/current-work/multipage/common-dom-interfaces.html#safe-passing-of-structured-data #}
-    if (DOMWrapperWorld::current(isolate)->isIsolatedWorld()) {
+    if (DOMWrapperWorld::current(isolate).isIsolatedWorld()) {
         {% for attribute in any_type_attributes %}
         if (!{{attribute.name}}.IsEmpty())
             event->setSerialized{{attribute.name | blink_capitalize}}(SerializedScriptValue::createAndSwallowExceptions({{attribute.name}}, isolate));
         {% endfor %}
     }
 
     {% endif %}
     v8::Handle<v8::Object> wrapper = info.Holder();
     V8DOMWrapper::associateObjectWithWrapper<{{v8_class}}>(event.release(), &{{v8_class}}::wrapperTypeInfo, wrapper, isolate, {{wrapper_configuration}});
     v8SetReturnValue(info, wrapper);
@@ skipping 292 matching lines @@
     {# Needed for legacy support of document.all #}
     functionTemplate->InstanceTemplate()->MarkAsUndetectable();
     {% endif %}
     {% for method in methods if not method.do_not_check_signature %}
     {# install_custom_signature #}
     {% if not method.overload_index or method.overload_index == 1 %}
     {# For overloaded methods, only generate one accessor #}
     {% filter conditional(method.conditional_string) %}
     {% if method.is_do_not_check_security %}
     {% if method.is_per_world_bindings %}
-    if (DOMWrapperWorld::current(isolate)->isMainWorld()) {
+    if (DOMWrapperWorld::current(isolate).isMainWorld()) {
         {{install_do_not_check_security_signature(method, 'ForMainWorld')}}
     } else {
         {{install_do_not_check_security_signature(method)}}
     }
     {% else %}
     {{install_do_not_check_security_signature(method)}}
     {% endif %}
     {% else %}{# is_do_not_check_security #}
     {% if method.is_per_world_bindings %}
-    if (DOMWrapperWorld::current(isolate)->isMainWorld()) {
+    if (DOMWrapperWorld::current(isolate).isMainWorld()) {
         {% filter runtime_enabled(method.runtime_enabled_function) %}
         {{install_custom_signature(method, 'ForMainWorld')}}
         {% endfilter %}
     } else {
         {% filter runtime_enabled(method.runtime_enabled_function) %}
         {{install_custom_signature(method)}}
         {% endfilter %}
     }
     {% else %}
     {% filter runtime_enabled(method.runtime_enabled_function) %}
@@ skipping 197 matching lines @@
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block get_shadow_object_template %}
 {% if interface_name == 'Window' %}
 v8::Handle<v8::ObjectTemplate> V8Window::getShadowObjectTemplate(v8::Isolate* isolate)
 {
-    if (DOMWrapperWorld::current(isolate)->isMainWorld()) {
+    if (DOMWrapperWorld::current(isolate).isMainWorld()) {
         DEFINE_STATIC_LOCAL(v8::Persistent<v8::ObjectTemplate>, V8WindowShadowObjectCacheForMainWorld, ());
         if (V8WindowShadowObjectCacheForMainWorld.IsEmpty()) {
             TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
             v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
             configureShadowObjectTemplate(templ, isolate);
             V8WindowShadowObjectCacheForMainWorld.Reset(isolate, templ);
             return templ;
         }
         return v8::Local<v8::ObjectTemplate>::New(isolate, V8WindowShadowObjectCacheForMainWorld);
     } else {
@@ skipping 20 matching lines @@
 {
     ASSERT(impl);
     {% for special_wrap_interface in special_wrap_for %}
     if (impl->is{{special_wrap_interface}}())
         return wrap(to{{special_wrap_interface}}(impl), creationContext, isolate);
     {% endfor %}
     v8::Handle<v8::Object> wrapper = {{v8_class}}::createWrapper(impl, creationContext, isolate);
     {% if is_document %}
     if (wrapper.IsEmpty())
         return wrapper;
-    DOMWrapperWorld* world = DOMWrapperWorld::current(isolate);
-    if (world->isMainWorld()) {
+    DOMWrapperWorld& world = DOMWrapperWorld::current(isolate);
+    if (world.isMainWorld()) {
         if (LocalFrame* frame = impl->frame())
             frame->script().windowShell(world)->updateDocumentWrapper(wrapper);
     }
     {% endif %}
     return wrapper;
 }
 
 {% endif %}
 {% endblock %}
 
@@ skipping 56 matching lines @@
 {% endfilter %}
 }
 
 template<>
 v8::Handle<v8::Value> toV8NoInline({{cpp_class}}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     return toV8(impl, creationContext, isolate);
 }
 
 {% endblock %}