Switch to standard integer types in net/.

net/disk_cache/blockfile/bitmap.h

 // Copyright (c) 2011 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_BITMAP_H_
 #define NET_DISK_CACHE_BLOCKFILE_BITMAP_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "net/base/net_export.h"
 
 namespace disk_cache {
 
 // This class provides support for simple maps of bits.
 class NET_EXPORT_PRIVATE Bitmap {
  public:
   Bitmap() : map_(NULL), num_bits_(0), array_size_(0), alloc_(false) {}
 
-  // This constructor will allocate on a uint32 boundary. If |clear_bits| is
+  // This constructor will allocate on a uint32_t boundary. If |clear_bits| is
   // false, the bitmap bits will not be initialized.
   Bitmap(int num_bits, bool clear_bits);
 
   // Constructs a Bitmap with the actual storage provided by the caller. |map|
   // has to be valid until this object destruction. |num_bits| is the number of
   // bits in the bitmap, and |num_words| is the size of |map| in 32-bit words.
-  Bitmap(uint32* map, int num_bits, int num_words);
+  Bitmap(uint32_t* map, int num_bits, int num_words);
 
   ~Bitmap();
 
   // Resizes the bitmap.
   // If |num_bits| < Size(), the extra bits will be discarded.
   // If |num_bits| > Size(), the extra bits will be filled with zeros if
   // |clear_bits| is true.
   // This object cannot be using memory provided during construction.
   void Resize(int num_bits, bool clear_bits);
 
@@ skipping 11 matching lines @@
   // Clears all bits in the bitmap
   void Clear() { SetAll(false); }
 
   // Sets the value, gets the value or toggles the value of a given bit.
   void Set(int index, bool value);
   bool Get(int index) const;
   void Toggle(int index);
 
   // Directly sets an element of the internal map. Requires |array_index| <
   // ArraySize();
-  void SetMapElement(int array_index, uint32 value);
+  void SetMapElement(int array_index, uint32_t value);
 
   // Gets an entry of the internal map. Requires array_index <
   // ArraySize()
-  uint32 GetMapElement(int array_index) const;
+  uint32_t GetMapElement(int array_index) const;
 
   // Directly sets the whole internal map. |size| is the number of 32-bit words
   // to set from |map|. If  |size| > array_size(), it ignores the end of |map|.
-  void SetMap(const uint32* map, int size);
+  void SetMap(const uint32_t* map, int size);
 
   // Gets a pointer to the internal map.
-  const uint32* GetMap() const { return map_; }
+  const uint32_t* GetMap() const { return map_; }
 
   // Sets a range of bits to |value|.
   void SetRange(int begin, int end, bool value);
 
   // Returns true if any bit between begin inclusive and end exclusive is set.
   // 0 <= |begin| <= |end| <= Size() is required.
   bool TestRange(int begin, int end, bool value) const;
 
   // Scans bits starting at bit *|index|, looking for a bit set to |value|. If
   // it finds that bit before reaching bit index |limit|, sets *|index| to the
@@ skipping 30 matching lines @@
   // Returns number of allocated words required for a bitmap of size |num_bits|.
   static int RequiredArraySize(int num_bits) {
     // Force at least one allocated word.
     if (num_bits <= kIntBits)
       return 1;
 
     return (num_bits + kIntBits - 1) >> kLogIntBits;
   }
 
  private:
-  static const int kIntBits = sizeof(uint32) * 8;
+  static const int kIntBits = sizeof(uint32_t) * 8;
   static const int kLogIntBits = 5;  // 2^5 == 32 bits per word.
 
   // Sets |len| bits from |start| to |value|. All the bits to be set should be
   // stored in the same word, and len < kIntBits.
   void SetWordBits(int start, int len, bool value);
 
-  uint32* map_;           // The bitmap.
+  uint32_t* map_;         // The bitmap.
   int num_bits_;          // The upper bound of the bitmap.
   int array_size_;        // The physical size (in uint32s) of the bitmap.
   bool alloc_;            // Whether or not we allocated the memory.
 
   DISALLOW_COPY_AND_ASSIGN(Bitmap);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_BITMAP_H_