reflow comments in platform/heap

third_party/WebKit/Source/platform/heap/HeapPage.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 283 matching lines @@
     // Sweep a page and move the page from m_firstUnsweptPages to
     // m_firstPages.
     page->sweep();
     page->unlink(&m_firstUnsweptPage);
     page->link(&m_firstPage);
     page->markAsSwept();
   }
 }
 
 bool BaseArena::lazySweepWithDeadline(double deadlineSeconds) {
-  // It might be heavy to call Platform::current()->monotonicallyIncreasingTimeSeconds()
-  // per page (i.e., 128 KB sweep or one LargeObject sweep), so we check
-  // the deadline per 10 pages.
+  // It might be heavy to call
+  // Platform::current()->monotonicallyIncreasingTimeSeconds() per page (i.e.,
+  // 128 KB sweep or one LargeObject sweep), so we check the deadline per 10
+  // pages.
   static const int deadlineCheckInterval = 10;
 
   RELEASE_ASSERT(getThreadState()->isSweepingInProgress());
   ASSERT(getThreadState()->sweepForbidden());
   ASSERT(!getThreadState()->isMainThread() ||
          ScriptForbiddenScope::isScriptForbidden());
 
   NormalPageArena* normalArena = nullptr;
   if (m_firstUnsweptPage && !m_firstUnsweptPage->isLargeObjectPage()) {
     // Mark this NormalPageArena as being lazily swept.
@@ skipping 40 matching lines @@
   LargeObjectArena* largeObjectArena = static_cast<LargeObjectArena*>(
       getThreadState()->arena(BlinkGC::LargeObjectArenaIndex));
   Address largeObject =
       largeObjectArena->allocateLargeObjectPage(allocationSize, gcInfoIndex);
   ASAN_MARK_LARGE_VECTOR_CONTAINER(this, largeObject);
   return largeObject;
 }
 
 bool BaseArena::willObjectBeLazilySwept(BasePage* page,
                                         void* objectPointer) const {
-  // If not on the current page being (potentially) lazily swept, |objectPointer|
-  // is an unmarked, sweepable object.
+  // If not on the current page being (potentially) lazily swept,
+  // |objectPointer| is an unmarked, sweepable object.
   if (page != m_firstUnsweptPage)
     return true;
 
   DCHECK(!page->isLargeObjectPage());
   // Check if the arena is currently being lazily swept.
   NormalPage* normalPage = reinterpret_cast<NormalPage*>(page);
   NormalPageArena* normalArena = normalPage->arenaForNormalPage();
   if (!normalArena->isLazySweeping())
     return true;
 
   // Rare special case: unmarked object is on the page being lazily swept,
-  // and a finalizer for an object on that page calls ThreadHeap::willObjectBeLazilySwept().
+  // and a finalizer for an object on that page calls
+  // ThreadHeap::willObjectBeLazilySwept().
   //
-  // Need to determine if |objectPointer| represents a live (unmarked) object or an
-  // unmarked object that will be lazily swept later. As lazy page sweeping
+  // Need to determine if |objectPointer| represents a live (unmarked) object or
+  // an unmarked object that will be lazily swept later. As lazy page sweeping
   // doesn't record a frontier pointer representing how far along it is, the
   // page is scanned from the start, skipping past freed & unmarked regions.
   //
-  // If no marked objects are encountered before |objectPointer|, we know
-  // that the finalizing object calling willObjectBeLazilySwept() comes later,
-  // and |objectPointer| has been deemed to be alive already (=> it won't be swept.)
+  // If no marked objects are encountered before |objectPointer|, we know that
+  // the finalizing object calling willObjectBeLazilySwept() comes later, and
+  // |objectPointer| has been deemed to be alive already (=> it won't be swept.)
   //
   // If a marked object is encountered before |objectPointer|, it will
   // not have been lazily swept past already. Hence it represents an unmarked,
   // sweepable object.
   //
   // As willObjectBeLazilySwept() is used rarely and it happening to be
   // used while runnning a finalizer on the page being lazily swept is
   // even rarer, the page scan is considered acceptable and something
   // really wanted -- willObjectBeLazilySwept()'s result can be trusted.
   Address pageEnd = normalPage->payloadEnd();
@@ skipping 328 matching lines @@
   }
   return result;
 }
 
 void NormalPageArena::setRemainingAllocationSize(
     size_t newRemainingAllocationSize) {
   m_remainingAllocationSize = newRemainingAllocationSize;
 
   // Sync recorded allocated-object size:
   //  - if previous alloc checkpoint is larger, allocation size has increased.
-  //  - if smaller, a net reduction in size since last call to updateRemainingAllocationSize().
+  //  - if smaller, a net reduction in size since last call to
+  //  updateRemainingAllocationSize().
   if (m_lastRemainingAllocationSize > m_remainingAllocationSize)
     getThreadState()->increaseAllocatedObjectSize(
         m_lastRemainingAllocationSize - m_remainingAllocationSize);
   else if (m_lastRemainingAllocationSize != m_remainingAllocationSize)
     getThreadState()->decreaseAllocatedObjectSize(
         m_remainingAllocationSize - m_lastRemainingAllocationSize);
   m_lastRemainingAllocationSize = m_remainingAllocationSize;
 }
 
 void NormalPageArena::updateRemainingAllocationSize() {
@@ skipping 727 matching lines @@
   pageDump->AddScalar("live_size", "bytes", liveSize);
   pageDump->AddScalar("dead_size", "bytes", deadSize);
   pageDump->AddScalar("free_size", "bytes", freeSize);
   heapInfo.freeSize += freeSize;
   heapInfo.freeCount += freeCount;
 }
 
 #if ENABLE(ASSERT)
 bool NormalPage::contains(Address addr) {
   Address blinkPageStart = roundToBlinkPageStart(getAddress());
-  ASSERT(
-      blinkPageStart ==
-      getAddress() -
-          blinkGuardPageSize);  // Page is at aligned address plus guard page size.
+  // Page is at aligned address plus guard page size.
+  ASSERT(blinkPageStart == getAddress() - blinkGuardPageSize);
   return blinkPageStart <= addr && addr < blinkPageStart + blinkPageSize;
 }
 #endif
 
 LargeObjectPage::LargeObjectPage(PageMemory* storage,
                                  BaseArena* arena,
                                  size_t payloadSize)
     : BasePage(storage, arena),
       m_payloadSize(payloadSize)
 #if ENABLE(ASAN_CONTAINER_ANNOTATIONS)
@@ skipping 130 matching lines @@
 
   m_hasEntries = true;
   size_t index = hash(address);
   ASSERT(!(index & 1));
   Address cachePage = roundToBlinkPageStart(address);
   m_entries[index + 1] = m_entries[index];
   m_entries[index] = cachePage;
 }
 
 }  // namespace blink