Add a native subtype of function that uses the native C++ class hierarchy to check if an element

Source/bindings/dart/DartDOMWrapper.h

 // Copyright 2011, 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 12 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef DartDOMWrapper_h
 #define DartDOMWrapper_h
 
+#include "DartWebkitClassIds.h"
+
 #include "bindings/dart/DartDOMData.h"
 #include "bindings/dart/DartExceptionState.h"
 #include "bindings/dart/DartUtilities.h"
 #include "bindings/v8/Dictionary.h"
 #include "bindings/v8/ScriptValue.h"
 #include "bindings/v8/SerializedScriptValue.h"
 #include "core/dom/ExceptionCode.h"
 
 #include <dart_api.h>
 #include <wtf/PassRefPtr.h>
@@ skipping 51 matching lines @@
 
     template <class BindingsClass>
     static Dart_Handle createWrapperWithClassName(
         DartDOMData* domData, typename BindingsClass::NativeType* domObject,
         const char* className, intptr_t libraryId, intptr_t cid)
     {
         ASSERT(domObject);
         Dart_PersistentHandle type = dartClass(domData, className, libraryId, cid);
         ASSERT(!Dart_IsError(type));
         Dart_Handle wrapper = Dart_Allocate(type);
-        writeNativePointer(wrapper, kNativeImplementationIndex, domObject);
+        writeNativePointer(wrapper, domObject, cid);
         associateWrapper<BindingsClass>(domData, domObject, wrapper);
         return wrapper;
     }
 
     // FIXME: move vectorToDart into DartUtilities or even into a separate class.
     template<class BindingsClass>
     static Dart_Handle vectorToDart(const Vector< RefPtr<typename BindingsClass::NativeType> >& vector)
     {
         Dart_Handle list = Dart_NewList(vector.size());
         if (Dart_IsError(list))
@@ skipping 20 matching lines @@
 
     template <class BindingsClass>
     static typename BindingsClass::NativeType* unwrapDartWrapper(
         DartDOMData* domData, Dart_Handle wrapper, Dart_Handle& exception)
     {
         ASSERT(!exception);
 
         if (Dart_IsNull(wrapper))
             return 0;
 
-        // FIXME: support cross-domain wrappers.
-        if (!instanceOf<BindingsClass>(domData, wrapper)) {
-            String message = String("Invalid class: expected instance of ") + BindingsClass::dartImplementationClassName;
-            exception = DartUtilities::stringToDartString(message);
-            return 0;
+        if (subtypeOf(wrapper, BindingsClass::dartClassId)) {
+            void* nativePointer = readNativePointer(wrapper, kNativeImplementationIndex);
+            return static_cast<typename BindingsClass::NativeType*>(nativePointer);
         }
-        void* nativePointer = readNativePointer(wrapper, kNativeImplementationIndex);
-        return static_cast<typename BindingsClass::NativeType*>(nativePointer);
+        String message = String("Invalid class: expected instance of ") +
+            BindingsClass::dartImplementationClassName;
+        exception = DartUtilities::stringToDartString(message);
+        return 0;
     }
 
     template <class BindingsClass>
     static typename BindingsClass::NativeType* unwrapDartWrapper(
         Dart_NativeArguments args, int index, Dart_Handle& exception)
     {
         ASSERT(!exception);
         DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
         Dart_Handle wrapper = Dart_GetNativeArgument(args, index);
         return unwrapDartWrapper<BindingsClass>(domData, wrapper, exception);
     }
 
+    static bool subtypeOf(Dart_Handle wrapper, intptr_t basecid)
+    {
+        intptr_t cid = reinterpret_cast<intptr_t>(readNativePointer(wrapper, kNativeTypeIndex));
+        while (cid != -1) {
+            if (cid == basecid) {
+                return true;
+            }
+            ASSERT(cid < NumWebkitClassIds);
+            cid = DartWebkitClassInfo[cid].base_class_id;
+        }
+        return false;
+    }
+
     template <class BindingsClass>
     static bool instanceOf(DartDOMData* domData, Dart_Handle wrapper)
     {
         Dart_PersistentHandle type = dartClass<BindingsClass>(domData);
 
         bool isInstanceOf = false;
         Dart_Handle result = Dart_ObjectIsType(wrapper, type, &isInstanceOf);
         return isInstanceOf;
     }
 
@@ skipping 30 matching lines @@
     }
 
     static int wrapperNativeFieldCount() { return kNativeFieldCount; }
 
     static Dart_Handle exceptionCodeToDartException(ExceptionCode);
     static Dart_Handle exceptionCodeToDartException(DartExceptionState&);
 
 private:
     enum NativeFieldIndices {
         kNativeImplementationIndex = 0,
+        kNativeTypeIndex = 1,
         kNativeFieldCount
     };
 
     static Dart_PersistentHandle dartClass(
         DartDOMData*,
         const char* dartImplementationClassName, intptr_t dartImplementationLibraryId,
         intptr_t classIndex);
 
     template <class BindingsClass>
     static Dart_PersistentHandle dartClass(DartDOMData* domData)
     {
         return dartClass(
             domData,
             BindingsClass::dartImplementationClassName, BindingsClass::dartImplementationLibraryId,
             BindingsClass::dartClassId);
     }
 
     static Dart_PersistentHandle dartClass(const char* dartImplementationClassName,
         const char* dartImplementationLibraryName, intptr_t classIndex);
 
-    static void writeNativePointer(Dart_Handle wrapper, int index, void* pointer)
+    static void writeNativePointer(Dart_Handle wrapper, void* pointer, intptr_t cid)
     {
         Dart_Handle result = Dart_SetNativeInstanceField(
-            wrapper, index, reinterpret_cast<intptr_t>(pointer));
+            wrapper, kNativeImplementationIndex, reinterpret_cast<intptr_t>(pointer));
         UNUSED_PARAM(result);
         ASSERT(!Dart_IsError(result));
+        result = Dart_SetNativeInstanceField(wrapper, kNativeTypeIndex, cid);
+        ASSERT(!Dart_IsError(result));
     }
 
     static void* readNativePointer(Dart_Handle wrapper, int index)
     {
         intptr_t value;
         Dart_Handle result = Dart_GetNativeInstanceField(wrapper, index, &value);
         // FIXME: the fact that we return 0 on error rather than asserting is
         // somewhat of a hack. We currently make this method return 0 because
         // we reuse this method to verify that objects are actually native
         // Node objects rather than objects that implement the Node interface.
@@ skipping 121 matching lines @@
         static DartMessagePortMap* domMap(DartDOMData* domData) { return domData->messagePortMap(); }
     };
     typedef MessagePortMapTraits MapTraits;
     typedef DartDOMWrapperActiveTraits<DartMessagePort, false> ActiveTraits;
     typedef DartDOMWrapperEventTargetTraits<DartMessagePort, true> EventTargetTraits;
 };
 
 }
 
 #endif // DartDOMWrapper_h