Clang format slam.

net/disk_cache/blockfile/disk_format.h

Index: net/disk_cache/blockfile/disk_format.h
diff --git a/net/disk_cache/blockfile/disk_format.h b/net/disk_cache/blockfile/disk_format.h
index 95ac58b6274caf2c969266f77b2ce5b5813db346..6851dac1358c32f6741333a243844f471ef77848 100644
--- a/net/disk_cache/blockfile/disk_format.h
+++ b/net/disk_cache/blockfile/disk_format.h
@@ -56,41 +56,41 @@ const uint32 kIndexMagic = 0xC103CAC3;
 const uint32 kCurrentVersion = 0x20000;  // Version 2.0.
 
 struct LruData {
-  int32     pad1[2];
-  int32     filled;          // Flag to tell when we filled the cache.
-  int32     sizes[5];
+  int32 pad1[2];
+  int32 filled;  // Flag to tell when we filled the cache.
+  int32 sizes[5];
   CacheAddr heads[5];
   CacheAddr tails[5];
-  CacheAddr transaction;     // In-flight operation target.
-  int32     operation;       // Actual in-flight operation.
-  int32     operation_list;  // In-flight operation list.
-  int32     pad2[7];
+  CacheAddr transaction;  // In-flight operation target.
+  int32 operation;        // Actual in-flight operation.
+  int32 operation_list;   // In-flight operation list.
+  int32 pad2[7];
 };
 
 // Header for the master index file.
 struct NET_EXPORT_PRIVATE IndexHeader {
   IndexHeader();
 
-  uint32      magic;
-  uint32      version;
-  int32       num_entries;   // Number of entries currently stored.
-  int32       num_bytes;     // Total size of the stored data.
-  int32       last_file;     // Last external file created.
-  int32       this_id;       // Id for all entries being changed (dirty flag).
-  CacheAddr   stats;         // Storage for usage data.
-  int32       table_len;     // Actual size of the table (0 == kIndexTablesize).
-  int32       crash;         // Signals a previous crash.
-  int32       experiment;    // Id of an ongoing test.
-  uint64      create_time;   // Creation time for this set of files.
-  int32       pad[52];
-  LruData     lru;           // Eviction control data.
+  uint32 magic;
+  uint32 version;
+  int32 num_entries;   // Number of entries currently stored.
+  int32 num_bytes;     // Total size of the stored data.
+  int32 last_file;     // Last external file created.
+  int32 this_id;       // Id for all entries being changed (dirty flag).
+  CacheAddr stats;     // Storage for usage data.
+  int32 table_len;     // Actual size of the table (0 == kIndexTablesize).
+  int32 crash;         // Signals a previous crash.
+  int32 experiment;    // Id of an ongoing test.
+  uint64 create_time;  // Creation time for this set of files.
+  int32 pad[52];
+  LruData lru;  // Eviction control data.
 };
 
 // The structure of the whole index file.
 struct Index {
   IndexHeader header;
-  CacheAddr   table[kIndexTablesize];  // Default size. Actual size controlled
-                                       // by header.table_len.
+  CacheAddr table[kIndexTablesize];  // Default size. Actual size controlled
+                                     // by header.table_len.
 };
 
 // Main structure for an entry on the backing storage. If the key is longer than
@@ -99,50 +99,50 @@ struct Index {
 // After that point, the whole key will be stored as a data block or external
 // file.
 struct EntryStore {
-  uint32      hash;               // Full hash of the key.
-  CacheAddr   next;               // Next entry with the same hash or bucket.
-  CacheAddr   rankings_node;      // Rankings node for this entry.
-  int32       reuse_count;        // How often is this entry used.
-  int32       refetch_count;      // How often is this fetched from the net.
-  int32       state;              // Current state.
-  uint64      creation_time;
-  int32       key_len;
-  CacheAddr   long_key;           // Optional address of a long key.
-  int32       data_size[4];       // We can store up to 4 data streams for each
-  CacheAddr   data_addr[4];       // entry.
-  uint32      flags;              // Any combination of EntryFlags.
-  int32       pad[4];
-  uint32      self_hash;          // The hash of EntryStore up to this point.
-  char        key[256 - 24 * 4];  // null terminated
+  uint32 hash;              // Full hash of the key.
+  CacheAddr next;           // Next entry with the same hash or bucket.
+  CacheAddr rankings_node;  // Rankings node for this entry.
+  int32 reuse_count;        // How often is this entry used.
+  int32 refetch_count;      // How often is this fetched from the net.
+  int32 state;              // Current state.
+  uint64 creation_time;
+  int32 key_len;
+  CacheAddr long_key;      // Optional address of a long key.
+  int32 data_size[4];      // We can store up to 4 data streams for each
+  CacheAddr data_addr[4];  // entry.
+  uint32 flags;            // Any combination of EntryFlags.
+  int32 pad[4];
+  uint32 self_hash;        // The hash of EntryStore up to this point.
+  char key[256 - 24 * 4];  // null terminated
 };
 
 COMPILE_ASSERT(sizeof(EntryStore) == 256, bad_EntyStore);
-const int kMaxInternalKeyLength = 4 * sizeof(EntryStore) -
-                                  offsetof(EntryStore, key) - 1;
+const int kMaxInternalKeyLength =
+    4 * sizeof(EntryStore) - offsetof(EntryStore, key) - 1;
 
 // Possible states for a given entry.
 enum EntryState {
   ENTRY_NORMAL = 0,
-  ENTRY_EVICTED,    // The entry was recently evicted from the cache.
-  ENTRY_DOOMED      // The entry was doomed.
+  ENTRY_EVICTED,  // The entry was recently evicted from the cache.
+  ENTRY_DOOMED    // The entry was doomed.
 };
 
 // Flags that can be applied to an entry.
 enum EntryFlags {
-  PARENT_ENTRY = 1,         // This entry has children (sparse) entries.
-  CHILD_ENTRY = 1 << 1      // Child entry that stores sparse data.
+  PARENT_ENTRY = 1,     // This entry has children (sparse) entries.
+  CHILD_ENTRY = 1 << 1  // Child entry that stores sparse data.
 };
 
 #pragma pack(push, 4)
 // Rankings information for a given entry.
 struct RankingsNode {
-  uint64      last_used;        // LRU info.
-  uint64      last_modified;    // LRU info.
-  CacheAddr   next;             // LRU list.
-  CacheAddr   prev;             // LRU list.
-  CacheAddr   contents;         // Address of the EntryStore.
-  int32       dirty;            // The entry is being modifyied.
-  uint32      self_hash;        // RankingsNode's hash.
+  uint64 last_used;      // LRU info.
+  uint64 last_modified;  // LRU info.
+  CacheAddr next;        // LRU list.
+  CacheAddr prev;        // LRU list.
+  CacheAddr contents;    // Address of the EntryStore.
+  int32 dirty;           // The entry is being modifyied.
+  uint32 self_hash;      // RankingsNode's hash.
 };
 #pragma pack(pop)