Oilpan: HeapTest: FinalizationObserverWithHashMap should not leave a Persistent object.

Source/platform/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 1096 matching lines @@
     {
         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 void clearObservers()
+    {
+        delete s_observerMap;
+        s_observerMap = nullptr;
+    }
+
     static bool s_didCallWillFinalize;
 
 private:
     static ObserverMap& observers()
     {
-        DEFINE_STATIC_LOCAL(Persistent<ObserverMap>, observerMap, ());
-        if (!observerMap)
-            observerMap = new ObserverMap();
-        return *observerMap;
+        if (!s_observerMap)
+            s_observerMap = new Persistent<ObserverMap>(new ObserverMap());
+        return **s_observerMap;
     }
 
     Observable& m_target;
+    static Persistent<ObserverMap>* s_observerMap;
 };
 
 bool FinalizationObserverWithHashMap::s_didCallWillFinalize = false;
+Persistent<FinalizationObserverWithHashMap::ObserverMap>* FinalizationObserverWithHashMap::s_observerMap;
 
 class SuperClass;
 
 class PointsBack : public RefCountedWillBeGarbageCollectedFinalized<PointsBack> {
 public:
     static PassRefPtrWillBeRawPtr<PointsBack> create()
     {
         return adoptRefWillBeNoop(new PointsBack());
     }
 
@@ skipping 2162 matching lines @@
     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);
+
+    FinalizationObserverWithHashMap::clearObservers();
 }
 
 TEST(HeapTest, PreFinalizer)
 {
     Observable::s_willFinalizeWasCalled = false;
     {
         Observable* foo = Observable::create(Bar::create());
         ThreadState::current()->registerPreFinalizer(*foo);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
@@ skipping 2073 matching lines @@
 TEST(HeapTest, NonNodeAllocatingNodeInDestructor)
 {
     new NonNodeAllocatingNodeInDestructor();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(10, (*NonNodeAllocatingNodeInDestructor::s_node)->value());
     delete NonNodeAllocatingNodeInDestructor::s_node;
     NonNodeAllocatingNodeInDestructor::s_node = 0;
 }
 
 } // namespace blink