reflow comments in platform/heap

third_party/WebKit/Source/platform/heap/HeapPage.h

 /*
  * 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 71 matching lines @@
 const size_t largeObjectSizeThreshold = blinkPageSize / 2;
 
 // A zap value used for freed memory that is allowed to be added to the free
 // list in the next addToFreeList().
 const uint8_t reuseAllowedZapValue = 0x2a;
 // A zap value used for freed memory that is forbidden to be added to the free
 // list in the next addToFreeList().
 const uint8_t reuseForbiddenZapValue = 0x2c;
 
 // In non-production builds, memory is zapped when it's freed. The zapped
-// memory is zeroed out when the memory is reused in ThreadHeap::allocateObject().
+// memory is zeroed out when the memory is reused in
+// ThreadHeap::allocateObject().
 // In production builds, memory is not zapped (for performance). The memory
 // is just zeroed out when it is added to the free list.
 #if defined(MEMORY_SANITIZER)
 // TODO(kojii): We actually need __msan_poison/unpoison here, but it'll be
 // added later.
 #define SET_MEMORY_INACCESSIBLE(address, size) \
   FreeList::zapFreedMemory(address, size);
 #define SET_MEMORY_ACCESSIBLE(address, size) memset((address), 0, (size))
 #define CHECK_MEMORY_INACCESSIBLE(address, size)     \
   ASAN_UNPOISON_MEMORY_REGION(address, size);        \
@@ skipping 29 matching lines @@
 class CallbackStack;
 class FreePagePool;
 class NormalPageArena;
 class OrphanedPagePool;
 class PageMemory;
 class PageMemoryRegion;
 class WebMemoryAllocatorDump;
 
 // HeapObjectHeader is 4 byte (32 bit) that has the following layout:
 //
-// | gcInfoIndex (14 bit) | DOM mark bit (1 bit) | size (14 bit) | dead bit (1 bit) | freed bit (1 bit) | mark bit (1 bit) |
+// | gcInfoIndex (14 bit) |
+// | DOM mark bit (1 bit) |
+// | size (14 bit)        |
+// | dead bit (1 bit)     |
+// | freed bit (1 bit)    |
+// | mark bit (1 bit)     |
 //
 // - For non-large objects, 14 bit is enough for |size| because the blink
 //   page size is 2^17 byte and each object is guaranteed to be aligned with
 //   2^3 byte.
 // - For large objects, |size| is 0. The actual size of a large object is
 //   stored in LargeObjectPage::m_payloadSize.
 // - 1 bit used to mark DOM trees for V8.
 // - 14 bit is enough for gcInfoIndex because there are less than 2^14 types
 //   in Blink.
 const size_t headerWrapperMarkBitMask = 1u << 17;
@@ skipping 101 matching lines @@
 
  private:
   uint32_t m_encoded;
 #if ENABLE(ASSERT)
   uint16_t m_magic;
 #endif
 
 // In 64 bit architectures, we intentionally add 4 byte padding immediately
 // after the HeapObjectHeader. This is because:
 //
-// | HeapObjectHeader (4 byte) | padding (4 byte) | object payload (8 * n byte) |
-// ^8 byte aligned                                ^8 byte aligned
+// | HeapObjectHeader (4 byte)   |  <- 8 byte aligned
+// | padding (4 byte)            |
+// | object payload (8 * n byte) |  <- 8 byte aligned
 //
 // is better than:
 //
-// | HeapObjectHeader (4 byte) | object payload (8 * n byte) | padding (4 byte) |
-// ^4 byte aligned             ^8 byte aligned               ^4 byte aligned
+// | HeapObjectHeader (4 byte)   |  <- 4 byte aligned
+// | object payload (8 * n byte) |  <- 8 byte aligned
+// | padding (4 byte)            |  <- 4 byte aligned
 //
 // since the former layout aligns both header and payload to 8 byte.
 #if USE_4BYTE_HEADER_PADDING
  public:
   uint32_t m_padding;
 #endif
 };
 
 class FreeListEntry final : public HeapObjectHeader {
  public:
@@ skipping 314 matching lines @@
 // cache.  If there is a miss in the cache we can determine the status of the
 // pointer precisely using the heap RegionTree.
 //
 // The HeapDoesNotContainCache is a negative cache, so it must be flushed when
 // memory is added to the heap.
 class HeapDoesNotContainCache {
   USING_FAST_MALLOC(HeapDoesNotContainCache);
 
  public:
   HeapDoesNotContainCache() : m_hasEntries(false) {
-    // Start by flushing the cache in a non-empty state to initialize all the cache entries.
+    // Start by flushing the cache in a non-empty state to initialize all the
+    // cache entries.
     for (int i = 0; i < numberOfEntries; ++i)
       m_entries[i] = nullptr;
   }
 
   void flush();
   bool isEmpty() { return !m_hasEntries; }
 
   // Perform a lookup in the cache.
   //
   // If lookup returns false, the argument address was not found in
@@ skipping 300 matching lines @@
   return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 inline NormalPageArena* NormalPage::arenaForNormalPage() const {
   return static_cast<NormalPageArena*>(arena());
 }
 
 }  // namespace blink
 
 #endif  // HeapPage_h