Switch to standard integer types in base/prefs/.

base/prefs/pref_service_unittest.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 <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
+#include "base/macros.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/mock_pref_change_callback.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service_factory.h"
 #include "base/prefs/pref_value_store.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/prefs/testing_pref_store.h"
 #include "base/values.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 210 matching lines @@
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(kRecommendedValue, actual_int_value);
 }
 
 // A PrefStore which just stores the last write flags that were used to write
 // values to it.
 class WriteFlagChecker : public TestingPrefStore {
  public:
   WriteFlagChecker() {}
 
-  void ReportValueChanged(const std::string& key, uint32 flags) override {
+  void ReportValueChanged(const std::string& key, uint32_t flags) override {
     SetLastWriteFlags(flags);
   }
 
   void SetValue(const std::string& key,
                 scoped_ptr<base::Value> value,
-                uint32 flags) override {
+                uint32_t flags) override {
     SetLastWriteFlags(flags);
   }
 
   void SetValueSilently(const std::string& key,
                         scoped_ptr<base::Value> value,
-                        uint32 flags) override {
+                        uint32_t flags) override {
     SetLastWriteFlags(flags);
   }
 
-  void RemoveValue(const std::string& key, uint32 flags) override {
+  void RemoveValue(const std::string& key, uint32_t flags) override {
     SetLastWriteFlags(flags);
   }
 
-  uint32 GetLastFlagsAndClear() {
+  uint32_t GetLastFlagsAndClear() {
     CHECK(last_write_flags_set_);
-    uint32 result = last_write_flags_;
+    uint32_t result = last_write_flags_;
     last_write_flags_set_ = false;
     last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
     return result;
   }
 
   bool last_write_flags_set() { return last_write_flags_set_; }
 
  private:
   ~WriteFlagChecker() override {}
 
-  void SetLastWriteFlags(uint32 flags) {
+  void SetLastWriteFlags(uint32_t flags) {
     CHECK(!last_write_flags_set_);
     last_write_flags_set_ = true;
     last_write_flags_ = flags;
   }
 
   bool last_write_flags_set_ = false;
-  uint32 last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
+  uint32_t last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 };
 
 TEST(PrefServiceTest, WriteablePrefStoreFlags) {
   scoped_refptr<WriteFlagChecker> flag_checker(new WriteFlagChecker);
   scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple);
   base::PrefServiceFactory factory;
   factory.set_user_prefs(flag_checker);
   scoped_ptr<PrefService> prefs(factory.Create(registry.get()));
 
   // The first 8 bits of write flags are reserved for subclasses. Create a
   // custom flag in this range
-  uint32 kCustomRegistrationFlag = 1 << 2;
+  uint32_t kCustomRegistrationFlag = 1 << 2;
 
   // A map of the registration flags that will be tested and the write flags
   // they are expected to convert to.
   struct RegistrationToWriteFlags {
     const char* pref_name;
-    uint32 registration_flags;
-    uint32 write_flags;
+    uint32_t registration_flags;
+    uint32_t write_flags;
   };
   const RegistrationToWriteFlags kRegistrationToWriteFlags[] = {
       {"none",
        PrefRegistry::NO_REGISTRATION_FLAGS,
        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
       {"lossy",
        PrefRegistry::LOSSY_PREF,
        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG},
       {"custom",
        kCustomRegistrationFlag,
@@ skipping 110 matching lines @@
 
   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
   prefs_.Set(kName, new_value);
   Mock::VerifyAndClearExpectations(&observer_);
 
   base::ListValue empty;
   observer_.Expect(kName, &empty);
   prefs_.Set(kName, empty);
   Mock::VerifyAndClearExpectations(&observer_);
 }