Switch to standard integer types in base/prefs/.

base/prefs/json_pref_store.cc

 // Copyright (c) 2012 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 "base/prefs/json_pref_store.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_filter.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
@@ skipping 185 matching lines @@
 
 bool JsonPrefStore::GetMutableValue(const std::string& key,
                                     base::Value** result) {
   DCHECK(CalledOnValidThread());
 
   return prefs_->Get(key, result);
 }
 
 void JsonPrefStore::SetValue(const std::string& key,
                              scoped_ptr<base::Value> value,
-                             uint32 flags) {
+                             uint32_t flags) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(value);
   base::Value* old_value = nullptr;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
     prefs_->Set(key, std::move(value));
     ReportValueChanged(key, flags);
   }
 }
 
 void JsonPrefStore::SetValueSilently(const std::string& key,
                                      scoped_ptr<base::Value> value,
-                                     uint32 flags) {
+                                     uint32_t flags) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(value);
   base::Value* old_value = nullptr;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
     prefs_->Set(key, std::move(value));
     ScheduleWrite(flags);
   }
 }
 
-void JsonPrefStore::RemoveValue(const std::string& key, uint32 flags) {
+void JsonPrefStore::RemoveValue(const std::string& key, uint32_t flags) {
   DCHECK(CalledOnValidThread());
 
   if (prefs_->RemovePath(key, nullptr))
     ReportValueChanged(key, flags);
 }
 
-void JsonPrefStore::RemoveValueSilently(const std::string& key, uint32 flags) {
+void JsonPrefStore::RemoveValueSilently(const std::string& key,
+                                        uint32_t flags) {
   DCHECK(CalledOnValidThread());
 
   prefs_->RemovePath(key, nullptr);
   ScheduleWrite(flags);
 }
 
 bool JsonPrefStore::ReadOnly() const {
   DCHECK(CalledOnValidThread());
 
   return read_only_;
@@ skipping 36 matching lines @@
 
   if (writer_.HasPendingWrite() && !read_only_)
     writer_.DoScheduledWrite();
 }
 
 void JsonPrefStore::SchedulePendingLossyWrites() {
   if (pending_lossy_write_)
     writer_.ScheduleWrite(this);
 }
 
-void JsonPrefStore::ReportValueChanged(const std::string& key, uint32 flags) {
+void JsonPrefStore::ReportValueChanged(const std::string& key, uint32_t flags) {
   DCHECK(CalledOnValidThread());
 
   if (pref_filter_)
     pref_filter_->FilterUpdate(key);
 
   FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
 
   ScheduleWrite(flags);
 }
 
@@ skipping 105 matching lines @@
   if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
     error_delegate_->OnError(read_error_);
 
   FOR_EACH_OBSERVER(PrefStore::Observer,
                     observers_,
                     OnInitializationCompleted(true));
 
   return;
 }
 
-void JsonPrefStore::ScheduleWrite(uint32 flags) {
+void JsonPrefStore::ScheduleWrite(uint32_t flags) {
   if (read_only_)
     return;
 
   if (flags & LOSSY_PREF_WRITE_FLAG)
     pending_lossy_write_ = true;
   else
     writer_.ScheduleWrite(this);
 }
 
 // NOTE: This value should NOT be changed without renaming the histogram
@@ skipping 40 matching lines @@
     return;
 
   // If the time since the last report exceeds the report interval, report all
   // the writes since the last report. They must have all occurred in the same
   // report interval.
   base::HistogramBase* histogram = GetHistogram();
   histogram->Add(writes_since_last_report_);
 
   // There may be several report intervals that elapsed that don't have any
   // writes in them. Report these too.
-  int64 total_num_intervals_elapsed =
+  int64_t total_num_intervals_elapsed =
       (time_since_last_report / report_interval_);
-  for (int64 i = 0; i < total_num_intervals_elapsed - 1; ++i)
+  for (int64_t i = 0; i < total_num_intervals_elapsed - 1; ++i)
     histogram->Add(0);
 
   writes_since_last_report_ = 0;
   last_report_time_ += total_num_intervals_elapsed * report_interval_;
 }
 
 base::HistogramBase* JsonPrefStore::WriteCountHistogram::GetHistogram() {
   std::string spaceless_basename;
   base::ReplaceChars(path_.BaseName().MaybeAsASCII(), " ", "_",
                      &spaceless_basename);
@@ skipping 13 matching lines @@
   DCHECK_EQ(31, num_buckets);
 
   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       histogram_name, min_value, max_value, num_buckets,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   return histogram;
 }