reflow comments in wtf/allocator

third_party/WebKit/Source/wtf/allocator/PageAllocator.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 81 matching lines @@
                        : PROT_NONE;
   ret = mmap(hint, len, accessFlag, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   if (ret == MAP_FAILED) {
     releaseStore(&s_allocPageErrorCode, errno);
     ret = 0;
   }
 #endif
   return ret;
 }
 
-// Trims base to given length and alignment. Windows returns null on failure and frees base.
+// Trims base to given length and alignment. Windows returns null on failure and
+// frees base.
 static void* trimMapping(void* base,
                          size_t baseLen,
                          size_t trimLen,
                          uintptr_t align,
                          PageAccessibilityConfiguration pageAccessibility) {
   size_t preSlack = reinterpret_cast<uintptr_t>(base) & (align - 1);
   if (preSlack)
     preSlack = align - preSlack;
   size_t postSlack = baseLen - preSlack - trimLen;
   ASSERT(baseLen >= trimLen || preSlack || postSlack);
@@ skipping 58 matching lines @@
 #endif
     } else if (!addr) {  // We know we're OOM when an unhinted allocation fails.
       return nullptr;
 
     } else {
 #if CPU(32BIT)
       addr = reinterpret_cast<char*>(addr) + align;
 #endif
     }
 
-#if !CPU( \
-    32BIT)  // Keep trying random addresses on systems that have a large address space.
+#if !CPU(32BIT)
+    // Keep trying random addresses on systems that have a large address space.
     addr = getRandomPageBase();
     addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(addr) &
                                    alignBaseMask);
 #endif
   }
 
-  // Map a larger allocation so we can force alignment, but continue randomizing only on 64-bit POSIX.
+  // Map a larger allocation so we can force alignment, but continue randomizing
+  // only on 64-bit POSIX.
   size_t tryLen = len + (align - kPageAllocationGranularity);
   RELEASE_ASSERT(tryLen >= len);
   void* ret;
 
   do {
     // Don't continue to burn cycles on mandatory hints (Windows).
     addr = kHintIsAdvisory ? getRandomPageBase() : nullptr;
     ret = systemAllocPages(addr, tryLen, pageAccessibility);
-    // The retries are for Windows, where a race can steal our mapping on resize.
+    // The retries are for Windows, where a race can steal our mapping on
+    // resize.
   } while (ret &&
            !(ret = trimMapping(ret, tryLen, len, align, pageAccessibility)));
 
   return ret;
 }
 
 void freePages(void* addr, size_t len) {
   ASSERT(!(reinterpret_cast<uintptr_t>(addr) &
            kPageAllocationGranularityOffsetMask));
   ASSERT(!(len & kPageAllocationGranularityOffsetMask));
@@ skipping 58 matching lines @@
   // not guaranteed to be zeroed when returned to the application.
   using DiscardVirtualMemoryFunction =
       DWORD(WINAPI*)(PVOID virtualAddress, SIZE_T size);
   static DiscardVirtualMemoryFunction discardVirtualMemory =
       reinterpret_cast<DiscardVirtualMemoryFunction>(-1);
   if (discardVirtualMemory ==
       reinterpret_cast<DiscardVirtualMemoryFunction>(-1))
     discardVirtualMemory =
         reinterpret_cast<DiscardVirtualMemoryFunction>(GetProcAddress(
             GetModuleHandle(L"Kernel32.dll"), "DiscardVirtualMemory"));
-  // Use DiscardVirtualMemory when available because it releases faster than MEM_RESET.
+  // Use DiscardVirtualMemory when available because it releases faster than
+  // MEM_RESET.
   DWORD ret = 1;
   if (discardVirtualMemory)
     ret = discardVirtualMemory(addr, len);
-  // DiscardVirtualMemory is buggy in Win10 SP0, so fall back to MEM_RESET on failure.
+  // DiscardVirtualMemory is buggy in Win10 SP0, so fall back to MEM_RESET on
+  // failure.
   if (ret) {
     void* ret = VirtualAlloc(addr, len, MEM_RESET, PAGE_READWRITE);
     RELEASE_ASSERT(ret);
   }
 #endif
 }
 
 uint32_t getAllocPageErrorCode() {
   return acquireLoad(&s_allocPageErrorCode);
 }
 
 }  // namespace WTF