Oilpan: Add a test to confirm that pre-finalization hook can be implmemented with HeapHashSet<WeakM…

Source/heap/HeapTest.cpp

 /*
  * Copyright (C) 2013 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 914 matching lines @@
             o->m_data->willFinalize();
             o->m_data = nullptr;
             o->m_didCallWillFinalize = true;
         }
     }
 
     WeakMember<T> m_data;
     bool m_didCallWillFinalize;
 };
 
+class FinalizationObserverWithHashMap {
+public:
+    typedef HeapHashMap<WeakMember<Observable>, OwnPtr<FinalizationObserverWithHashMap> > ObserverMap;
+
+    explicit FinalizationObserverWithHashMap(Observable& target) : m_target(target) { }
+    ~FinalizationObserverWithHashMap()
+    {
+        m_target.willFinalize();
+        s_didCallWillFinalize = true;
+    }
+
+    static ObserverMap& observe(Observable& target)
+    {
+        ObserverMap& map = observers();
+        ObserverMap::AddResult result = map.add(&target, nullptr);
+        if (result.isNewEntry)
+            result.storedValue->value = adoptPtr(new FinalizationObserverWithHashMap(target));
+        else
+            ASSERT(result.storedValue->value);
+        return map;
+    }
+
+    static bool s_didCallWillFinalize;
+
+private:
+    static ObserverMap& observers()
+    {
+        DEFINE_STATIC_LOCAL(Persistent<ObserverMap>, observerMap, ());
+        if (!observerMap)
+            observerMap = new ObserverMap();
+        return *observerMap;
+    }
+
+    Observable& m_target;
+};
+
+bool FinalizationObserverWithHashMap::s_didCallWillFinalize = false;
+
 class SuperClass;
 
 class PointsBack : public RefCountedWillBeGarbageCollectedFinalized<PointsBack> {
 public:
     static PassRefPtrWillBeRawPtr<PointsBack> create()
     {
         return adoptRefWillBeNoop(new PointsBack());
     }
 
     ~PointsBack()
@@ skipping 1679 matching lines @@
     {
         Observable* foo = Observable::create(Bar::create());
         // |o| observes |foo|.
         o = FinalizationObserver<Observable>::create(foo);
     }
     // FinalizationObserver doesn't have a strong reference to |foo|. So |foo|
     // and its member will be collected.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live);
     EXPECT_TRUE(o->didCallWillFinalize());
+
+    FinalizationObserverWithHashMap::s_didCallWillFinalize = false;
+    Observable* foo = Observable::create(Bar::create());
+    FinalizationObserverWithHashMap::ObserverMap& map = FinalizationObserverWithHashMap::observe(*foo);
+    EXPECT_EQ(1u, map.size());
+    foo = 0;
+    // FinalizationObserverWithHashMap doesn't have a strong reference to
+    // |foo|. So |foo| and its member will be collected.
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+    EXPECT_EQ(0u, Bar::s_live);
+    EXPECT_EQ(0u, map.size());
+    EXPECT_TRUE(FinalizationObserverWithHashMap::s_didCallWillFinalize);
 }
 
 TEST(HeapTest, Comparisons)
 {
     Persistent<Bar> barPersistent = Bar::create();
     Persistent<Foo> fooPersistent = Foo::create(barPersistent);
     EXPECT_TRUE(barPersistent != fooPersistent);
     barPersistent = fooPersistent;
     EXPECT_TRUE(barPersistent == fooPersistent);
 }
@@ skipping 362 matching lines @@
     // swept away and zapped later in the same sweeping phase.
     EXPECT_EQ(42, wrapper->value());
 
     wrapper.clear();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(10, IntWrapper::s_destructorCalls);
     EXPECT_EQ(512, OneKiloByteObject::s_destructorCalls);
 }
 
 } // WebCore namespace