Properly retain non-node event listeners.

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 63 matching lines @@
         DartDOMData* domData = DartIsolate::currentDOMData();
         Dart_Handle wrapper = DartDOMWrapperTraits<BindingsClass>::MapTraits::domMap(domData)->get(domObject);
         if (wrapper)
             return wrapper;
 
         wrapper = instantiateWrapper(className);
         writeNativePointer(wrapper, kNativeImplementationIndex, domObject);
         Dart_Handle persistentWrapperHandle = DartUtilities::createPrologueWeakPersistentHandle(wrapper, domObject, &wrapperWeakCallback<BindingsClass>);
         DartDOMWrapperTraits<BindingsClass>::MapTraits::domMap(domData)->set(domObject, persistentWrapperHandle);
         DartDOMWrapperTraits<BindingsClass>::ActiveTraits::setWrapper(domData, domObject, persistentWrapperHandle);
+        DartDOMWrapperTraits<BindingsClass>::EventTargetTraits::setWrapper(domData, domObject, persistentWrapperHandle);
         domObject->ref();
         return wrapper;
     }
 
     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))
             return list;
@@ skipping 84 matching lines @@
     }
 
     template <class BindingsClass>
     static void wrapperWeakCallback(Dart_Handle, void* peer)
     {
         DartDOMData* domData = DartIsolate::currentDOMData();
         typename BindingsClass::NativeType* domObject = static_cast<typename BindingsClass::NativeType*>(peer);
         ASSERT(DartDOMWrapperTraits<BindingsClass>::MapTraits::domMap(domData)->contains(domObject));
         DartDOMWrapperTraits<BindingsClass>::MapTraits::domMap(domData)->remove(domObject);
         DartDOMWrapperTraits<BindingsClass>::ActiveTraits::removeWrapper(domData, domObject);
+        DartDOMWrapperTraits<BindingsClass>::EventTargetTraits::removeWrapper(domData, domObject);
         domObject->deref();
     }
 };
 
 template<bool isNode>
 struct DartDOMWrapperMapTraits {};
 
 template<>
 struct DartDOMWrapperMapTraits<false> {
     static DartDOMObjectMap* domMap(DartDOMData* domData) { return domData->objectMap(); }
@@ skipping 19 matching lines @@
     {
         domData->activeObjectMap()->set(domObject, wrapper);
     }
 
     static void removeWrapper(DartDOMData* domData, typename BindingsClass::NativeType* domObject)
     {
         domData->activeObjectMap()->remove(domObject);
     }
 };
 
+template<class BindingsClass, bool isEventTarget>
+struct DartDOMWrapperEventTargetTraits {};

[Anton Muhin, 2012/07/09 16:11:08]

ditto for too complicated way to customize behaviour

[podivilov, 2012/07/10 08:35:45]

I don't know any simpler way to achieve that. Conditional logic won't compile
because of wrong types.

[Anton Muhin, 2012/07/10 08:39:26]

Yes, you're right, sorry.

On 2012/07/10 08:35:45, podivilov wrote:

+
+template<class BindingsClass>
+struct DartDOMWrapperEventTargetTraits<BindingsClass, false> {
+    static void setWrapper(DartDOMData*, typename BindingsClass::NativeType*, Dart_Handle) {}
+    static void removeWrapper(DartDOMData*, typename BindingsClass::NativeType*) {}
+};
+
+template<class BindingsClass>
+struct DartDOMWrapperEventTargetTraits<BindingsClass, true> {
+    static void setWrapper(DartDOMData* domData, typename BindingsClass::NativeType* domObject, Dart_Handle wrapper)
+    {
+        domData->eventTargetMap()->set(domObject, wrapper);
+    }
+
+    static void removeWrapper(DartDOMData* domData, typename BindingsClass::NativeType* domObject)
+    {
+        domData->eventTargetMap()->remove(domObject);
+    }
+};
+
 template<class BindingsClass>
 struct DartDOMWrapperTraits {
     typedef DartDOMWrapperMapTraits<BindingsClass::isNode> MapTraits;
     typedef DartDOMWrapperActiveTraits<BindingsClass, BindingsClass::isActive> ActiveTraits;
+    // Putting all the nodes into additional map is expensive. Instead, we have
+    // special treatment of node event listeners in GC prologue.
+    typedef DartDOMWrapperEventTargetTraits<BindingsClass, BindingsClass::isEventTarget && !BindingsClass::isNode> EventTargetTraits;
 };
 
 class DartMessagePort;
 
 template<>
 struct DartDOMWrapperTraits<DartMessagePort> {
     struct MessagePortMapTraits {
         static DartMessagePortMap* domMap(DartDOMData* domData) { return domData->messagePortMap(); }
     };
     typedef MessagePortMapTraits MapTraits;
     typedef DartDOMWrapperActiveTraits<DartMessagePort, false> ActiveTraits;
+    typedef DartDOMWrapperEventTargetTraits<DartMessagePort, true> EventTargetTraits;
 };
 
 }
 
 #endif // DartDOMWrapper_h