Remove SafePointScopes in HeapTest.cpp

third_party/WebKit/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 406 matching lines @@
   static void test(ThreadedTesterBase* tester) {
     Vector<std::unique_ptr<WebThread>, numberOfThreads> m_threads;
     for (int i = 0; i < numberOfThreads; i++) {
       m_threads.push_back(WTF::wrapUnique(
           Platform::current()->createThread("blink gc testing thread")));
       m_threads.back()->getWebTaskRunner()->postTask(
           BLINK_FROM_HERE,
           crossThreadBind(threadFunc, crossThreadUnretained(tester)));
     }
     while (tester->m_threadsToFinish) {
-      SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
       testing::yieldCurrentThread();
     }
     delete tester;
   }
 
   virtual void runThread() = 0;
 
  protected:
   static const int numberOfThreads = 10;
   static const int gcPerThread = 5;
@@ skipping 53 matching lines @@
   void runThread() override {
     ThreadState::attachCurrentThread();
 
     // Add a cross-thread persistent from this thread; the test object
     // verifies that it will have been cleared out after the threads
     // have all detached, running their termination GCs while doing so.
     addGlobalPersistent();
 
     int gcCount = 0;
     while (!done()) {
-      ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
       {
         Persistent<IntWrapper> wrapper;
 
         std::unique_ptr<GlobalIntWrapperPersistent> globalPersistent =
             createGlobalPersistent(0x0ed0cabb);
 
         for (int i = 0; i < numberOfAllocations; i++) {
           wrapper = IntWrapper::create(0x0bbac0de);
           if (!(i % 10)) {
             globalPersistent = createGlobalPersistent(0x0ed0cabb);
           }
-          SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
           testing::yieldCurrentThread();
         }
 
         if (gcCount < gcPerThread) {
           preciselyCollectGarbage();
           gcCount++;
           atomicIncrement(&m_gcCount);
         }
 
         // Taking snapshot shouldn't have any bad side effect.
         // TODO(haraken): This snapshot GC causes crashes, so disable
         // it at the moment. Fix the crash and enable it.
         // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack,
         //                            BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
         preciselyCollectGarbage();
         EXPECT_EQ(wrapper->value(), 0x0bbac0de);
         EXPECT_EQ((*globalPersistent)->value(), 0x0ed0cabb);
       }
-      SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
       testing::yieldCurrentThread();
     }
 
     ThreadState::detachCurrentThread();
     atomicDecrement(&m_threadsToFinish);
   }
 };
 
 class ThreadedWeaknessTester : public ThreadedTesterBase {
  public:
   static void test() { ThreadedTesterBase::test(new ThreadedWeaknessTester); }
 
  private:
   void runThread() override {
     ThreadState::attachCurrentThread();
 
     int gcCount = 0;
     while (!done()) {
-      ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
       {
         Persistent<HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>> weakMap =
             new HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>;
         PersistentHeapHashMap<ThreadMarker, WeakMember<IntWrapper>> weakMap2;
 
         for (int i = 0; i < numberOfAllocations; i++) {
           weakMap->insert(static_cast<unsigned>(i), IntWrapper::create(0));
           weakMap2.insert(static_cast<unsigned>(i), IntWrapper::create(0));
-          SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
           testing::yieldCurrentThread();
         }
 
         if (gcCount < gcPerThread) {
           preciselyCollectGarbage();
           gcCount++;
           atomicIncrement(&m_gcCount);
         }
 
         // Taking snapshot shouldn't have any bad side effect.
         // TODO(haraken): This snapshot GC causes crashes, so disable
         // it at the moment. Fix the crash and enable it.
         // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack,
         //                            BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
         preciselyCollectGarbage();
         EXPECT_TRUE(weakMap->isEmpty());
         EXPECT_TRUE(weakMap2.isEmpty());
       }
-      SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
       testing::yieldCurrentThread();
     }
     ThreadState::detachCurrentThread();
     atomicDecrement(&m_threadsToFinish);
   }
 };
 
 class ThreadPersistentHeapTester : public ThreadedTesterBase {
  public:
   static void test() {
@@ skipping 4675 matching lines @@
     // be marked.
     preciselyCollectGarbage();
     preciselyCollectGarbage();
 
     // Wake up the worker thread so it can continue. It will sweep
     // and perform another GC where the backing store of its
     // collection should be strongified.
     wakeWorkerThread();
 
     // Wait for the worker thread to sweep its heaps before checking.
-    {
-      SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
-      parkMainThread();
-    }
+    parkMainThread();
   }
 
  private:
   using WeakCollectionType =
       HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>>;
 
   static WeakCollectionType* allocateCollection() {
     // Create a weak collection that is kept alive by a persistent
     // and keep the contents alive with a persistents as
     // well.
     Persistent<IntWrapper> wrapper1 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper2 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper3 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper4 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper5 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper6 = IntWrapper::create(32);
     Persistent<WeakCollectionType> weakCollection = new WeakCollectionType;
     weakCollection->insert(wrapper1, wrapper1);
     weakCollection->insert(wrapper2, wrapper2);
     weakCollection->insert(wrapper3, wrapper3);
     weakCollection->insert(wrapper4, wrapper4);
     weakCollection->insert(wrapper5, wrapper5);
     weakCollection->insert(wrapper6, wrapper6);
 
     // Signal the main thread that the worker is done with its allocation.
     wakeMainThread();
 
-    {
-      // Wait for the main thread to do two GCs without sweeping
-      // this thread heap. The worker waits within a safepoint,
-      // but there is no sweeping until leaving the safepoint
-      // scope. If the weak collection backing is marked dead
-      // because of this we will not get strongification in the
-      // GC we force when we continue.
-      SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
-      parkWorkerThread();
-    }
+    // Wait for the main thread to do two GCs without sweeping
+    // this thread heap.
+    parkWorkerThread();
 
     return weakCollection;
   }
 
   static void workerThreadMain() {
     MutexLocker locker(workerThreadMutex());
 
     ThreadState::attachCurrentThread();
 
     {
@@ skipping 775 matching lines @@
   CrossThreadWeakPersistent<DestructorLockingObject> crossThreadWeakPersistent(
       object);
   object = nullptr;
   {
     MutexLocker recursiveMutexLocker(recursiveMutex());
     EXPECT_EQ(0, DestructorLockingObject::s_destructorCalls);
   }
 
   {
     // Pretend we have no pointers on stack during the step 4.
-    SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
     wakeWorkerThread();
     parkMainThread();
   }
 
   // Step 5: Make sure the weak persistent is cleared.
   EXPECT_FALSE(crossThreadWeakPersistent.get());
   {
     MutexLocker recursiveMutexLocker(recursiveMutex());
     EXPECT_EQ(1, DestructorLockingObject::s_destructorCalls);
   }
@@ skipping 240 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink