More net/ header/implementation method reordering.

net/disk_cache/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/bitmap.h"
 
+#include <algorithm>
+
 #include "base/logging.h"
 
 namespace {
 
 // Returns the number of trailing zeros.
 int FindLSBSetNonZero(uint32 word) {
   // Get the LSB, put it on the exponent of a 32 bit float and remove the
   // mantisa and the bias. This code requires IEEE 32 bit float compliance.
   float f = static_cast<float>(word & -static_cast<int>(word));
 
@@ skipping 14 matching lines @@
   if (!value)
     word = ~word;
 
   return FindLSBSetNonZero(word);
 }
 
 }
 
 namespace disk_cache {
 
+Bitmap::Bitmap(int num_bits, bool clear_bits)
+    : num_bits_(num_bits),
+      array_size_(RequiredArraySize(num_bits)),
+      alloc_(true) {
+  map_ = new uint32[array_size_];
+
+  // Initialize all of the bits.
+  if (clear_bits)
+    Clear();
+}
+
+Bitmap::Bitmap(uint32* map, int num_bits, int num_words)
+    : 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_;
+}
+
 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;
@@ skipping 47 matching lines @@
 uint32 Bitmap::GetMapElement(int array_index) const {
   DCHECK_LT(array_index, array_size_);
   DCHECK_GE(array_index, 0);
   return map_[array_index];
 }
 
 void Bitmap::SetMap(const uint32* map, int size) {
   memcpy(map_, map, std::min(size, array_size_) * sizeof(*map_));
 }
 
-void Bitmap::SetWordBits(int start, int len, bool value) {
-  DCHECK_LT(len, kIntBits);
-  DCHECK_GE(len, 0);
-  if (!len)
-    return;
-
-  int word = start / kIntBits;
-  int offset = start % kIntBits;
-
-  uint32 to_add = 0xffffffff << len;
-  to_add = (~to_add) << offset;
-  if (value) {
-    map_[word] |= to_add;
-  } else {
-    map_[word] &= ~to_add;
-  }
-}
-
 void Bitmap::SetRange(int begin, int end, bool value) {
   DCHECK_LE(begin, end);
   int start_offset = begin & (kIntBits - 1);
   if (start_offset) {
     // Set the bits in the first word.
     int len = std::min(end - begin, kIntBits - start_offset);
     SetWordBits(begin, len, value);
     begin += len;
   }
 
@@ skipping 138 matching lines @@
     return false;
 
   // Now see how many bits have the same value.
   int end = *index;
   if (!FindNextBit(&end, limit, !value))
     return limit - *index;
 
   return end - *index;
 }
 
+void Bitmap::SetWordBits(int start, int len, bool value) {
+  DCHECK_LT(len, kIntBits);
+  DCHECK_GE(len, 0);
+  if (!len)
+    return;
+
+  int word = start / kIntBits;
+  int offset = start % kIntBits;
+
+  uint32 to_add = 0xffffffff << len;
+  to_add = (~to_add) << offset;
+  if (value) {
+    map_[word] |= to_add;
+  } else {
+    map_[word] &= ~to_add;
+  }
+}
+
 }  // namespace disk_cache