Keep a persistent handle for the bindings classes to avoid repeated lookups that involve performing…

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 34 matching lines @@
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
 template<class BindingsClass>
 struct DartDOMWrapperTraits;
 
 class DartDOMWrapper {
 public:
     template <class WebKitClass>
-    static Dart_Handle newWrapper(const char* className, const char* libraryName, WebKitClass* domObject)
+    static Dart_Handle newWrapper(const char* className, const char* libraryName, intptr_t cid, WebKitClass* domObject)
     {
-        Dart_Handle wrapper = instantiateWrapper(className, libraryName);
+
+        Dart_Handle type = dartClass(className, libraryName, cid);
+        ASSERT(!Dart_IsError(type));
+        Dart_Handle wrapper = Dart_Allocate(type);
         writeNativePointer(wrapper, kNativeImplementationIndex, domObject);
         return wrapper;
     }
 
     template <class BindingsClass>
     static Dart_Handle toDart(typename BindingsClass::NativeType* domObject)
     {
-        return toDartWithClassName<BindingsClass>(domObject, BindingsClass::dartImplementationClassName, BindingsClass::dartImplementationLibraryName);
+        return toDartWithClassName<BindingsClass>(
+            domObject,
+            BindingsClass::dartImplementationClassName,
+            BindingsClass::dartImplementationLibraryName,
+            BindingsClass::dartClassId);
     }
 
     template <class BindingsClass>
     static Dart_Handle toDartWithClassName(typename BindingsClass::NativeType* domObject,
-        const char* className, const char* libraryName)
+        const char* className, const char* libraryName, intptr_t cid)
     {
         typedef DartDOMWrapperTraits<BindingsClass> Traits;
 
         if (!domObject)
             return Dart_Null();
 
         Dart_Handle oldInstance = lookupWrapper<BindingsClass>(domObject);
         if (oldInstance)
             return oldInstance;
 
-        Dart_Handle newInstance = newWrapper(className, libraryName, domObject);
+        Dart_Handle newInstance = newWrapper(className, libraryName, cid, domObject);
         return associateWrapper<BindingsClass>(domObject, newInstance);
     }
 
     template <class BindingsClass>
     static Dart_Handle lookupWrapper(typename BindingsClass::NativeType* domObject)
     {
         typedef DartDOMWrapperTraits<BindingsClass> Traits;
 
         DartDOMData* domData = DartDOMData::current();
         Dart_WeakPersistentHandle wrapper = Traits::MapTraits::domMap(domData)->get(domObject);
@@ skipping 80 matching lines @@
     static typename BindingsClass::NativeType* unwrapDartWrapper(Dart_NativeArguments args, int index, Dart_Handle& exception)
     {
         ASSERT(!exception);
         Dart_Handle wrapper = Dart_GetNativeArgument(args, index);
         return unwrapDartWrapper<BindingsClass>(wrapper, exception);
     }
 
     template <class BindingsClass>
     static bool instanceOf(Dart_Handle wrapper)
     {
-        return instanceOf(BindingsClass::dartImplementationClassName, BindingsClass::dartImplementationLibraryName, wrapper);
+        Dart_Handle type = dartClass<BindingsClass>();
+
+        bool isInstanceOf = false;
+        Dart_Handle result = Dart_ObjectIsType(wrapper, type, &isInstanceOf);
+        if (Dart_IsError(result))
+            return false;
+        return isInstanceOf;
     }
 
     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 20 matching lines @@
 
     static Dart_Handle exceptionCodeToDartException(ExceptionCode);
     static Dart_Handle exceptionCodeToDartException(DartExceptionState&);
 
 private:
     enum NativeFieldIndices {
         kNativeImplementationIndex = 0,
         kNativeFieldCount
     };
 
-    static Dart_Handle instantiateWrapper(const char* className, const char* libraryName);
-    static bool instanceOf(const char* dartImplementationClassName,
-            const char* dartImplementationLibraryName, Dart_Handle wrapper);
+    static Dart_Handle dartClass(const char* dartImplementationClassName,
+        const char* dartImplementationLibraryName, intptr_t classIndex);
+
+    template <class BindingsClass>
+    static Dart_Handle dartClass()
+    {
+        return dartClass(BindingsClass::dartImplementationClassName, BindingsClass::dartImplementationLibraryName, BindingsClass::dartClassId);
+    }
 
     static void writeNativePointer(Dart_Handle wrapper, int index, void* pointer)
     {
         DartApiScope scope;
         Dart_Handle result = Dart_SetNativeInstanceField(wrapper, index, reinterpret_cast<intptr_t>(pointer));
         UNUSED_PARAM(result);
         ASSERT(!Dart_IsError(result));
     }
 
     static void* readNativePointer(Dart_Handle wrapper, int index)
@@ skipping 98 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