[wrapper-tracing] Remove flag and object grouping entry points

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 968 matching lines @@
   heap().compaction()->finishThreadCompaction();
 }
 
 void ThreadState::makeConsistentForMutator() {
   ASSERT(isInGC());
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     m_arenas[i]->makeConsistentForMutator();
 }
 
 void ThreadState::preGC() {
-  if (RuntimeEnabledFeatures::traceWrappablesEnabled() && m_isolate &&
-      m_performCleanup)
+  if (m_isolate && m_performCleanup)
     m_performCleanup(m_isolate);
 
   ASSERT(!isInGC());
   setGCState(GCRunning);
   makeConsistentForGC();
   flushHeapDoesNotContainCacheIfNeeded();
   clearArenaAges();
 
   // It is possible, albeit rare, for a thread to be kept
   // at a safepoint across multiple GCs, as resuming all attached
   // threads after the "global" GC phases will contend for the shared
   // safepoint barrier mutexes etc, which can additionally delay
   // a thread. Enough so that another thread may initiate
   // a new GC before this has happened.
   //
   // In which case the parked thread's ThreadState will have unprocessed
   // entries on its local weak callback stack when that later GC goes
   // ahead. Clear out and invalidate the stack now, as the thread
   // should only process callbacks that's found to be reachable by
   // the latest GC, when it eventually gets to next perform
   // thread-local weak processing.
   m_threadLocalWeakCallbackStack->decommit();
   m_threadLocalWeakCallbackStack->commit();
 }
 
 void ThreadState::postGC(BlinkGC::GCType gcType) {
-  if (RuntimeEnabledFeatures::traceWrappablesEnabled() &&
-      m_invalidateDeadObjectsInWrappersMarkingDeque) {
+  if (m_invalidateDeadObjectsInWrappersMarkingDeque)
     m_invalidateDeadObjectsInWrappersMarkingDeque(m_isolate);
-  }
 
   ASSERT(isInGC());
   for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
     m_arenas[i]->prepareForSweep();
 
   if (gcType == BlinkGC::TakeSnapshot) {
     takeSnapshot(SnapshotType::HeapSnapshot);
 
     // This unmarks all marked objects and marks all unmarked objects dead.
     makeConsistentForMutator();
@@ skipping 753 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink