Switch to standard integer types in net/.

net/disk_cache/blockfile/stats.cc

 // 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.
 
 #include "net/disk_cache/blockfile/stats.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/bucket_ranges.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sample_vector.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace {
 
-const int32 kDiskSignature = 0xF01427E0;
+const int32_t kDiskSignature = 0xF01427E0;
 
 struct OnDiskStats {
-  int32 signature;
+  int32_t signature;
   int size;
   int data_sizes[disk_cache::Stats::kDataSizesLength];
-  int64 counters[disk_cache::Stats::MAX_COUNTER];
+  int64_t counters[disk_cache::Stats::MAX_COUNTER];
 };
 static_assert(sizeof(OnDiskStats) < 512, "needs more than 2 blocks");
 
 // Returns the "floor" (as opposed to "ceiling") of log base 2 of number.
-int LogBase2(int32 number) {
+int LogBase2(int32_t number) {
   unsigned int value = static_cast<unsigned int>(number);
   const unsigned int mask[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
   const unsigned int s[] = {1, 2, 4, 8, 16};
 
   unsigned int result = 0;
   for (int i = 4; i >= 0; i--) {
     if (value & mask[i]) {
       value >>= s[i];
       result |= s[i];
     }
@@ skipping 121 matching lines @@
   stats_histogram->AddSamples(samples);
 }
 
 int Stats::StorageSize() {
   // If we have more than 512 bytes of counters, change kDiskSignature so we
   // don't overwrite something else (LoadStats must fail).
   static_assert(sizeof(OnDiskStats) <= 256 * 2, "use more blocks");
   return 256 * 2;
 }
 
-void Stats::ModifyStorageStats(int32 old_size, int32 new_size) {
+void Stats::ModifyStorageStats(int32_t old_size, int32_t new_size) {
   // We keep a counter of the data block size on an array where each entry is
   // the adjusted log base 2 of the size. The first entry counts blocks of 256
   // bytes, the second blocks up to 512 bytes, etc. With 20 entries, the last
   // one stores entries of more than 64 MB
   int new_index = GetStatsBucket(new_size);
   int old_index = GetStatsBucket(old_size);
 
   if (new_size)
     data_sizes_[new_index]++;
 
   if (old_size)
     data_sizes_[old_index]--;
 }
 
 void Stats::OnEvent(Counters an_event) {
   DCHECK(an_event >= MIN_COUNTER && an_event < MAX_COUNTER);
   counters_[an_event]++;
 }
 
-void Stats::SetCounter(Counters counter, int64 value) {
+void Stats::SetCounter(Counters counter, int64_t value) {
   DCHECK(counter >= MIN_COUNTER && counter < MAX_COUNTER);
   counters_[counter] = value;
 }
 
-int64 Stats::GetCounter(Counters counter) const {
+int64_t Stats::GetCounter(Counters counter) const {
   DCHECK(counter >= MIN_COUNTER && counter < MAX_COUNTER);
   return counters_[counter];
 }
 
 void Stats::GetItems(StatsItems* items) {
   std::pair<std::string, std::string> item;
   for (int i = 0; i < kDataSizesLength; i++) {
     item.first = base::StringPrintf("Size%02d", i);
     item.second = base::StringPrintf("0x%08x", data_sizes_[i]);
     items->push_back(item);
@@ skipping 80 matching lines @@
 //   15     [36k, 40K)
 //   16     [40k, 64K)
 //   17     [64K, 128K)
 //   18    [128K, 256K)
 //      ...
 //   23      [4M, 8M)
 //   24      [8M, 16M)
 //   25     [16M, 32M)
 //   26     [32M, 64M)
 //   27     [64M, ...)
-int Stats::GetStatsBucket(int32 size) {
+int Stats::GetStatsBucket(int32_t size) {
   if (size < 1024)
     return 0;
 
   // 10 slots more, until 20K.
   if (size < 20 * 1024)
     return size / 2048 + 1;
 
   // 5 slots more, from 20K to 40K.
   if (size < 40 * 1024)
     return (size - 20 * 1024) / 4096 + 11;
 
   // From this point on, use a logarithmic scale.
   int result =  LogBase2(size) + 1;
 
   static_assert(kDataSizesLength > 16, "update the scale");
   if (result >= kDataSizesLength)
     result = kDataSizesLength - 1;
 
   return result;
 }
 
 int Stats::GetRatio(Counters hit, Counters miss) const {
-  int64 ratio = GetCounter(hit) * 100;
+  int64_t ratio = GetCounter(hit) * 100;
   if (!ratio)
     return 0;
 
   ratio /= (GetCounter(hit) + GetCounter(miss));
   return static_cast<int>(ratio);
 }
 
 }  // namespace disk_cache