Improve ScriptForbiddenScope handling in cross-threaded code.

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 449 matching lines @@
     return false;
 }
 
 void ThreadState::threadLocalWeakProcessing()
 {
     ASSERT(checkThread());
     ASSERT(!sweepForbidden());
     TRACE_EVENT0("blink_gc", "ThreadState::threadLocalWeakProcessing");
     double startTime = WTF::currentTimeMS();
 
-    SweepForbiddenScope forbiddenScope(this);
-    if (isMainThread())
-        ScriptForbiddenScope::enter();
+    SweepForbiddenScope sweepForbiddenScope(this);
+    ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
     // Disallow allocation during weak processing.
     // It would be technically safe to allow allocations, but it is unsafe
     // to mutate an object graph in a way in which a dead object gets
     // resurrected or mutate a HashTable (because HashTable's weak processing
     // assumes that the HashTable hasn't been mutated since the latest marking).
     // Due to the complexity, we just forbid allocations.
     NoAllocationScope noAllocationScope(this);
 
     MarkingVisitor<Visitor::WeakProcessing> weakProcessingVisitor;
 
     // Perform thread-specific weak processing.
     while (popAndInvokeThreadLocalWeakCallback(&weakProcessingVisitor)) { }
 
     if (isMainThread()) {
-        ScriptForbiddenScope::exit();
         double timeForThreadLocalWeakProcessing = WTF::currentTimeMS() - startTime;
         Platform::current()->histogramCustomCounts("BlinkGC.timeForThreadLocalWeakProcessing", timeForThreadLocalWeakProcessing, 1, 10 * 1000, 50);
     }
 }
 
 CrossThreadPersistentRegion& ThreadState::crossThreadPersistentRegion()
 {
     AtomicallyInitializedStaticReference(CrossThreadPersistentRegion, persistentRegion, new CrossThreadPersistentRegion());
     return persistentRegion;
 }
