bindings: Renames from/toInternalPointer, etc.

Source/bindings/core/v8/ScriptWrappable.h

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 60 matching lines @@
 // This doesn't happen with other compilers which support EBCO. All the
 // addresses in the above example will be 0x1000 with EBCO supported.
 //
 // Since v8::Object::SetAlignedPointerInInternalField requires the pointers to
 // be aligned, we need a hack to specify at least 4 byte alignment to MSVC.
 __declspec(align(4))
 #endif
 class ScriptWrappableBase {
 public:
     template<typename T>
-    static T* fromInternalPointer(ScriptWrappableBase* internalPointer)
+    T* toImpl()
     {
         // Check if T* is castable to ScriptWrappableBase*, which means T
         // doesn't have two or more ScriptWrappableBase as superclasses.
         // If T has two ScriptWrappableBase as superclasses, conversions
         // from T* to ScriptWrappableBase* are ambiguous.
-        ASSERT(static_cast<ScriptWrappableBase*>(static_cast<T*>(internalPointer)));
+        ASSERT(static_cast<ScriptWrappableBase*>(static_cast<T*>(this)));
         // The internal pointers must be aligned to at least 4 byte alignment.
-        ASSERT((reinterpret_cast<intptr_t>(internalPointer) & 0x3) == 0);
-        return static_cast<T*>(internalPointer);
+        ASSERT((reinterpret_cast<intptr_t>(this) & 0x3) == 0);
+        return static_cast<T*>(this);
     }
-    ScriptWrappableBase* toInternalPointer()
+    ScriptWrappableBase* toScriptWrappableBase()
     {
         // The internal pointers must be aligned to at least 4 byte alignment.
         ASSERT((reinterpret_cast<intptr_t>(this) & 0x3) == 0);
         return this;
     }
 
     void assertWrapperSanity(v8::Local<v8::Object> object)
     {
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(object.IsEmpty()
-            || object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == toInternalPointer());
+            || object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == toScriptWrappableBase());
     }
 };
 
 /**
  * ScriptWrappable wraps a V8 object and its WrapperTypeInfo.
  *
  * ScriptWrappable acts much like a v8::Persistent<> in that it keeps a
  * V8 object alive. Under the hood, however, it keeps either a TypeInfo
  * object or an actual v8 persistent (or is empty).
  *
@@ skipping 130 matching lines @@
         v8::Persistent<v8::Object> persistent;
         getPersistent(&persistent);
         isolate->SetReference(parent, persistent);
     }
 
     template<typename V8T, typename T>
     static void assertWrapperSanity(v8::Local<v8::Object> object, T* objectAsT)
     {
         ASSERT(objectAsT);
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(object.IsEmpty()
-            || object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == V8T::toInternalPointer(objectAsT));
+            || object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == V8T::toScriptWrappableBase(objectAsT));
     }
 
     template<typename V8T, typename T>
     static void assertWrapperSanity(void* object, T* objectAsT)
     {
         ASSERT_NOT_REACHED();
     }
 
     template<typename V8T, typename T>
     static void assertWrapperSanity(ScriptWrappable* object, T* objectAsT)
     {
         ASSERT(object);
         ASSERT(objectAsT);
         v8::Object* value = object->getRawValue();
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(value == 0
-            || value->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == V8T::toInternalPointer(objectAsT));
+            || value->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == V8T::toScriptWrappableBase(objectAsT));
     }
 
     using ScriptWrappableBase::assertWrapperSanity;
 
     inline bool containsWrapper() const { return (m_wrapperOrTypeInfo & 1); }
     inline bool containsTypeInfo() const { return m_wrapperOrTypeInfo && !(m_wrapperOrTypeInfo & 1); }
 
 #if !ENABLE(OILPAN)
 protected:
     virtual ~ScriptWrappable()
@@ skipping 86 matching lines @@
     virtual const WrapperTypeInfo* wrapperTypeInfo() const OVERRIDE \
     { \
         return &s_wrapperTypeInfo; \
     } \
 private: \
     static const WrapperTypeInfo& s_wrapperTypeInfo
 
 } // namespace blink
 
 #endif // ScriptWrappable_h