DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

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 118 matching lines @@
 
 void BaseArena::takeSnapshot(const String& dumpBaseName,
                              ThreadState::GCSnapshotInfo& info) {
   // |dumpBaseName| at this point is "blink_gc/thread_X/heaps/HeapName"
   base::trace_event::MemoryAllocatorDump* allocatorDump =
       BlinkGCMemoryDumpProvider::instance()
           ->createMemoryAllocatorDumpForCurrentGC(dumpBaseName);
   size_t pageCount = 0;
   BasePage::HeapSnapshotInfo heapInfo;
   for (BasePage* page = m_firstUnsweptPage; page; page = page->next()) {
-    String dumpName =
-        dumpBaseName + String::format("/pages/page_%lu",
-                                      static_cast<unsigned long>(pageCount++));
+    String dumpName = dumpBaseName +
+                      String::format("/pages/page_%lu",
+                                     static_cast<unsigned long>(pageCount++));
     base::trace_event::MemoryAllocatorDump* pageDump =
         BlinkGCMemoryDumpProvider::instance()
             ->createMemoryAllocatorDumpForCurrentGC(dumpName);
 
     page->takeSnapshot(pageDump, info, heapInfo);
   }
   allocatorDump->AddScalar("blink_page_count", "objects", pageCount);
 
   // When taking a full dump (w/ freelist), both the /buckets and /pages
   // report their free size but they are not meant to be added together.
@@ skipping 540 matching lines @@
         CHECK_MEMORY_INACCESSIBLE(headerAddress, size);
         freedSize += size;
         headerAddress += size;
         continue;
       }
       if (header->isFree()) {
         // Zero the memory in the free list header to maintain the
         // invariant that memory on the free list is zero filled.
         // The rest of the memory is already on the free list and is
         // therefore already zero filled.
-        SET_MEMORY_INACCESSIBLE(headerAddress, size < sizeof(FreeListEntry)
-                                                   ? size
-                                                   : sizeof(FreeListEntry));
+        SET_MEMORY_INACCESSIBLE(
+            headerAddress,
+            size < sizeof(FreeListEntry) ? size : sizeof(FreeListEntry));
         CHECK_MEMORY_INACCESSIBLE(headerAddress, size);
         headerAddress += size;
         continue;
       }
       ASSERT(header->checkHeader());
       if (startOfGap != headerAddress)
         addToFreeList(startOfGap, headerAddress - startOfGap);
 
       headerAddress += size;
       startOfGap = headerAddress;
@@ skipping 495 matching lines @@
 bool FreeList::takeSnapshot(const String& dumpBaseName) {
   bool didDumpBucketStats = false;
   for (size_t i = 0; i < blinkPageSizeLog2; ++i) {
     size_t entryCount = 0;
     size_t freeSize = 0;
     for (FreeListEntry* entry = m_freeLists[i]; entry; entry = entry->next()) {
       ++entryCount;
       freeSize += entry->size();
     }
 
-    String dumpName =
-        dumpBaseName + String::format("/buckets/bucket_%lu",
-                                      static_cast<unsigned long>(1 << i));
+    String dumpName = dumpBaseName +
+                      String::format("/buckets/bucket_%lu",
+                                     static_cast<unsigned long>(1 << i));
     base::trace_event::MemoryAllocatorDump* bucketDump =
         BlinkGCMemoryDumpProvider::instance()
             ->createMemoryAllocatorDumpForCurrentGC(dumpName);
     bucketDump->AddScalar("free_count", "objects", entryCount);
     bucketDump->AddScalar("free_size", "bytes", freeSize);
     didDumpBucketStats = true;
   }
   return didDumpBucketStats;
 }
 
@@ skipping 58 matching lines @@
     ASSERT(size > 0);
     ASSERT(size < blinkPagePayloadSize());
 
     if (header->isPromptlyFreed())
       pageArena->decreasePromptlyFreedSize(size);
     if (header->isFree()) {
       // Zero the memory in the free list header to maintain the
       // invariant that memory on the free list is zero filled.
       // The rest of the memory is already on the free list and is
       // therefore already zero filled.
-      SET_MEMORY_INACCESSIBLE(headerAddress, size < sizeof(FreeListEntry)
-                                                 ? size
-                                                 : sizeof(FreeListEntry));
+      SET_MEMORY_INACCESSIBLE(
+          headerAddress,
+          size < sizeof(FreeListEntry) ? size : sizeof(FreeListEntry));
       CHECK_MEMORY_INACCESSIBLE(headerAddress, size);
       headerAddress += size;
       continue;
     }
     if (!header->isMarked()) {
       // This is a fast version of header->payloadSize().
       size_t payloadSize = size - sizeof(HeapObjectHeader);
       Address payload = header->payload();
       // For ASan, unpoison the object before calling the finalizer. The
       // finalized object will be zero-filled and poison'ed afterwards.
@@ skipping 149 matching lines @@
         reinterpret_cast<HeapObjectHeader*>(headerAddress);
     size_t size = header->size();
     ASSERT(size < blinkPagePayloadSize());
     if (header->isPromptlyFreed())
       arenaForNormalPage()->decreasePromptlyFreedSize(size);
     if (header->isFree()) {
       // Zero the memory in the free list header to maintain the
       // invariant that memory on the free list is zero filled.
       // The rest of the memory is already on the free list and is
       // therefore already zero filled.
-      SET_MEMORY_INACCESSIBLE(headerAddress, size < sizeof(FreeListEntry)
-                                                 ? size
-                                                 : sizeof(FreeListEntry));
+      SET_MEMORY_INACCESSIBLE(
+          headerAddress,
+          size < sizeof(FreeListEntry) ? size : sizeof(FreeListEntry));
       CHECK_MEMORY_INACCESSIBLE(headerAddress, size);
       headerAddress += size;
       continue;
     }
     if (startOfGap != headerAddress)
       normalArena->addToFreeList(startOfGap, headerAddress - startOfGap);
     if (header->isMarked())
       header->unmark();
     headerAddress += size;
     startOfGap = headerAddress;
@@ skipping 328 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