Clang format slam.

net/disk_cache/blockfile/index_table_v3.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_DISK_CACHE_BLOCKFILE_INDEX_TABLE_V3_H_
 #define NET_DISK_CACHE_BLOCKFILE_INDEX_TABLE_V3_H_
 
 // The IndexTable class is in charge of handling all the details about the main
 // index table of the cache. It provides methods to locate entries in the cache,
 // create new entries and modify existing entries. It hides the fact that the
@@ skipping 98 matching lines @@
   EntrySet();
   ~EntrySet();
 
   int evicted_count;  // The numebr of evicted entries in this set.
   size_t current;     // The number of the cell that is being processed.
   std::vector<EntryCell> cells;
 };
 
 // A given entity referenced by the index table is uniquely identified by the
 // combination of hash and address.
-struct CellInfo { uint32 hash; Addr address; };
+struct CellInfo {
+  uint32 hash;
+  Addr address;
+};
 typedef std::vector<CellInfo> CellList;
 
 // An index iterator is used to get a group of cells that share the same
 // timestamp. When this structure is passed to GetNextCells(), the caller sets
 // the initial timestamp and direction; whet it is used with GetOldest, the
 // initial values are ignored.
 struct NET_EXPORT_PRIVATE IndexIterator {
   IndexIterator();
   ~IndexIterator();
 
@@ skipping 103 matching lines @@
 
  private:
   EntryCell FindEntryCellImpl(uint32 hash, Addr address, bool allow_deleted);
   void CheckState(const EntryCell& cell);
   void Write(const EntryCell& cell);
   int NewExtraBucket();
   void WalkTables(int limit_time,
                   IndexIterator* no_use,
                   IndexIterator* low_use,
                   IndexIterator* high_use);
-  void UpdateFromBucket(IndexBucket* bucket, int bucket_hash,
+  void UpdateFromBucket(IndexBucket* bucket,
+                        int bucket_hash,
                         int limit_time,
                         IndexIterator* no_use,
                         IndexIterator* low_use,
                         IndexIterator* high_use);
   void MoveCells(IndexBucket* old_extra_table);
-  void MoveSingleCell(IndexCell* current_cell, int cell_num,
-                      int main_table_index, bool growing);
-  void HandleMisplacedCell(IndexCell* current_cell, int cell_num,
+  void MoveSingleCell(IndexCell* current_cell,
+                      int cell_num,
+                      int main_table_index,
+                      bool growing);
+  void HandleMisplacedCell(IndexCell* current_cell,
+                           int cell_num,
                            int main_table_index);
   void CheckBucketList(int bucket_id);
 
   uint32 GetLocation(const IndexCell& cell);
   uint32 GetHashValue(const IndexCell& cell);
   uint32 GetFullHash(const IndexCell& cell, uint32 lower_part);
   bool IsHashMatch(const IndexCell& cell, uint32 hash);
   bool MisplacedHash(const IndexCell& cell, uint32 hash);
 
   IndexTableBackend* backend_;
   IndexHeaderV3* header_;
   scoped_ptr<Bitmap> bitmap_;
   scoped_ptr<Bitmap> backup_bitmap_;
   scoped_ptr<uint32[]> backup_bitmap_storage_;
   scoped_ptr<IndexHeaderV3> backup_header_;
   IndexBucket* main_table_;
   IndexBucket* extra_table_;
   uint32 mask_;     // Binary mask to map a hash to the hash table.
   int extra_bits_;  // How many bits are in mask_ above the default value.
   bool modified_;
   bool small_table_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexTable);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_INDEX_TABLE_V3_H_