Clang format slam.

net/disk_cache/blockfile/index_table_v3.cc

 // 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.
 
 #include "net/disk_cache/blockfile/index_table_v3.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 55 matching lines @@
 
 uint32 GetCellSmallTableLocation(const IndexCell& cell) {
   return cell.first_part & kCellSmallTableLocationMask;
 }
 
 uint32 GetCellId(const IndexCell& cell) {
   return (cell.first_part >> kCellIdOffset) & kCellIdMask;
 }
 
 uint32 GetCellSmallTableId(const IndexCell& cell) {
-  return (cell.first_part >> kCellSmallTableIdOffset) &
-         kCellSmallTableIdMask;
+  return (cell.first_part >> kCellSmallTableIdOffset) & kCellSmallTableIdMask;
 }
 
 int GetCellTimestamp(const IndexCell& cell) {
   return (cell.first_part >> kCellTimestampOffset) & kCellTimestampMask;
 }
 
 int GetCellReuse(const IndexCell& cell) {
   return (cell.first_part >> kCellReuseOffset) & kCellReuseMask;
 }
 
@@ skipping 109 matching lines @@
 }
 
 bool IsNormalState(const IndexCell& cell) {
   disk_cache::EntryState state =
       static_cast<disk_cache::EntryState>(GetCellState(cell));
   DCHECK_NE(state, disk_cache::ENTRY_FREE);
   return state != disk_cache::ENTRY_DELETED &&
          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)
     return 0;
 
   int bucket_num = (*bucket)->next / disk_cache::kCellsPerBucket;
   if (bucket_num < min_bucket_num || bucket_num > max_bucket_num) {
     // The next bucket must fall within the extra table. Note that this is not
     // an uncommon path as growing the table may not cleanup the link from the
     // main table to the extra table, and that cleanup is performed here when
@@ skipping 20 matching lines @@
   if (!iterator->forward && time >= limit_time)
     return;
 
   if ((iterator->forward && time < iterator->timestamp) ||
       (!iterator->forward && time > iterator->timestamp)) {
     // This timestamp is better than the one we had.
     iterator->timestamp = time;
     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);
   }
 }
 
 void InitIterator(IndexIterator* iterator) {
   iterator->cells.clear();
   iterator->timestamp = iterator->forward ? kint32max : 0;
 }
 
 }  // namespace
 
 namespace disk_cache {
 
 EntryCell::~EntryCell() {
 }
 
 bool EntryCell::IsValid() const {
   return GetCellLocation(cell_) != 0;
 }
 
 // This code has to map the cell address (up to 22 bits) to a general cache Addr
 // (up to 24 bits of general addressing). It also set the implied file_number
 // in the case of small tables. See also the comment by the definition of
 // kEntriesFile.
 Addr EntryCell::GetAddress() const {
   uint32 location = GetLocation();
   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));
 }
 
 EntryState EntryCell::GetState() const {
   return static_cast<EntryState>(GetCellState(cell_));
 }
 
 EntryGroup EntryCell::GetGroup() const {
   return static_cast<EntryGroup>(GetCellGroup(cell_));
 }
@@ skipping 42 matching lines @@
 }
 
 EntryCell::EntryCell() : cell_num_(0), hash_(0), small_table_(false) {
   cell_.Clear();
 }
 
 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();
   SetCellState(&cell_, ENTRY_NEW);
   SetCellGroup(&cell_, ENTRY_NO_USE);
   if (small_table) {
     DCHECK(address.FileNumber() == kEntriesFile ||
            address.FileNumber() == kEvictedEntriesFile);
     SetCellSmallTableLocation(&cell_, address.start_block());
     SetCellSmallTableId(&cell_, hash >> kSmallTableHashShift);
   } else {
     uint32 location = address.FileNumber() << 16 | address.start_block();
     SetCellLocation(&cell_, location);
     SetCellId(&cell_, hash >> kHashShift);
   }
 }
 
 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() {
   SetCellSum(&cell_, CalculateCellSum(cell_));
 }
 
 uint32 EntryCell::GetLocation() const {
   if (small_table_)
     return GetCellSmallTableLocation(cell_);
 
@@ skipping 81 matching lines @@
       DCHECK_EQ(base::bits::Log2Floor(header_->table_len),
                 base::bits::Log2Floor(backup_header_->table_len) + 1);
       int extra_size = (header()->max_bucket - mask_) * kCellsPerBucket;
       DCHECK_GE(extra_size, 0);
 
       // Doubling the size implies deleting the extra table and moving as many
       // cells as we can to the main table, so we first copy the old one. This
       // 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));
     }
     main_table_ = params->main_table;
   }
   DCHECK(main_table_);
   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) -
                 base::bits::Log2Floor(kBaseTableLen);
   DCHECK_GE(extra_bits_, 0);
   DCHECK_LT(extra_bits_, kMaxAbsoluteExtraBits);
 
   // Note that following the previous code the constants could be derived as
   // kMaxAbsoluteExtraBits = base::bits::Log2Floor(max table len) -
   //                         base::bits::Log2Floor(kBaseTableLen);
   //                       = 22 - base::bits::Log2Floor(1024) = 22 - 10;
   // kMaxExtraBitsSmallTable = base::bits::Log2Floor(max 16 bit table) - 10.
 
   mask_ = ((kBaseTableLen / kCellsPerBucket) << extra_bits_) - 1;
   small_table_ = extra_bits_ < kMaxExtraBitsSmallTable;
   if (!small_table_)
     extra_bits_ -= kMaxExtraBitsSmallTable;
 
   // table_len keeps the max number of cells stored by the index. We need a
   // bitmap with 1 bit per cell, and that bitmap has num_words 32-bit words.
   int num_words = (header_->table_len + 31) / 32;
 
   if (old_extra_table) {
     // All the cells from the extra table are moving to the new tables so before
     // creating the bitmaps, clear the part of the bitmap referring to the extra
     // 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);
     backup_header_->table_len = header_->table_len;
   } else {
     backup_bitmap_storage_.reset(params->backup_bitmap.release());
     backup_header_.reset(params->backup_header.release());
   }
 
   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());
 
   if (small_table_)
     DCHECK(header_->flags & SMALL_CACHE);
 
   // All tables and backups are needed for operation.
   DCHECK(main_table_);
   DCHECK(extra_table_);
   DCHECK(bitmap_.get());
@@ skipping 43 matching lines @@
       } else if (IsHashMatch(*current_cell, hash)) {
         EntryCell entry_cell(cell_num, hash, *current_cell, small_table_);
         CheckState(entry_cell);
         if (entry_cell.GetState() != ENTRY_DELETED) {
           entries.cells.push_back(entry_cell);
           if (entry_cell.GetGroup() == ENTRY_EVICTED)
             entries.evicted_count++;
         }
       }
     }
-    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;
 }
 
 EntryCell IndexTable::CreateEntryCell(uint32 hash, Addr address) {
   DCHECK(IsValidAddress(address));
   DCHECK(address.FileNumber() || address.start_block());
 
   int bucket_num = static_cast<int>(hash & mask_);
   int cell_num = 0;
   IndexBucket* bucket = &main_table_[bucket_num];
   IndexCell* current_cell = NULL;
   bool found = false;
   do {
     for (int i = 0; i < kCellsPerBucket && !found; i++) {
       current_cell = &bucket->cells[i];
       if (!GetLocation(*current_cell)) {
         cell_num = bucket_num * kCellsPerBucket + i;
         found = true;
       }
     }
     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) {
     bucket_num = NewExtraBucket();
     if (bucket_num) {
       cell_num = bucket_num * kCellsPerBucket;
       bucket->next = cell_num;
       bucket = &extra_table_[bucket_num - (mask_ + 1)];
       bucket->hash = hash & mask_;
       found = true;
@@ skipping 132 matching lines @@
 }
 
 void IndexTable::OnBackupTimer() {
   if (!modified_)
     return;
 
   int num_words = (header_->table_len + 31) / 32;
   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;
 }
 
 // -----------------------------------------------------------------------
 
-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];
   do {
     for (int i = 0; i < kCellsPerBucket; i++) {
       IndexCell* current_cell = &bucket->cells[i];
       if (!GetLocation(*current_cell))
         continue;
       DCHECK(SanityCheck(*current_cell));
       if (IsHashMatch(*current_cell, hash)) {
         // We have a match.
         int cell_num = bucket_num * kCellsPerBucket + i;
         EntryCell entry_cell(cell_num, hash, *current_cell, small_table_);
         if (entry_cell.GetAddress() != address)
           continue;
 
         if (!allow_deleted && entry_cell.GetState() == ENTRY_DELETED)
           continue;
 
         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();
 }
 
 void IndexTable::CheckState(const EntryCell& cell) {
   int current_state = cell.GetState();
   if (current_state != ENTRY_FIXING) {
     bool present = ((current_state & 3) != 0);  // Look at the last two bits.
     if (present != bitmap_->Get(cell.cell_num()) ||
         present != backup_bitmap_->Get(cell.cell_num())) {
@@ skipping 19 matching lines @@
   int bucket_num = cell.cell_num() / kCellsPerBucket;
   if (bucket_num < static_cast<int32>(mask_ + 1)) {
     bucket = &main_table_[bucket_num];
   } else {
     DCHECK_LE(bucket_num, header()->max_bucket);
     bucket = &extra_table_[bucket_num - (mask_ + 1)];
   }
 
   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();
   }
 
   if (header()->max_bucket * kCellsPerBucket ==
       header()->table_len - kCellsPerBucket) {
     return 0;
   }
 
   header()->max_bucket++;
   return header()->max_bucket;
 }
 
 void IndexTable::WalkTables(int limit_time,
                             IndexIterator* no_use,
                             IndexIterator* low_use,
                             IndexIterator* high_use) {
   header_->num_no_use_entries = 0;
   header_->num_low_use_entries = 0;
   header_->num_high_use_entries = 0;
   header_->num_evicted_entries = 0;
 
   for (int i = 0; i < static_cast<int32>(mask_ + 1); i++) {
     int bucket_num = i;
     IndexBucket* bucket = &main_table_[i];
     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,
                                   IndexIterator* high_use) {
   for (int i = 0; i < kCellsPerBucket; i++) {
     IndexCell& current_cell = bucket->cells[i];
     if (!GetLocation(current_cell))
       continue;
     DCHECK(SanityCheck(current_cell));
     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);
         header_->num_no_use_entries++;
         break;
       case ENTRY_LOW_USE:
         UpdateIterator(entry_cell, limit_time, low_use);
         header_->num_low_use_entries++;
         break;
       case ENTRY_HIGH_USE:
@@ skipping 48 matching lines @@
     IndexBucket* bucket = &source_table[i];
     do {
       for (int j = 0; j < kCellsPerBucket; j++) {
         IndexCell& current_cell = bucket->cells[j];
         if (!GetLocation(current_cell))
           continue;
         DCHECK(SanityCheck(current_cell));
         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);
   }
 
   DCHECK_EQ(header()->used_cells, used_cells);
 
   if (upgrade_format) {
     small_table_ = false;
     header()->flags &= ~SMALL_CACHE;
   }
 }
 
-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_);
 
   // This method may be called when moving entries from a small table to a
   // normal table. In that case, the caller (MoveCells) has to read the old
   // table, so it needs small_table_ set to true, but this method needs to
   // write to the new table so small_table_ has to be set to false, and the
   // value restored to true before returning.
   bool upgrade_format = !extra_bits_ && growing;
   if (upgrade_format)
@@ skipping 29 matching lines @@
     }
 
     if (cell_num != new_cell.cell_num()) {
       bitmap_->Set(old_cell.cell_num(), false);
       backup_bitmap_->Set(old_cell.cell_num(), false);
     }
   }
   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.
 
   // The cell may be misplaced, or a duplicate cell exists with this data.
   uint32 hash = GetFullHash(*current_cell, main_table_index);
   MoveSingleCell(current_cell, cell_num, main_table_index, false);
 
   // Now look for a duplicate cell.
   CheckBucketList(hash & mask_);
 }
 
 void IndexTable::CheckBucketList(int bucket_num) {
   typedef std::pair<int, EntryGroup> AddressAndGroup;
   std::set<AddressAndGroup> entries;
   IndexBucket* bucket = &main_table_[bucket_num];
   int bucket_hash = bucket_num;
   do {
     for (int i = 0; i < kCellsPerBucket; i++) {
       IndexCell* current_cell = &bucket->cells[i];
       if (!GetLocation(*current_cell))
         continue;
       if (!SanityCheck(*current_cell)) {
         NOTREACHED();
         current_cell->Clear();
         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();
         continue;
       }
       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);
 }
 
 uint32 IndexTable::GetLocation(const IndexCell& cell) {
   if (small_table_)
     return GetCellSmallTableLocation(cell);
 
   return GetCellLocation(cell);
 }
 
@@ skipping 22 matching lines @@
 bool IndexTable::MisplacedHash(const IndexCell& cell, uint32 hash) {
   if (!extra_bits_)
     return false;
 
   uint32 mask = (1 << extra_bits_) - 1;
   hash = small_table_ ? hash >> kSmallTableHashShift : hash >> kHashShift;
   return (GetHashValue(cell) & mask) != (hash & mask);
 }
 
 }  // namespace disk_cache