Use enum for per thread heap enabled flag

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 530 matching lines @@
     }
 
     void addGlobalPersistent()
     {
         MutexLocker lock(m_mutex);
         m_crossPersistents.append(createGlobalPersistent(0x2a2a2a2a));
     }
 
     void runThread() override
     {
-        ThreadState::attachCurrentThread(false);
+        ThreadState::attachCurrentThread(MainThreadHeapMode);
 
         // 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);
             {
@@ skipping 36 matching lines @@
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
     }
 
 private:
     void runThread() override
     {
-        ThreadState::attachCurrentThread(false);
+        ThreadState::attachCurrentThread(MainThreadHeapMode);
 
         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->add(static_cast<unsigned>(i), IntWrapper::create(0));
@@ skipping 73 matching lines @@
         explicit PersistentChain(int count)
         {
             m_refCountedChain = adoptRef(RefCountedChain::create(count));
         }
 
         RefPtr<RefCountedChain> m_refCountedChain;
     };
 
     void runThread() override
     {
-        ThreadState::attachCurrentThread(false);
+        ThreadState::attachCurrentThread(MainThreadHeapMode);
 
         PersistentChain::create(100);
 
         // Upon thread detach, GCs will run until all persistents have been
         // released. We verify that the draining of persistents proceeds
         // as expected by dropping one Persistent<> per GC until there
         // are none left.
         ThreadState::detachCurrentThread();
         atomicDecrement(&m_threadsToFinish);
     }
@@ skipping 4312 matching lines @@
         {
             // Since the sleeper thread has detached this is the only thread.
             TestGCScope scope(BlinkGC::NoHeapPointersOnStack);
             EXPECT_TRUE(scope.allThreadsParked());
         }
     }
 
 private:
     static void sleeperMainFunc()
     {
-        ThreadState::attachCurrentThread(false);
+        ThreadState::attachCurrentThread(MainThreadHeapMode);
         s_sleeperRunning = true;
 
         // Simulate a long running op that is not entering a safepoint.
         while (!s_sleeperDone) {
             testing::yieldCurrentThread();
         }
 
         ThreadState::detachCurrentThread();
         s_sleeperRunning = false;
     }
@@ skipping 664 matching lines @@
         // shutdown.
         wakeWorkerThread();
     }
 
 private:
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
-        ThreadState::attachCurrentThread(false);
+        ThreadState::attachCurrentThread(MainThreadHeapMode);
 
         {
             // Create a worker object that is not kept alive except the
             // main thread will keep it as an integer value on its stack.
             IntWrapper* workerObject = IntWrapper::create(42);
             s_workerObjectPointer = reinterpret_cast<uintptr_t>(workerObject);
         }
 
         // Signal the main thread that the worker is done with its allocation.
         wakeMainThread();
@@ skipping 100 matching lines @@
             parkWorkerThread();
         }
 
         return weakCollection;
     }
 
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
 
-        ThreadState::attachCurrentThread(false);
+        ThreadState::attachCurrentThread(MainThreadHeapMode);
 
         {
             Persistent<WeakCollectionType> collection = allocateCollection();
             {
                 // Prevent weak processing with an iterator and GC.
                 WeakCollectionType::iterator it = collection->begin();
                 conservativelyCollectGarbage();
 
                 // The backing should be strongified because of the iterator.
                 EXPECT_EQ(6u, collection->size());
@@ skipping 140 matching lines @@
         // can acquire it and do its sweep of its arenas. Just wait for the worker
         // to complete its sweep and check the result.
         parkMainThread();
         EXPECT_EQ(1, DestructorLockingObject::s_destructorCalls);
     }
 
 private:
     static void workerThreadMain()
     {
         MutexLocker locker(workerThreadMutex());
-        ThreadState::attachCurrentThread(false);
+        ThreadState::attachCurrentThread(MainThreadHeapMode);
 
         DestructorLockingObject* dlo = DestructorLockingObject::create();
         ASSERT_UNUSED(dlo, dlo);
 
         // Wake up the main thread which is waiting for the worker to do its
         // allocation.
         wakeMainThread();
 
         // Wait for the main thread to get the global lock to ensure it has
         // it before the worker tries to acquire it. We want the worker to
@@ skipping 671 matching lines @@
     preciselyCollectGarbage();
     EXPECT_FALSE(holder->object());
 }
 
 namespace {
 
 void workerThreadMainForCrossThreadWeakPersistentTest(DestructorLockingObject** object)
 {
     // Step 2: Create an object and store the pointer.
     MutexLocker locker(workerThreadMutex());
-    ThreadState::attachCurrentThread(false);
+    ThreadState::attachCurrentThread(MainThreadHeapMode);
     *object = DestructorLockingObject::create();
     wakeMainThread();
     parkWorkerThread();
 
     // Step 4: Run a GC.
     ThreadState::current()->collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
     wakeMainThread();
     parkWorkerThread();
 
     // Step 6: Finish.
@@ skipping 105 matching lines @@
         IntWrapper::s_destructorCalls = 0;
         ThreadedTesterBase::test(new ThreadedClearOnShutdownTester);
         EXPECT_EQ(numberOfThreads, IntWrapper::s_destructorCalls);
     }
 
 private:
     void runWhileAttached();
 
     void runThread() override
     {
-        ThreadState::attachCurrentThread(false);
+        ThreadState::attachCurrentThread(MainThreadHeapMode);
         EXPECT_EQ(42, threadSpecificIntWrapper().value());
         runWhileAttached();
         ThreadState::detachCurrentThread();
         atomicDecrement(&m_threadsToFinish);
     }
 
     class HeapObject;
     friend class HeapObject;
 
     using WeakHeapObjectSet = PersistentHeapHashSet<WeakMember<HeapObject>>;
@@ skipping 151 matching lines @@
     static_assert(WTF::IsGarbageCollectedType<HeapLinkedHashSet<Member<IntWrapper>>>::value, "HeapLinkedHashSet");
     static_assert(WTF::IsGarbageCollectedType<HeapListHashSet<Member<IntWrapper>>>::value, "HeapListHashSet");
     static_assert(WTF::IsGarbageCollectedType<HeapHashCountedSet<Member<IntWrapper>>>::value, "HeapHashCountedSet");
     static_assert(WTF::IsGarbageCollectedType<HeapHashMap<int, Member<IntWrapper>>>::value, "HeapHashMap");
     static_assert(WTF::IsGarbageCollectedType<HeapVector<Member<IntWrapper>>>::value, "HeapVector");
     static_assert(WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value, "HeapDeque");
     static_assert(WTF::IsGarbageCollectedType<HeapTerminatedArray<Member<IntWrapper>>>::value, "HeapTerminatedArray");
 }
 
 } // namespace blink