wtf reformat test

third_party/WebKit/Source/wtf/PageAllocator.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 22 matching lines @@
 
 #include "wtf/Assertions.h"
 #include "wtf/CPU.h"
 #include "wtf/WTFExport.h"
 #include <cstddef>
 #include <stdint.h>
 
 namespace WTF {
 
 #if OS(WIN)
-static const size_t kPageAllocationGranularityShift = 16; // 64KB
+static const size_t kPageAllocationGranularityShift = 16;  // 64KB
 #else
-static const size_t kPageAllocationGranularityShift = 12; // 4KB
+static const size_t kPageAllocationGranularityShift = 12;  // 4KB
 #endif
-static const size_t kPageAllocationGranularity = 1 << kPageAllocationGranularityShift;
-static const size_t kPageAllocationGranularityOffsetMask = kPageAllocationGranularity - 1;
-static const size_t kPageAllocationGranularityBaseMask = ~kPageAllocationGranularityOffsetMask;
+static const size_t kPageAllocationGranularity =
+    1 << kPageAllocationGranularityShift;
+static const size_t kPageAllocationGranularityOffsetMask =
+    kPageAllocationGranularity - 1;
+static const size_t kPageAllocationGranularityBaseMask =
+    ~kPageAllocationGranularityOffsetMask;
 
 // All Blink-supported systems have 4096 sized system pages and can handle
 // permissions and commit / decommit at this granularity.
 static const size_t kSystemPageSize = 4096;
 static const size_t kSystemPageOffsetMask = kSystemPageSize - 1;
 static const size_t kSystemPageBaseMask = ~kSystemPageOffsetMask;
 
 enum PageAccessibilityConfiguration {
-    PageAccessible,
-    PageInaccessible,
+  PageAccessible,
+  PageInaccessible,
 };
 
 // Allocate one or more pages.
 // The requested address is just a hint; the actual address returned may
 // differ. The returned address will be aligned at least to align bytes.
 // len is in bytes, and must be a multiple of kPageAllocationGranularity.
 // align is in bytes, and must be a power-of-two multiple of
 // kPageAllocationGranularity.
 // If addr is null, then a suitable and randomized address will be chosen
 // automatically.
 // PageAccessibilityConfiguration controls the permission of the
 // allocated pages.
 // This call will return null if the allocation cannot be satisfied.
-WTF_EXPORT void* allocPages(void* addr, size_t len, size_t align, PageAccessibilityConfiguration);
+WTF_EXPORT void* allocPages(void* addr,
+                            size_t len,
+                            size_t align,
+                            PageAccessibilityConfiguration);
 
 // Free one or more pages.
 // addr and len must match a previous call to allocPages().
 WTF_EXPORT void freePages(void* addr, size_t len);
 
 // Mark one or more system pages as being inaccessible.
 // Subsequently accessing any address in the range will fault, and the
 // addresses will not be re-used by future allocations.
 // len must be a multiple of kSystemPageSize bytes.
 WTF_EXPORT void setSystemPagesInaccessible(void* addr, size_t len);
 
 // Mark one or more system pages as being accessible.
 // The pages will be readable and writeable.
 // len must be a multiple of kSystemPageSize bytes.
 // The result bool value indicates whether the permission
 // change succeeded or not. You must check the result
 // (in most cases you need to RELEASE_ASSERT that it is
 // true).
-WTF_EXPORT WARN_UNUSED_RETURN bool setSystemPagesAccessible(void* addr, size_t len);
+WTF_EXPORT WARN_UNUSED_RETURN bool setSystemPagesAccessible(void* addr,
+                                                            size_t len);
 
 // Decommit one or more system pages. Decommitted means that the physical memory
 // is released to the system, but the virtual address space remains reserved.
 // System pages are re-committed by calling recommitSystemPages(). Touching
 // a decommitted page _may_ fault.
 // Clients should not make any assumptions about the contents of decommitted
 // system pages, before or after they write to the page. The only guarantee
 // provided is that the contents of the system page will be deterministic again
 // after recommitting and writing to it. In particlar note that system pages are
 // not guaranteed to be zero-filled upon re-commit. len must be a multiple of
@@ skipping 16 matching lines @@
 // A read or write to a discarded page will not fault.
 // Reading from a discarded page may return the original page content, or a
 // page full of zeroes.
 // Writing to a discarded page is the only guaranteed way to tell the system
 // that the page is required again. Once written to, the content of the page is
 // guaranteed stable once more. After being written to, the page content may be
 // based on the original page content, or a page of zeroes.
 // len must be a multiple of kSystemPageSize bytes.
 WTF_EXPORT void discardSystemPages(void* addr, size_t len);
 
-} // namespace WTF
+}  // namespace WTF
 
-#endif // WTF_PageAllocator_h
+#endif  // WTF_PageAllocator_h