@@ skipping 278 matching lines @@
     // the check just in case.
     if (sweepForbidden())
         return;
 
     TRACE_EVENT1("blink_gc", "ThreadState::performIdleLazySweep", "idleDeltaInSeconds", deadlineSeconds - Platform::current()->monotonicallyIncreasingTimeSeconds());
 
     bool sweepCompleted = true;
     SweepForbiddenScope scope(this);
     {
         double startTime = WTF::currentTimeMS();
-        if (isMainThread())
-            ScriptForbiddenScope::enter();
+        ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
         for (int i = 0; i < BlinkGC::NumberOfHeaps; i++) {
             // lazySweepWithDeadline() won't check the deadline until it sweeps
             // 10 pages. So we give a small slack for safety.
             double slack = 0.001;
             double remainingBudget = deadlineSeconds - slack - Platform::current()->monotonicallyIncreasingTimeSeconds();
             if (remainingBudget <= 0 || !m_heaps[i]->lazySweepWithDeadline(deadlineSeconds)) {
                 // We couldn't finish the sweeping within the deadline.
                 // We request another idle task for the remaining sweeping.
                 scheduleIdleLazySweep();
                 sweepCompleted = false;
                 break;
             }
         }
 
-        if (isMainThread())
-            ScriptForbiddenScope::exit();
         accumulateSweepingTime(WTF::currentTimeMS() - startTime);
     }
 
     if (sweepCompleted)
         postSweep();
 }
 
 void ThreadState::scheduleIdleGC()
 {
     // TODO(haraken): Idle GC should be supported in worker threads as well.
@@ skipping 252 matching lines @@
     // Some objects need to be finalized promptly and cannot be handled
     // by lazy sweeping. Keep those in a designated heap and sweep it
     // eagerly.
     ASSERT(isSweepingInProgress());
 
     // Mirroring the completeSweep() condition; see its comment.
     if (sweepForbidden())
         return;
 
     SweepForbiddenScope scope(this);
-    {
-        double startTime = WTF::currentTimeMS();
-        if (isMainThread())
-            ScriptForbiddenScope::enter();
+    ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
-        m_heaps[BlinkGC::EagerSweepHeapIndex]->completeSweep();
-
-        if (isMainThread())
-            ScriptForbiddenScope::exit();
-        accumulateSweepingTime(WTF::currentTimeMS() - startTime);
-    }
+    double startTime = WTF::currentTimeMS();
+    m_heaps[BlinkGC::EagerSweepHeapIndex]->completeSweep();
+    accumulateSweepingTime(WTF::currentTimeMS() - startTime);
 }
 
 void ThreadState::completeSweep()
 {
     ASSERT(checkThread());
     // If we are not in a sweeping phase, there is nothing to do here.
     if (!isSweepingInProgress())
         return;
 
     // completeSweep() can be called recursively if finalizers can allocate
     // memory and the allocation triggers completeSweep(). This check prevents
     // the sweeping from being executed recursively.
     if (sweepForbidden())
         return;
 
     SweepForbiddenScope scope(this);
     {
-        if (isMainThread())
-            ScriptForbiddenScope::enter();
+        ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
         TRACE_EVENT0("blink_gc", "ThreadState::completeSweep");
         double startTime = WTF::currentTimeMS();
 
         static_assert(BlinkGC::EagerSweepHeapIndex == 0, "Eagerly swept heaps must be processed first.");
         for (int i = 0; i < BlinkGC::NumberOfHeaps; i++)
             m_heaps[i]->completeSweep();
 
         double timeForCompleteSweep = WTF::currentTimeMS() - startTime;
         accumulateSweepingTime(timeForCompleteSweep);
 
-        if (isMainThread()) {
-            ScriptForbiddenScope::exit();
+        if (isMainThread())
             Platform::current()->histogramCustomCounts("BlinkGC.CompleteSweep", timeForCompleteSweep, 1, 10 * 1000, 50);
-        }
     }
 
     postSweep();
 }
 
 void ThreadState::postSweep()
 {
     ASSERT(checkThread());
     Heap::reportMemoryUsageForTracing();
 
@@ skipping 201 matching lines @@
 }
 
 void ThreadState::invokePreFinalizers()
 {
     ASSERT(checkThread());
     ASSERT(!sweepForbidden());
     TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
 
     double startTime = WTF::currentTimeMS();
     if (!m_orderedPreFinalizers.isEmpty()) {
-        SweepForbiddenScope forbiddenScope(this);
-        if (isMainThread())
-            ScriptForbiddenScope::enter();
+        SweepForbiddenScope sweepForbidden(this);
+        ScriptForbiddenIfMainThreadScope scriptForbidden;
 
         // Call the prefinalizers in the opposite order to their registration.
         //
         // The prefinalizer callback wrapper returns |true| when its associated
         // object is unreachable garbage and the prefinalizer callback has run.
         // The registered prefinalizer entry must then be removed and deleted.
         //
         auto it = --m_orderedPreFinalizers.end();
         bool done;
         do {
             auto entry = it;
             done = it == m_orderedPreFinalizers.begin();
             if (!done)
                 --it;
             if ((entry->second)(entry->first))
                 m_orderedPreFinalizers.remove(entry);
         } while (!done);
-
-        if (isMainThread())
-            ScriptForbiddenScope::exit();
     }
     if (isMainThread()) {
         double timeForInvokingPreFinalizers = WTF::currentTimeMS() - startTime;
         Platform::current()->histogramCustomCounts("BlinkGC.TimeForInvokingPreFinalizers", timeForInvokingPreFinalizers, 1, 10 * 1000, 50);
     }
 }
 
 void ThreadState::clearHeapAges()
 {
     memset(m_heapAges, 0, sizeof(size_t) * BlinkGC::NumberOfHeaps);
@@ skipping 115 matching lines @@
     threadDump->addScalar("dead_count", "objects", totalDeadCount);
     threadDump->addScalar("live_size", "bytes", totalLiveSize);
     threadDump->addScalar("dead_size", "bytes", totalDeadSize);
 
     WebMemoryAllocatorDump* heapsDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(heapsDumpName);
     WebMemoryAllocatorDump* classesDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(classesDumpName);
     BlinkGCMemoryDumpProvider::instance()->currentProcessMemoryDump()->addOwnershipEdge(classesDump->guid(), heapsDump->guid());
 }
 
 } // namespace blink