Clang format slam.

net/disk_cache/blockfile/index_table_v3.cc

Index: net/disk_cache/blockfile/index_table_v3.cc
diff --git a/net/disk_cache/blockfile/index_table_v3.cc b/net/disk_cache/blockfile/index_table_v3.cc
index 999d5ac6cbd8cfc456e3d90cd5e09b1c0dbbbdcf..9aff718c117a42bec94de4a1c420f92935e30efa 100644
--- a/net/disk_cache/blockfile/index_table_v3.cc
+++ b/net/disk_cache/blockfile/index_table_v3.cc
@@ -73,8 +73,7 @@ uint32 GetCellId(const IndexCell& cell) {
 }
 
 uint32 GetCellSmallTableId(const IndexCell& cell) {
-  return (cell.first_part >> kCellSmallTableIdOffset) &
-         kCellSmallTableIdMask;
+  return (cell.first_part >> kCellSmallTableIdOffset) & kCellSmallTableIdMask;
 }
 
 int GetCellTimestamp(const IndexCell& cell) {
@@ -204,7 +203,8 @@ bool IsNormalState(const IndexCell& cell) {
          state != disk_cache::ENTRY_FIXING;
 }
 
-inline int GetNextBucket(int min_bucket_num, int max_bucket_num,
+inline int GetNextBucket(int min_bucket_num,
+                         int max_bucket_num,
                          disk_cache::IndexBucket* table,
                          disk_cache::IndexBucket** bucket) {
   if (!(*bucket)->next)
@@ -245,7 +245,7 @@ void UpdateIterator(const disk_cache::EntryCell& cell,
     iterator->cells.clear();
   }
   if (time == iterator->timestamp) {
-    CellInfo cell_info = { cell.hash(), cell.GetAddress() };
+    CellInfo cell_info = {cell.hash(), cell.GetAddress()};
     iterator->cells.push_back(cell_info);
   }
 }
@@ -275,12 +275,12 @@ Addr EntryCell::GetAddress() const {
   int file_number = FileNumberFromLocation(location);
   if (small_table_) {
     DCHECK_EQ(0, file_number);
-    file_number = (GetGroup() == ENTRY_EVICTED) ? kEvictedEntriesFile :
-                                                  kEntriesFile;
+    file_number =
+        (GetGroup() == ENTRY_EVICTED) ? kEvictedEntriesFile : kEntriesFile;
   }
   DCHECK_NE(0, file_number);
-  FileType file_type = (GetGroup() == ENTRY_EVICTED) ? BLOCK_EVICTED :
-                                                       BLOCK_ENTRIES;
+  FileType file_type =
+      (GetGroup() == ENTRY_EVICTED) ? BLOCK_EVICTED : BLOCK_ENTRIES;
   return Addr(file_type, 1, file_number, StartBlockFromLocation(location));
 }
 
@@ -343,9 +343,7 @@ EntryCell::EntryCell(int32 cell_num,
                      uint32 hash,
                      Addr address,
                      bool small_table)
-    : cell_num_(cell_num),
-      hash_(hash),
-      small_table_(small_table) {
+    : cell_num_(cell_num), hash_(hash), small_table_(small_table) {
   DCHECK(IsValidAddress(address) || !address.value());
 
   cell_.Clear();
@@ -367,10 +365,7 @@ EntryCell::EntryCell(int32 cell_num,
                      uint32 hash,
                      const IndexCell& cell,
                      bool small_table)
-    : cell_num_(cell_num),
-      hash_(hash),
-      cell_(cell),
-      small_table_(small_table) {
+    : cell_num_(cell_num), hash_(hash), cell_(cell), small_table_(small_table) {
 }
 
 void EntryCell::FixSum() {
@@ -472,7 +467,8 @@ void IndexTable::Init(IndexTableInitData* params) {
       // is not required when just growing the extra table because we don't
       // move any cell in that case.
       old_extra_table.reset(new IndexBucket[extra_size]);
-      memcpy(old_extra_table.get(), extra_table_,
+      memcpy(old_extra_table.get(),
+             extra_table_,
              extra_size * sizeof(IndexBucket));
       memset(params->extra_table, 0, extra_size * sizeof(IndexBucket));
     }
@@ -482,7 +478,7 @@ void IndexTable::Init(IndexTableInitData* params) {
   extra_table_ = params->extra_table;
 
   // extra_bits_ is really measured against table-size specific values.
-  const int kMaxAbsoluteExtraBits = 12;  // From smallest to largest table.
+  const int kMaxAbsoluteExtraBits = 12;   // From smallest to largest table.
   const int kMaxExtraBitsSmallTable = 6;  // From smallest to 64K table.
 
   extra_bits_ = base::bits::Log2Floor(header_->table_len) -
@@ -511,25 +507,29 @@ void IndexTable::Init(IndexTableInitData* params) {
     // table.
     int old_main_table_bit_words = ((mask_ >> 1) + 1) * kCellsPerBucket / 32;
     DCHECK_GT(num_words, old_main_table_bit_words);
-    memset(params->index_bitmap->bitmap + old_main_table_bit_words, 0,
+    memset(params->index_bitmap->bitmap + old_main_table_bit_words,
+           0,
            (num_words - old_main_table_bit_words) * sizeof(int32));
 
     DCHECK(growing);
     int old_num_words = (backup_header_.get()->table_len + 31) / 32;
     DCHECK_GT(old_num_words, old_main_table_bit_words);
-    memset(backup_bitmap_storage_.get() + old_main_table_bit_words, 0,
+    memset(backup_bitmap_storage_.get() + old_main_table_bit_words,
+           0,
            (old_num_words - old_main_table_bit_words) * sizeof(int32));
   }
-  bitmap_.reset(new Bitmap(params->index_bitmap->bitmap, header_->table_len,
-                           num_words));
+  bitmap_.reset(
+      new Bitmap(params->index_bitmap->bitmap, header_->table_len, num_words));
 
   if (growing) {
     int old_num_words = (backup_header_.get()->table_len + 31) / 32;
     DCHECK_GE(num_words, old_num_words);
     scoped_ptr<uint32[]> storage(new uint32[num_words]);
-    memcpy(storage.get(), backup_bitmap_storage_.get(),
+    memcpy(storage.get(),
+           backup_bitmap_storage_.get(),
            old_num_words * sizeof(int32));
-    memset(storage.get() + old_num_words, 0,
+    memset(storage.get() + old_num_words,
+           0,
            (num_words - old_num_words) * sizeof(int32));
 
     backup_bitmap_storage_.swap(storage);
@@ -540,8 +540,8 @@ void IndexTable::Init(IndexTableInitData* params) {
   }
 
   num_words = (backup_header_->table_len + 31) / 32;
-  backup_bitmap_.reset(new Bitmap(backup_bitmap_storage_.get(),
-                                  backup_header_->table_len, num_words));
+  backup_bitmap_.reset(new Bitmap(
+      backup_bitmap_storage_.get(), backup_header_->table_len, num_words));
   if (old_extra_table)
     MoveCells(old_extra_table.get());
 
@@ -605,8 +605,8 @@ EntrySet IndexTable::LookupEntries(uint32 hash) {
         }
       }
     }
-    bucket_num = GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_,
-                               &bucket);
+    bucket_num =
+        GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_, &bucket);
   } while (bucket_num);
   return entries;
 }
@@ -630,8 +630,8 @@ EntryCell IndexTable::CreateEntryCell(uint32 hash, Addr address) {
     }
     if (found)
       break;
-    bucket_num = GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_,
-                               &bucket);
+    bucket_num =
+        GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_, &bucket);
   } while (bucket_num);
 
   if (!found) {
@@ -784,7 +784,8 @@ void IndexTable::OnBackupTimer() {
   int num_bytes = num_words * 4 + static_cast<int>(sizeof(*header_));
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(num_bytes));
   memcpy(buffer->data(), header_, sizeof(*header_));
-  memcpy(buffer->data() + sizeof(*header_), backup_bitmap_storage_.get(),
+  memcpy(buffer->data() + sizeof(*header_),
+         backup_bitmap_storage_.get(),
          num_words * 4);
   backend_->SaveIndex(buffer, num_bytes);
   modified_ = false;
@@ -792,7 +793,8 @@ void IndexTable::OnBackupTimer() {
 
 // -----------------------------------------------------------------------
 
-EntryCell IndexTable::FindEntryCellImpl(uint32 hash, Addr address,
+EntryCell IndexTable::FindEntryCellImpl(uint32 hash,
+                                        Addr address,
                                         bool allow_deleted) {
   int bucket_num = static_cast<int>(hash & mask_);
   IndexBucket* bucket = &main_table_[bucket_num];
@@ -815,8 +817,8 @@ EntryCell IndexTable::FindEntryCellImpl(uint32 hash, Addr address,
         return entry_cell;
       }
     }
-    bucket_num = GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_,
-                               &bucket);
+    bucket_num =
+        GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_, &bucket);
   } while (bucket_num);
   return EntryCell();
 }
@@ -856,15 +858,15 @@ void IndexTable::Write(const EntryCell& cell) {
 
   int cell_number = cell.cell_num() % kCellsPerBucket;
   if (GetLocation(bucket->cells[cell_number]) && cell.GetLocation()) {
-    DCHECK_EQ(cell.GetLocation(),
-              GetLocation(bucket->cells[cell_number]));
+    DCHECK_EQ(cell.GetLocation(), GetLocation(bucket->cells[cell_number]));
   }
   cell.Serialize(&bucket->cells[cell_number]);
 }
 
 int IndexTable::NewExtraBucket() {
-  int safe_window = (header()->table_len < kNumExtraBlocks * 2) ?
-                    kNumExtraBlocks / 4 : kNumExtraBlocks;
+  int safe_window = (header()->table_len < kNumExtraBlocks * 2)
+                        ? kNumExtraBlocks / 4
+                        : kNumExtraBlocks;
   if (header()->table_len - header()->max_bucket * kCellsPerBucket <
       safe_window) {
     backend_->GrowIndex();
@@ -894,18 +896,18 @@ void IndexTable::WalkTables(int limit_time,
     do {
       UpdateFromBucket(bucket, i, limit_time, no_use, low_use, high_use);
 
-      bucket_num = GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_,
-                                 &bucket);
+      bucket_num =
+          GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_, &bucket);
     } while (bucket_num);
   }
-  header_->num_entries = header_->num_no_use_entries +
-                         header_->num_low_use_entries +
-                         header_->num_high_use_entries +
-                         header_->num_evicted_entries;
+  header_->num_entries =
+      header_->num_no_use_entries + header_->num_low_use_entries +
+      header_->num_high_use_entries + header_->num_evicted_entries;
   modified_ = true;
 }
 
-void IndexTable::UpdateFromBucket(IndexBucket* bucket, int bucket_hash,
+void IndexTable::UpdateFromBucket(IndexBucket* bucket,
+                                  int bucket_hash,
                                   int limit_time,
                                   IndexIterator* no_use,
                                   IndexIterator* low_use,
@@ -918,8 +920,8 @@ void IndexTable::UpdateFromBucket(IndexBucket* bucket, int bucket_hash,
     if (!IsNormalState(current_cell))
       continue;
 
-    EntryCell entry_cell(0, GetFullHash(current_cell, bucket_hash),
-                         current_cell, small_table_);
+    EntryCell entry_cell(
+        0, GetFullHash(current_cell, bucket_hash), current_cell, small_table_);
     switch (GetCellGroup(current_cell)) {
       case ENTRY_NO_USE:
         UpdateIterator(entry_cell, limit_time, no_use);
@@ -988,21 +990,21 @@ void IndexTable::MoveCells(IndexBucket* old_extra_table) {
         if (bucket_num == i) {
           if (upgrade_format || (GetHashValue(current_cell) & new_bit)) {
             // Move this cell to the upper half of the table.
-            MoveSingleCell(&current_cell, bucket_num * kCellsPerBucket + j, i,
-                           true);
+            MoveSingleCell(
+                &current_cell, bucket_num * kCellsPerBucket + j, i, true);
           }
         } else {
           // All cells on extra buckets have to move.
-          MoveSingleCell(&current_cell, bucket_num * kCellsPerBucket + j, i,
-                         true);
+          MoveSingleCell(
+              &current_cell, bucket_num * kCellsPerBucket + j, i, true);
         }
       }
 
       // There is no need to clear the old bucket->next value because if falls
       // within the main table so it will be fixed when attempting to follow
       // the link.
-      bucket_num = GetNextBucket(max_hash, max_bucket, old_extra_table,
-                                 &bucket);
+      bucket_num =
+          GetNextBucket(max_hash, max_bucket, old_extra_table, &bucket);
     } while (bucket_num);
   }
 
@@ -1014,8 +1016,10 @@ void IndexTable::MoveCells(IndexBucket* old_extra_table) {
   }
 }
 
-void IndexTable::MoveSingleCell(IndexCell* current_cell, int cell_num,
-                                int main_table_index, bool growing) {
+void IndexTable::MoveSingleCell(IndexCell* current_cell,
+                                int cell_num,
+                                int main_table_index,
+                                bool growing) {
   uint32 hash = GetFullHash(*current_cell, main_table_index);
   EntryCell old_cell(cell_num, hash, *current_cell, small_table_);
 
@@ -1065,7 +1069,8 @@ void IndexTable::MoveSingleCell(IndexCell* current_cell, int cell_num,
   header()->used_cells--;
 }
 
-void IndexTable::HandleMisplacedCell(IndexCell* current_cell, int cell_num,
+void IndexTable::HandleMisplacedCell(IndexCell* current_cell,
+                                     int cell_num,
                                      int main_table_index) {
   NOTREACHED();  // No unit tests yet.
 
@@ -1093,8 +1098,10 @@ void IndexTable::CheckBucketList(int bucket_num) {
         continue;
       }
       int cell_num = bucket_num * kCellsPerBucket + i;
-      EntryCell cell(cell_num, GetFullHash(*current_cell, bucket_hash),
-                     *current_cell, small_table_);
+      EntryCell cell(cell_num,
+                     GetFullHash(*current_cell, bucket_hash),
+                     *current_cell,
+                     small_table_);
       if (!entries.insert(std::make_pair(cell.GetAddress().value(),
                                          cell.GetGroup())).second) {
         current_cell->Clear();
@@ -1103,8 +1110,8 @@ void IndexTable::CheckBucketList(int bucket_num) {
       CheckState(cell);
     }
 
-    bucket_num = GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_,
-                              &bucket);
+    bucket_num =
+        GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_, &bucket);
   } while (bucket_num);
 }