Remove BlinkGCInterruptor

third_party/WebKit/Source/platform/heap/ThreadState.h

 /*
  * 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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ThreadState_h
 #define ThreadState_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/BlinkGC.h"
-#include "platform/heap/BlinkGCInterruptor.h"
 #include "platform/heap/ThreadingTraits.h"
 #include "public/platform/WebThread.h"
 #include "wtf/AddressSanitizer.h"
 #include "wtf/Allocator.h"
 #include "wtf/Forward.h"
 #include "wtf/Functional.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/ThreadSpecific.h"
 #include "wtf/Threading.h"
@@ skipping 265 matching lines @@
   // Notice that a thread does not have to be paused if it is at safepoint it
   // can continue to run and perform tasks that do not require interaction
   // with the heap. It will be paused if it attempts to leave the safepoint and
   // there is a GC in progress.
   //
   // Each thread that has ThreadState attached must:
   //   - periodically check if GC is requested from another thread by calling a
   //     safePoint() method;
   //   - use SafePointScope around long running loops that have no safePoint()
   //     invocation inside, such loops must not touch any heap object;
-  //   - register an BlinkGCInterruptor that can interrupt long running loops
-  //     that have no calls to safePoint and are not wrapped in a SafePointScope
-  //     (e.g. BlinkGCInterruptor for JavaScript code)
   //
-
   // Check if GC is requested by another thread and pause this thread if this is
   // the case.  Can only be called when current thread is in a consistent state.
   void safePoint(BlinkGC::StackState);
 
   // Mark current thread as running inside safepoint.
   void enterSafePoint(BlinkGC::StackState, void*);
   void leaveSafePoint();
 
-  void addInterruptor(std::unique_ptr<BlinkGCInterruptor>);
-
   void recordStackEnd(intptr_t* endOfStack) { m_endOfStack = endOfStack; }
 
   // Get one of the heap structures for this thread.
   // The thread heap is split into multiple heap parts based on object types
   // and object sizes.
   BaseArena* arena(int arenaIndex) const {
     ASSERT(0 <= arenaIndex);
     ASSERT(arenaIndex < BlinkGC::NumberOfArenas);
     return m_arenas[arenaIndex];
   }
@@ skipping 254 matching lines @@
 
   void invokePreFinalizers();
 
   void takeSnapshot(SnapshotType);
   void clearArenaAges();
   int arenaIndexOfVectorArenaLeastRecentlyExpanded(int beginArenaIndex,
                                                    int endArenaIndex);
 
   void reportMemoryToV8();
 
-  // Should only be called under protection of threadAttachMutex().
-  const Vector<std::unique_ptr<BlinkGCInterruptor>>& interruptors() const {
-    return m_interruptors;
-  }
-
   friend class SafePointBarrier;
   friend class SafePointScope;
 
   static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
 
   // We can't create a static member of type ThreadState here
   // because it will introduce global constructor and destructor.
   // We would like to manage lifetime of the ThreadState attached
   // to the main thread explicitly instead and still use normal
   // constructor and destructor for the ThreadState class.
   // For this we reserve static storage for the main ThreadState
   // and lazily construct ThreadState in it using placement new.
   static uint8_t s_mainThreadStateStorage[];
 
   ThreadHeap* m_heap;
   ThreadIdentifier m_thread;
   std::unique_ptr<PersistentRegion> m_persistentRegion;
   BlinkGC::StackState m_stackState;
   intptr_t* m_startOfStack;
   intptr_t* m_endOfStack;
 
   void* m_safePointScopeMarker;
   Vector<Address> m_safePointStackCopy;
-  Vector<std::unique_ptr<BlinkGCInterruptor>> m_interruptors;
   bool m_sweepForbidden;
   size_t m_noAllocationCount;
   size_t m_gcForbiddenCount;
   size_t m_mixinsBeingConstructedCount;
   double m_accumulatedSweepingTime;
 
   BaseArena* m_arenas[BlinkGC::NumberOfArenas];
   int m_vectorBackingArenaIndex;
   size_t m_arenaAges[BlinkGC::NumberOfArenas];
   size_t m_currentArenaAges;
@@ skipping 65 matching lines @@
 class ThreadStateFor<AnyThread> {
   STATIC_ONLY(ThreadStateFor);
 
  public:
   static ThreadState* state() { return ThreadState::current(); }
 };
 
 }  // namespace blink
 
 #endif  // ThreadState_h