DOM wrappers that are not retained from Dart should be collected.

Source/WebCore/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 13 matching lines @@
 // 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 "DOMStringList.h"
+#include "DartIsolate.h"
 #include "DartUtilities.h"
 #include "EventListener.h"
 #include "EventTarget.h"
 #include "ExceptionCode.h"
 #include "MediaQueryListListener.h"
 #include "Range.h"
 #include "ScriptValue.h"
 #include "SerializedScriptValue.h"
 #if ENABLE(SVG)
 #include "SVGPropertyTearOff.h"
@@ skipping 261 matching lines @@
         if (!DartUtilities::checkResult(element, exception))
             return;
         array[i] = toWebGLArrayElement<Element>(element, exception);
         if (exception)
             return;
     }
 }
 
 class DartDOMWrapper {
 public:
-    template <class WebkitClass>
-    static Dart_Handle newWrapper(const char* className, WebkitClass* domObject)
+    template <class WebKitClass>
+    static Dart_Handle newWrapper(const char* className, WebKitClass* domObject)
     {
         Dart_Handle wrapper = instantiateWrapper(className);
         installNativePointers(domObject, wrapper);
         return wrapper;
     }
 
     template <class BindingsClass>
     static Dart_Handle toDart(typename BindingsClass::NativeType* instance)
     {
         return toDart(instance, BindingsClass::dartImplementationClassName);
     }
 
-    template <class WebkitClass>
-    static Dart_Handle toDart(WebkitClass* instance, const char* className)
+    template <class WebKitClass>
+    static Dart_Handle toDart(WebKitClass* instance, const char* className)
     {
         if (!instance)
             return 0;
 
         // FIXME: custom toDartValue implementations should check the cache first.
         // FIXME: separate maps for nodes, dom objects and active dom objects.
         DartDOMMap* domMap = DartUtilities::domMapForCurrentIsolate();
         Dart_Handle wrapper = domMap->get(instance);
         if (wrapper)
             return wrapper;
 
         wrapper = instantiateWrapper(className);
         bindDOMObjectToDartWrapper(instance, wrapper);
         return wrapper;
     }
 
-    template <class WebkitClass>
-    static void bindDOMObjectToDartWrapper(WebkitClass* domObject, Dart_Handle wrapper)
+    template <class WebKitClass>
+    static void bindDOMObjectToDartWrapper(WebKitClass* domObject, Dart_Handle wrapper)
     {
         ASSERT(domObject);
         domObject->ref();
         installNativePointers(domObject, wrapper);
 
-        // FIXME: make persistent handle weak and deref domObject in weak callback.
-        Dart_Handle persistentWrapperHandle = Dart_NewPersistentHandle(wrapper);
+        RefPtr<DartIsolate> isolate = DartIsolate::current();
+        Dart_Handle persistentWrapperHandle = isolate->createWeakPersistentHandle(wrapper, domObject, &wrapperWeakCallback<WebKitClass>);
 
         DartDOMMap* domMap = DartUtilities::domMapForCurrentIsolate();
         ASSERT(!domMap->contains(domObject));
         domMap->set(domObject, persistentWrapperHandle);
     }
 
     template <class BindingsClass>
     static typename BindingsClass::NativeType* unwrapDartWrapper(Dart_Handle wrapper, Dart_Handle& exception)
     {
         // FIXME: support cross-domain wrappers.
         if (!BindingsClass::instanceOf(wrapper)) {
             String message = String("Invalid class: expected instance of ") + BindingsClass::dartImplementationClassName;
             exception = DartUtilities::stringToDartString(message);
             return 0;
         }
         ASSERT(!exception);
         void* nativePointer = readNativePointer(wrapper, kNativeImplementationIndex);
         return reinterpret_cast<typename BindingsClass::NativeType*>(nativePointer);
     }
 
-    static void derefDOMObject(Dart_Handle wrapper, void* domObject);
-
-    template <class WebkitClass>
-    static WebkitClass* receiver(Dart_NativeArguments args)
+    template <class WebKitClass>
+    static WebKitClass* receiver(Dart_NativeArguments args)
     {
         // Type of receiver is ensured by Dart VM runtime, so bypass additional checks.
         void* nativePointer = readNativePointer(Dart_GetNativeArgument(args, 0), kNativeImplementationIndex);
-        WebkitClass* const recv = static_cast<WebkitClass*>(nativePointer);
+        WebKitClass* const recv = static_cast<WebKitClass*>(nativePointer);
         ASSERT(recv); // Never should return 0.
         return recv;
     }
 
     template <typename Type>
     static void returnValue(Dart_NativeArguments args, const Type& value)
     {
         Dart_Handle result = toDartValue(value);
         if (result)
             Dart_SetReturnValue(args, result);
@@ skipping 10 matching lines @@
     }
 
     static Dart_Handle exceptionCodeToDartException(ExceptionCode);
 
     // DO NOT USE: Use BindingsClass:instanceOf(handle) instead.
     static bool instanceOf(const char* dartImplementationClassName, Dart_Handle wrapper);
 
 private:
     enum NativeFieldIndices {
         kNativeImplementationIndex = 0,
-        kDerefObjectFunctionIndex,
         kNativeFieldCount
     };
 
     static Dart_Handle instantiateWrapper(const char* className);
 
     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)
     {
         // FIXME: Try to remove this scope from the hot path.
         DartApiScope scope;
         intptr_t value;
         Dart_Handle result = Dart_GetNativeInstanceField(wrapper, index, &value);
         ASSERT(!Dart_IsError(result));
         UNUSED_PARAM(result);
         return reinterpret_cast<void*>(value);
     }
 
-    template <class WebkitClass>
-    static void installNativePointers(WebkitClass* domObject, Dart_Handle wrapper)
+    template <class WebKitClass>
+    static void installNativePointers(WebKitClass* domObject, Dart_Handle wrapper)
     {
         ASSERT(domObject);
-        DerefObjectFunction derefObjectFunction = &DartDOMWrapper::derefObject<WebkitClass>;
         writeNativePointer(wrapper, kNativeImplementationIndex, domObject);
-        writeNativePointer(wrapper, kDerefObjectFunctionIndex, reinterpret_cast<void*>(derefObjectFunction));
     }
 
-    typedef void (*DerefObjectFunction)(void*);
-
     template<typename T>
-    static void derefObject(void* pointer)
+    static void wrapperWeakCallback(Dart_Handle, void* domObject)
     {
-        static_cast<T*>(pointer)->deref();
+        DartDOMMap* domMap = DartUtilities::domMapForCurrentIsolate();
+        ASSERT(domMap->contains(domObject));
+        domMap->remove(domObject);
+        static_cast<T*>(domObject)->deref();
     }
 };
 
-template<>
-inline void DartDOMWrapper::derefObject<NPObject>(void*)
-{
-    // FIXME: proper deref.
-}
-
 // ParameterAdapter.
 
 template <typename Value>
 class ParameterAdapterBase {
 public:
     bool conversionSuccessful() const { return !m_exception; }
 
     Dart_Handle exception() const
     {
         ASSERT(!conversionSuccessful());
@@ skipping 295 matching lines @@
 template <>
 class ParameterAdapter<ScriptValue> : public ParameterAdapterBase<ScriptValue> {
 public:
     explicit ParameterAdapter(Dart_Handle handle) { this->unsupported(); }
     operator ScriptValue() const { return this->value(); }
 };
 
 }
 
 #endif // DartDOMWrapper_h