reflow comments in platform/heap

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 313 matching lines @@
     oldCount = currentCount;
     currentCount = getPersistentRegion()->numberOfPersistents();
   }
   // We should not have any persistents left when getting to this point,
   // if we have it is probably a bug so adding a debug ASSERT to catch this.
   ASSERT(!currentCount);
   // All of pre-finalizers should be consumed.
   ASSERT(m_orderedPreFinalizers.isEmpty());
   RELEASE_ASSERT(gcState() == NoGCScheduled);
 
-  // Add pages to the orphaned page pool to ensure any global GCs from this point
-  // on will not trace objects on this thread's arenas.
+  // Add pages to the orphaned page pool to ensure any global GCs from this
+  // point on will not trace objects on this thread's arenas.
   cleanupPages();
 }
 
 void ThreadState::cleanupMainThread() {
   ASSERT(isMainThread());
 
 #if defined(LEAK_SANITIZER)
   // See comment below, clear out most garbage before releasing static
   // persistents should some of the finalizers depend on touching
   // these persistents.
@@ skipping 191 matching lines @@
          WTF::Partitions::totalSizeOfCommittedPages();
 }
 
 size_t ThreadState::estimatedLiveSize(size_t estimationBaseSize,
                                       size_t sizeAtLastGC) {
   if (m_heap->heapStats().wrapperCountAtLastGC() == 0) {
     // We'll reach here only before hitting the first GC.
     return 0;
   }
 
-  // (estimated size) = (estimation base size) - (heap size at the last GC) / (# of persistent handles at the last GC) * (# of persistent handles collected since the last GC);
+  // (estimated size) = (estimation base size) - (heap size at the last GC) /
+  //   (# of persistent handles at the last GC) *
+  //     (# of persistent handles collected since the last GC);
   size_t sizeRetainedByCollectedPersistents = static_cast<size_t>(
       1.0 * sizeAtLastGC / m_heap->heapStats().wrapperCountAtLastGC() *
       m_heap->heapStats().collectedWrapperCount());
   if (estimationBaseSize < sizeRetainedByCollectedPersistents)
     return 0;
   return estimationBaseSize - sizeRetainedByCollectedPersistents;
 }
 
 double ThreadState::heapGrowingRate() {
   size_t currentSize = m_heap->heapStats().allocatedObjectSize() +
@@ skipping 29 matching lines @@
                  "ThreadState::partitionAllocGrowingRate",
                  static_cast<int>(100 * growingRate));
   return growingRate;
 }
 
 // TODO(haraken): We should improve the GC heuristics. The heuristics affect
 // performance significantly.
 bool ThreadState::judgeGCThreshold(size_t allocatedObjectSizeThreshold,
                                    size_t totalMemorySizeThreshold,
                                    double heapGrowingRateThreshold) {
-  // If the allocated object size or the total memory size is small, don't trigger a GC.
+  // If the allocated object size or the total memory size is small, don't
+  // trigger a GC.
   if (m_heap->heapStats().allocatedObjectSize() <
           allocatedObjectSizeThreshold ||
       totalMemorySize() < totalMemorySizeThreshold)
     return false;
 // If the growing rate of Oilpan's heap or PartitionAlloc is high enough,
 // trigger a GC.
 #if PRINT_HEAP_STATS
   dataLogF("heapGrowingRate=%.1lf, partitionAllocGrowingRate=%.1lf\n",
            heapGrowingRate(), partitionAllocGrowingRate());
 #endif
@@ skipping 710 matching lines @@
   ASSERT(!m_atSafePoint);
   m_stackState = stackState;
   m_atSafePoint = true;
   m_heap->checkAndPark(this, nullptr);
   m_atSafePoint = false;
   m_stackState = BlinkGC::HeapPointersOnStack;
   preSweep();
 }
 
 #ifdef ADDRESS_SANITIZER
-// When we are running under AddressSanitizer with detect_stack_use_after_return=1
-// then stack marker obtained from SafePointScope will point into a fake stack.
-// Detect this case by checking if it falls in between current stack frame
-// and stack start and use an arbitrary high enough value for it.
-// Don't adjust stack marker in any other case to match behavior of code running
-// without AddressSanitizer.
+// When we are running under AddressSanitizer with
+// detect_stack_use_after_return=1 then stack marker obtained from
+// SafePointScope will point into a fake stack.  Detect this case by checking if
+// it falls in between current stack frame and stack start and use an arbitrary
+// high enough value for it.  Don't adjust stack marker in any other case to
+// match behavior of code running without AddressSanitizer.
 NO_SANITIZE_ADDRESS static void* adjustScopeMarkerForAdressSanitizer(
     void* scopeMarker) {
   Address start = reinterpret_cast<Address>(StackFrameDepth::getStackStart());
   Address end = reinterpret_cast<Address>(&start);
   RELEASE_ASSERT(end < start);
 
   if (end <= scopeMarker && scopeMarker < start)
     return scopeMarker;
 
   // 256 is as good an approximation as any else.
@@ skipping 475 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink