Slightly tidy up the usage of SweepForbiddenScope and ScriptForbiddenScope

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 602 matching lines @@
   // This check is here to prevent performIdleLazySweep() from being called
   // recursively. I'm not sure if it can happen but it would be safer to have
   // the check just in case.
   if (sweepForbidden())
     return;
 
   TRACE_EVENT1("blink_gc,devtools.timeline",
                "ThreadState::performIdleLazySweep", "idleDeltaInSeconds",
                deadlineSeconds - monotonicallyIncreasingTime());
 
+  SweepForbiddenScope scope(this);
+  ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
+
+  double startTime = WTF::currentTimeMS();
   bool sweepCompleted = true;
-  SweepForbiddenScope scope(this);
-  {
-    double startTime = WTF::currentTimeMS();
-    ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
-
-    for (int i = 0; i < BlinkGC::NumberOfArenas; 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 - monotonicallyIncreasingTime();
-      if (remainingBudget <= 0 ||
-          !m_arenas[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;
-      }
+  for (int i = 0; i < BlinkGC::NumberOfArenas; 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 - monotonicallyIncreasingTime();
+    if (remainingBudget <= 0 ||
+        !m_arenas[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;
     }
-
-    accumulateSweepingTime(WTF::currentTimeMS() - startTime);
   }
+  accumulateSweepingTime(WTF::currentTimeMS() - startTime);
 
   if (sweepCompleted)
     postSweep();
 }
 
 void ThreadState::scheduleIdleGC() {
   // TODO(haraken): Idle GC should be supported in worker threads as well.
   if (!isMainThread())
     return;
 
@@ skipping 318 matching lines @@
   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);
-  {
-    ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
+  ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
-    TRACE_EVENT0("blink_gc,devtools.timeline", "ThreadState::completeSweep");
-    double startTime = WTF::currentTimeMS();
+  TRACE_EVENT0("blink_gc,devtools.timeline", "ThreadState::completeSweep");
+  double startTime = WTF::currentTimeMS();
 
-    static_assert(BlinkGC::EagerSweepArenaIndex == 0,
-                  "Eagerly swept arenas must be processed first.");
-    for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
-      m_arenas[i]->completeSweep();
+  static_assert(BlinkGC::EagerSweepArenaIndex == 0,
+                "Eagerly swept arenas must be processed first.");
+  for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
+    m_arenas[i]->completeSweep();
 
-    double timeForCompleteSweep = WTF::currentTimeMS() - startTime;
-    accumulateSweepingTime(timeForCompleteSweep);
+  double timeForCompleteSweep = WTF::currentTimeMS() - startTime;
+  accumulateSweepingTime(timeForCompleteSweep);
 
-    if (isMainThread()) {
-      DEFINE_STATIC_LOCAL(CustomCountHistogram, completeSweepHistogram,
-                          ("BlinkGC.CompleteSweep", 1, 10 * 1000, 50));
-      completeSweepHistogram.count(timeForCompleteSweep);
-    }
+  if (isMainThread()) {
+    DEFINE_STATIC_LOCAL(CustomCountHistogram, completeSweepHistogram,
+                        ("BlinkGC.CompleteSweep", 1, 10 * 1000, 50));
+    completeSweepHistogram.count(timeForCompleteSweep);
   }
 
   postSweep();
 }
 
 void ThreadState::postSweep() {
   ASSERT(checkThread());
   ThreadHeap::reportMemoryUsageForTracing();
 
   if (isMainThread()) {
@@ skipping 260 matching lines @@
 
 void ThreadState::unlockThreadAttachMutex() {
   m_heap->threadAttachMutex().unlock();
 }
 
 void ThreadState::invokePreFinalizers() {
   ASSERT(checkThread());
   ASSERT(!sweepForbidden());
   TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
 
+  SweepForbiddenScope sweepForbidden(this);

[haraken, 2017/02/15 09:37:15]

Actually this is not needed though.

+  ScriptForbiddenIfMainThreadScope scriptForbidden;
+
   double startTime = WTF::currentTimeMS();
   if (!m_orderedPreFinalizers.isEmpty()) {
-    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;
@@ skipping 269 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink