[oilpan] Rename PauseScope to SafePointScope

Source/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 166 matching lines @@
     bool contains(void* pointer) { return contains(reinterpret_cast<Address>(pointer)); }
     bool contains(const void* pointer) { return contains(const_cast<void*>(pointer)); }
     BaseHeapPage* heapPageFromAddress(Address);
 
     bool isAllocationAllowed() const { return !m_noAllocationCount; }
     void enterNoAllocationScope() { m_noAllocationCount++; }
     void leaveNoAllocationScope() { m_noAllocationCount--; }
 
     void executePendingAction();
 
-    void paused(StackState);
-    void resumed();
-    bool isPaused() const { return m_isPaused; }
+    void enterSafePoint(StackState);
+    void leaveSafePoint();
+    bool isInSafePoint() const { return m_inSafePoint; }
 
     bool shouldGC();
     bool shouldForceConservativeGC();
     bool isInGC() const { return m_inGC; }
     void enterGC()
     {
         if (!m_inGC++)
             s_inGC = true;
     }
     void leaveGC()
@@ skipping 27 matching lines @@
 
     static ThreadState* Current();
     static ThreadState* MainThreadState() { return &s_mainThreadState; }
     static bool IsMainThread() { return Current() == MainThreadState(); }
 
     static void stopThreads(StackState);
     static void resumeThreads();
 
     void safePoint();
 
-    class PauseScope {
+    class SafePointScope {
     public:
-        PauseScope(StackState stackState) { ThreadState::Current()->paused(stackState); }
-        ~PauseScope() { ThreadState::Current()->resumed(); }
+        SafePointScope(StackState stackState) { ThreadState::Current()->enterSafePoint(stackState); }
+        ~SafePointScope() { ThreadState::Current()->leaveSafePoint(); }
     };
 
     void visitStack(Visitor*);
     void visitPersistents(Visitor*);
     bool checkAndVisitPointer(Visitor*, Address);
     bool isConsistentForGC();
     void makeConsistentForGC();
     void getStats(HeapStats&);
     HeapStats& stats() { return m_stats; }
     HeapStats& statsAfterLastGC() { return m_statsAfterLastGC; }
@@ skipping 28 matching lines @@
     static SafePointBarrier* s_safePointBarrier;
     // This variable is flipped to true after all threads are stoped and outermost GC has started.
     static bool s_inGC;
 
     void create(intptr_t* startOfStack);
     void destroy();
     void trace(Visitor*);
     bool pointersOnStack() const { return m_stackState == HeapPointersOnStack; }
 
     ThreadIdentifier m_thread;
-    bool m_isPaused;
+    bool m_inSafePoint;

[Mads Ager (chromium), 2013/12/05 09:22:24]

m_atSafePoint?

     int m_inGC;
     PersistentNode* m_persistents;
     StackState m_stackState;
     intptr_t* m_startOfStack;
     intptr_t* m_endOfStack;
     HeapContainsCache* m_heapContainsCache;
     BaseHeap* m_heaps[NumberOfHeaps];
     PendingAction m_pendingAction;
     size_t m_noAllocationCount;
     bool m_sweepInProgress;
@@ skipping 93 matching lines @@
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WTF, Int32Array);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WTF, Uint32Array);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WTF, Float32Array);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WTF, Float64Array);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WebKit, IDBCallbacksProxy);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WebKit, IDBDatabaseBackendProxy);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WebKit, IDBDatabaseCallbacksProxy);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WebKit, IDBFactoryBackendProxy);
 
 #endif