Use Dart_InstanceIsSubtypeOf to check if instance is a direct subtype of specified type.

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 124 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)) {
+        if (!subtypeOf<BindingsClass>(domData, wrapper)) {
             String message = String("Invalid class: expected instance of ") + BindingsClass::dartImplementationClassName;
             exception = DartUtilities::stringToDartString(message);
             return 0;
         }
         void* nativePointer = readNativePointer(wrapper, kNativeImplementationIndex);
         return static_cast<typename BindingsClass::NativeType*>(nativePointer);
     }
 
     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);
     }
 
     template <class BindingsClass>
-    static bool instanceOf(DartDOMData* domData, Dart_Handle wrapper)
+    static bool subtypeOf(DartDOMData* domData, Dart_Handle wrapper)
     {
         Dart_PersistentHandle type = dartClass<BindingsClass>(domData);
 
-        bool isInstanceOf = false;
-        Dart_Handle result = Dart_ObjectIsType(wrapper, type, &isInstanceOf);

[vsm, 2013/10/14 15:44:09]

Siva: Just curious, what's the semantic difference between ObjectIsType and
InstanceIsSubtypeOf?  Why is the latter more efficient?

[siva, 2013/10/14 15:55:06]

Dart_InstanceIsSubtypeOf just does a straight sub class check without looking
into interfaces etc. It also only deals with non parameterized types which is
what all these Web native types are.
(This will also take care of the issue 11008).

On 2013/10/14 15:44:09, vsm wrote:

-        return isInstanceOf;
+        bool isSubtypeOf = false;
+        Dart_Handle result = Dart_InstanceIsSubtypeOf(wrapper, type, &isSubtypeOf);
+        ASSERT(!Dart_IsError(result));
+        return isSubtypeOf;
     }
 
     template <class WebKitClass>
     static WebKitClass* receiver(Dart_NativeArguments args)
     {
         // Type of receiver is ensured by Dart VM runtime, so bypass additional checks.
         intptr_t value = 0;
         ASSERT(!kNativeImplementationIndex);
         Dart_Handle result = Dart_GetNativeReceiver(args, &value);
         ASSERT(!Dart_IsError(result));
@@ skipping 189 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