bindings: Introduces type-check for the internal pointers.

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 678 matching lines @@
     v8SetReturnValue(info, wrapper);
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block visit_dom_wrapper %}
 {% if reachable_node_function or set_wrapper_reference_to_list %}
-void {{v8_class}}::visitDOMWrapper(void* object, const v8::Persistent<v8::Object>& wrapper, v8::Isolate* isolate)
+void {{v8_class}}::visitDOMWrapper(ScriptWrappableBase* internalPointer, const v8::Persistent<v8::Object>& wrapper, v8::Isolate* isolate)
 {
-    {{cpp_class}}* impl = fromInternalPointer(object);
+    {{cpp_class}}* impl = fromInternalPointer(internalPointer);
     {% if set_wrapper_reference_to_list %}
     v8::Local<v8::Object> creationContext = v8::Local<v8::Object>::New(isolate, wrapper);
     V8WrapperInstantiationScope scope(creationContext, isolate);
     {% for set_wrapper_reference_to in set_wrapper_reference_to_list %}
     {{set_wrapper_reference_to.cpp_type}} {{set_wrapper_reference_to.name}} = impl->{{set_wrapper_reference_to.name}}();
     if ({{set_wrapper_reference_to.name}}) {
         if (!DOMDataStore::containsWrapper<{{set_wrapper_reference_to.v8_type}}>({{set_wrapper_reference_to.name}}, isolate))
             wrap({{set_wrapper_reference_to.name}}, creationContext, isolate);
         DOMDataStore::setWrapperReference<{{set_wrapper_reference_to.v8_type}}>(wrapper, {{set_wrapper_reference_to.name}}, isolate);
     }
     {% endfor %}
     {% endif %}
     {% if reachable_node_function %}
     // The {{reachable_node_function}}() method may return a reference or a pointer.
     if (Node* owner = WTF::getPtr(impl->{{reachable_node_function}}())) {
         Node* root = V8GCController::opaqueRootForGC(owner, isolate);
         isolate->SetReferenceFromGroup(v8::UniqueId(reinterpret_cast<intptr_t>(root)), wrapper);
         return;
     }
     {% endif %}
-    setObjectGroup(object, wrapper, isolate);
+    setObjectGroup(internalPointer, wrapper, isolate);
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block shadow_attributes %}
 {% if interface_name == 'Window' %}
 static const V8DOMConfiguration::AttributeConfiguration shadowAttributes[] = {
@@ skipping 408 matching lines @@
     return V8PerIsolateData::from(isolate)->findInstanceInPrototypeChain(&wrapperTypeInfo, v8Value);
 }
 
 {% endblock %}
 
 
 {##############################################################################}
 {% block to_native_with_type_check %}
 {{cpp_class}}* {{v8_class}}::toNativeWithTypeCheck(v8::Isolate* isolate, v8::Handle<v8::Value> value)
 {
-    return hasInstance(value, isolate) ? fromInternalPointer(v8::Handle<v8::Object>::Cast(value)->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex)) : 0;
+    return hasInstance(value, isolate) ? fromInternalPointer(blink::toInternalPointer(v8::Handle<v8::Object>::Cast(value))) : 0;

[haraken, 2014/08/08 15:50:31]

fromInternalPointer(toInternalPointer(value)) is a bit confusing.

Probably we can:

- Rename toInternalPointer to toScriptWrappableBase
- Rename fromInternalPointer to toImpl
- Remove toNative
- Rename toNativeWithTypeCheck to toImplWithTypeCheck

You can do the refactoring in a separate CL.

[Yuki, 2014/08/11 05:42:00]

I see.  Let's choose the best name with an offline discussion, and then, I'll
rename it.

 }
 
 {% endblock %}
 
 
 {##############################################################################}
 {% block install_per_context_attributes %}
 {% if has_per_context_enabled_attributes %}
 void {{v8_class}}::installPerContextEnabledProperties(v8::Handle<v8::Object> instanceObject, {{cpp_class}}* impl, v8::Isolate* isolate)
 {
@@ skipping 166 matching lines @@
     V8DOMWrapper::associateObjectWithWrapper<{{v8_class}}>(impl, &wrapperTypeInfo, wrapper, isolate, {{wrapper_configuration}});
     return wrapper;
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block deref_object_and_to_v8_no_inline %}
-void {{v8_class}}::derefObject(void* object)
+void {{v8_class}}::derefObject(ScriptWrappableBase* internalPointer)
 {
 {% if gc_type == 'RefCountedObject' %}
-    fromInternalPointer(object)->deref();
+    fromInternalPointer(internalPointer)->deref();
 {% elif gc_type == 'WillBeGarbageCollectedObject' %}
 {% filter conditional('!ENABLE(OILPAN)') %}
-    fromInternalPointer(object)->deref();
+    fromInternalPointer(internalPointer)->deref();
 {% endfilter %}
 {% endif %}
 }
 
 template<>
 v8::Handle<v8::Value> toV8NoInline({{cpp_class}}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     return toV8(impl, creationContext, isolate);
 }
 
 {% endblock %}