Remove ThreadHeap::m_threads

third_party/WebKit/Source/platform/heap/ThreadState.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 115 matching lines @@
 #if defined(LEAK_SANITIZER)
       m_disabledStaticPersistentsRegistration(0),
 #endif
       m_allocatedObjectSize(0),
       m_markedObjectSize(0),
       m_reportedMemoryToV8(0) {
   ASSERT(checkThread());
   ASSERT(!**s_threadSpecific);
   **s_threadSpecific = this;
 
-  m_heap = new ThreadHeap();
-  ASSERT(m_heap);
-  m_heap->attach(this);
+  m_heap = WTF::wrapUnique(new ThreadHeap(this));
 
   for (int arenaIndex = 0; arenaIndex < BlinkGC::LargeObjectArenaIndex;
        arenaIndex++)
     m_arenas[arenaIndex] = new NormalPageArena(this, arenaIndex);
   m_arenas[BlinkGC::LargeObjectArenaIndex] =
       new LargeObjectArena(this, BlinkGC::LargeObjectArenaIndex);
 
   m_likelyToBePromptlyFreed =
       wrapArrayUnique(new int[likelyToBePromptlyFreedArraySize]);
   clearArenaAges();
 }
 
 ThreadState::~ThreadState() {
   ASSERT(checkThread());
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     delete m_arenas[i];
 
   **s_threadSpecific = nullptr;
 }
 
 void ThreadState::attachMainThread() {
   s_threadSpecific = new WTF::ThreadSpecific<ThreadState*>();
   new (s_mainThreadStateStorage) ThreadState();
 }
 
 void ThreadState::attachCurrentThread() {
   new ThreadState();
 }
 
+void ThreadState::detachCurrentThread() {
+  ThreadState* state = current();
+  state->runTerminationGC();
+  if (state->isMainThread())
+    DCHECK_EQ(state->heap().heapStats().allocatedSpace(), 0u);
+  CHECK(state->gcState() == ThreadState::NoGCScheduled);
+  delete state;
+}
+
 void ThreadState::removeAllPages() {
   ASSERT(checkThread());
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     m_arenas[i]->removeAllPages();
 }
 
 void ThreadState::runTerminationGC() {
   if (isMainThread()) {
     removeAllPages();
     return;
@@ skipping 25 matching lines @@
   // We should not have any persistents left when getting to this point,
   // if we have it is probably a bug so adding a debug ASSERT to catch this.
   ASSERT(!currentCount);
   // All of pre-finalizers should be consumed.
   ASSERT(m_orderedPreFinalizers.isEmpty());
   RELEASE_ASSERT(gcState() == NoGCScheduled);
 
   removeAllPages();
 }
 
-void ThreadState::detachCurrentThread() {
-  ThreadState* state = current();
-  state->heap().detach(state);
-  RELEASE_ASSERT(state->gcState() == ThreadState::NoGCScheduled);
-  delete state;
-}
-
 NO_SANITIZE_ADDRESS
 void ThreadState::visitAsanFakeStackForPointer(Visitor* visitor, Address ptr) {
 #if defined(ADDRESS_SANITIZER)
   Address* start = reinterpret_cast<Address*>(m_startOfStack);
   Address* end = reinterpret_cast<Address*>(m_endOfStack);
   Address* fakeFrameStart = nullptr;
   Address* fakeFrameEnd = nullptr;
   Address* maybeFakeFrame = reinterpret_cast<Address*>(ptr);
   Address* realFrameForFakeFrame = reinterpret_cast<Address*>(
       __asan_addr_is_in_fake_stack(m_asanFakeStack, maybeFakeFrame,
@@ skipping 981 matching lines @@
   m_safePointStackCopy.resize(slotCount);
   for (size_t i = 0; i < slotCount; ++i) {
     m_safePointStackCopy[i] = from[i];
   }
 }
 
 void ThreadState::addInterruptor(
     std::unique_ptr<BlinkGCInterruptor> interruptor) {
   ASSERT(checkThread());
   SafePointScope scope(BlinkGC::HeapPointersOnStack);
-  {
-    MutexLocker locker(m_heap->threadAttachMutex());
-    m_interruptors.push_back(std::move(interruptor));
-  }
+  m_interruptors.push_back(std::move(interruptor));
 }
 
 void ThreadState::registerStaticPersistentNode(
     PersistentNode* node,
     PersistentClearCallback callback) {
 #if defined(LEAK_SANITIZER)
   if (m_disabledStaticPersistentsRegistration)
     return;
 #endif
 
@@ skipping 26 matching lines @@
 void ThreadState::enterStaticReferenceRegistrationDisabledScope() {
   m_disabledStaticPersistentsRegistration++;
 }
 
 void ThreadState::leaveStaticReferenceRegistrationDisabledScope() {
   ASSERT(m_disabledStaticPersistentsRegistration);
   m_disabledStaticPersistentsRegistration--;
 }
 #endif
 
-void ThreadState::lockThreadAttachMutex() {
-  m_heap->threadAttachMutex().lock();
-}
-
-void ThreadState::unlockThreadAttachMutex() {
-  m_heap->threadAttachMutex().unlock();
-}
-
 void ThreadState::invokePreFinalizers() {
   ASSERT(checkThread());
   ASSERT(!sweepForbidden());
   TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
 
   double startTime = WTF::currentTimeMS();
   if (!m_orderedPreFinalizers.isEmpty()) {
     SweepForbiddenScope sweepForbidden(this);
     ScriptForbiddenIfMainThreadScope scriptForbidden;
 
@@ skipping 279 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink