Clang format slam.

net/disk_cache/blockfile/bitmap.cc

 // Copyright (c) 2009 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/bitmap.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 
@@ skipping 44 matching lines @@
     : map_(map),
       num_bits_(num_bits),
       // If size is larger than necessary, trim because array_size_ is used
       // as a bound by various methods.
       array_size_(std::min(RequiredArraySize(num_bits), num_words)),
       alloc_(false) {
 }
 
 Bitmap::~Bitmap() {
   if (alloc_)
-    delete [] map_;
+    delete[] map_;
 }
 
 void Bitmap::Resize(int num_bits, bool clear_bits) {
   DCHECK(alloc_ || !map_);
   const int old_maxsize = num_bits_;
   const int old_array_size = array_size_;
   array_size_ = RequiredArraySize(num_bits);
 
   if (array_size_ != old_array_size) {
     uint32* new_map = new uint32[array_size_];
     // Always clear the unused bits in the last word.
     new_map[array_size_ - 1] = 0;
-    memcpy(new_map, map_,
-           sizeof(*map_) * std::min(array_size_, old_array_size));
+    memcpy(
+        new_map, map_, sizeof(*map_) * std::min(array_size_, old_array_size));
     if (alloc_)
       delete[] map_;  // No need to check for NULL.
     map_ = new_map;
     alloc_ = true;
   }
 
   num_bits_ = num_bits;
   if (old_maxsize < num_bits_ && clear_bits) {
     SetRange(old_maxsize, num_bits_, false);
   }
 }
 
 void Bitmap::Set(int index, bool value) {
   DCHECK_LT(index, num_bits_);
   DCHECK_GE(index, 0);
   const int i = index & (kIntBits - 1);
   const int j = index / kIntBits;
   if (value)
     map_[j] |= (1 << i);
   else
     map_[j] &= ~(1 << i);
 }
 
 bool Bitmap::Get(int index) const {
   DCHECK_LT(index, num_bits_);
   DCHECK_GE(index, 0);
-  const int i = index & (kIntBits-1);
+  const int i = index & (kIntBits - 1);
   const int j = index / kIntBits;
   return ((map_[j] & (1 << i)) != 0);
 }
 
 void Bitmap::Toggle(int index) {
   DCHECK_LT(index, num_bits_);
   DCHECK_GE(index, 0);
   const int i = index & (kIntBits - 1);
   const int j = index / kIntBits;
   map_[j] ^= (1 << i);
@@ skipping 27 matching lines @@
 
   if (begin == end)
     return;
 
   // Now set the bits in the last word.
   int end_offset = end & (kIntBits - 1);
   end -= end_offset;
   SetWordBits(end, end_offset, value);
 
   // Set all the words in the middle.
-  memset(map_ + (begin / kIntBits), (value ? 0xFF : 0x00),
+  memset(map_ + (begin / kIntBits),
+         (value ? 0xFF : 0x00),
          ((end / kIntBits) - (begin / kIntBits)) * sizeof(*map_));
 }
 
 // Return true if any bit between begin inclusive and end exclusive
 // is set.  0 <= begin <= end <= bits() is required.
 bool Bitmap::TestRange(int begin, int end, bool value) const {
   DCHECK_LT(begin, num_bits_);
   DCHECK_LE(end, num_bits_);
   DCHECK_LE(begin, end);
   DCHECK_GE(begin, 0);
@@ skipping 137 matching lines @@
   uint32 to_add = 0xffffffff << len;
   to_add = (~to_add) << offset;
   if (value) {
     map_[word] |= to_add;
   } else {
     map_[word] &= ~to_add;
   }
 }
 
 }  // namespace disk_cache