bindings: Introduces type-check for the internal pointers.

Source/bindings/templates/interface.h

Index: Source/bindings/templates/interface.h
diff --git a/Source/bindings/templates/interface.h b/Source/bindings/templates/interface.h
index 17b1f971efde2c8dc08e4a7faffa96c6764b23e9..3a908e1d8b1330c01ad69a4fbc29ade7393d61ca 100644
--- a/Source/bindings/templates/interface.h
+++ b/Source/bindings/templates/interface.h
@@ -32,13 +32,13 @@ public:
     static v8::Handle<v8::FunctionTemplate> domTemplate(v8::Isolate*);
     static {{cpp_class}}* toNative(v8::Handle<v8::Object> object)
     {
-        return fromInternalPointer(object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex));
+        return fromInternalPointer(blink::toInternalPointer(object));

[haraken, 2014/08/08 09:37:23]

Do we need blink:: ? The same comment for other parts where you added blink::.

[Yuki, 2014/08/08 13:01:25]

Yes, we need blink:: to solve ambiguity between blink::V8T::toInternalPointer(T*
impl) and blink::toInternalPointer(v8::Handle<v8::Object>).

     }
     static {{cpp_class}}* toNativeWithTypeCheck(v8::Isolate*, v8::Handle<v8::Value>);
     static const WrapperTypeInfo wrapperTypeInfo;
-    static void derefObject(void*);
+    static void derefObject(ScriptWrappableBase* internalPointer);

[haraken, 2014/08/08 09:37:23]

Omit |internalPointer|. Blink normally doesn't add variable names in method
declarations. The same comment for other parts in this CL.

[Yuki, 2014/08/08 13:01:25]

I read the style guide at
http://dev.chromium.org/blink/coding-style
especially at [Names] section's 9, which says "Leave meaningless variable names
out of function declarations. A good rule of thumb is if the parameter type name
contains the parameter name (without trailing numbers or pluralization), then
the parameter name isn't needed. Usually, there should be a parameter name for
bools, strings, and numerical types."

I thought that "ScriptWrappableBase" and "internalPointer" differ and it's
helpful to put the name explicitly so that people understand that we need to
pass "internal pointer" here.

[haraken, 2014/08/08 13:14:30]

I think the issue is we're using a word "internalPointer" although it's actually
a ScriptWrapperBase's pointer. It should be named "wrappableBase" or something
like that. Then we can remove the variable name.

You can do this in a separate CL.

     {% if has_visit_dom_wrapper %}
-    static void visitDOMWrapper(void*, const v8::Persistent<v8::Object>&, v8::Isolate*);
+    static void visitDOMWrapper(ScriptWrappableBase* internalPointer, const v8::Persistent<v8::Object>&, v8::Isolate*);
     {% endif %}
     {% if is_active_dom_object %}
     static ActiveDOMObject* toActiveDOMObject(v8::Handle<v8::Object>);
@@ -140,21 +140,21 @@ public:
     static const int internalFieldCount = v8DefaultWrapperInternalFieldCount + {{custom_internal_field_counter}};
     {% endif %}
     {# End custom internal fields #}
-    static inline void* toInternalPointer({{cpp_class}}* impl)
+    static inline ScriptWrappableBase* toInternalPointer({{cpp_class}}* impl)
     {
         {% if parent_interface %}
         return V8{{parent_interface}}::toInternalPointer(impl);
         {% else %}
-        return impl;
+        return reinterpret_cast<ScriptWrappableBase*>(static_cast<void*>(impl));

[haraken, 2014/08/08 09:37:23]

Do we need static_cast<void*> ? The same comment for other parts where you added
static_cast<void*>.

[Yuki, 2014/08/08 13:01:25]

The other parts really need this trick because there are cases that T doesn't
inherit from ScriptWrappableBase.

This part is a special exception that I would like to keep the existing behavior
as much as possible in this CL.  I'm planning to change the behavior at
http://crrev.com/420233002 .

We have been using pointers to most-base DOM class as the internal pointers, not
poitners to ScriptWrappable or ScriptWrappableBase.  For example, pointer to
EventTarget as the internal pointer of Node.  This cast returns a pointer to
EventTarget as the internal pointer of Node as same as before.

         {% endif %}
     }
 
-    static inline {{cpp_class}}* fromInternalPointer(void* object)
+    static inline {{cpp_class}}* fromInternalPointer(ScriptWrappableBase* internalPointer)
     {
         {% if parent_interface %}
-        return static_cast<{{cpp_class}}*>(V8{{parent_interface}}::fromInternalPointer(object));
+        return static_cast<{{cpp_class}}*>(V8{{parent_interface}}::fromInternalPointer(internalPointer));
         {% else %}
-        return static_cast<{{cpp_class}}*>(object);
+        return reinterpret_cast<{{cpp_class}}*>(static_cast<void*>(internalPointer));
         {% endif %}
     }
     {% if interface_name == 'Window' %}