Switch to standard integer types in components/, part 3 of 4.

components/pref_registry/pref_registry_syncable.h

 // 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.
 
 #ifndef COMPONENTS_PREF_REGISTRY_PREF_REGISTRY_SYNCABLE_H_
 #define COMPONENTS_PREF_REGISTRY_PREF_REGISTRY_SYNCABLE_H_
 
+#include <stdint.h>
+
 #include <string>
 
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/prefs/pref_registry_simple.h"
 
 namespace base {
 class DictionaryValue;
 class FilePath;
 class ListValue;
 class Value;
 }
 
 // TODO(tfarina): Change this namespace to pref_registry.
@@ skipping 14 matching lines @@
 // logic which is only required to support pref registration after the
 // PrefService has been created which is only used by tests. We can remove this
 // entire class and those tests with some work.
 class PrefRegistrySyncable : public PrefRegistrySimple {
  public:
   // Enum of flags used when registering preferences to determine if it should
   // be synced or not. These flags are mutually exclusive, only one of them
   // should ever be specified.
   //
   // Note: These must NOT overlap with PrefRegistry::PrefRegistrationFlags.
-  enum PrefRegistrationFlags : uint32 {
+  enum PrefRegistrationFlags : uint32_t {
     // The pref will be synced.
     SYNCABLE_PREF = 1 << 0,
 
     // The pref will be synced. The pref will never be encrypted and will be
     // synced before other datatypes. Because they're never encrypted, on first
     // sync, they can be synced down before the user is prompted for a
     // passphrase.
     SYNCABLE_PRIORITY_PREF = 1 << 1,
   };
 
-  typedef base::Callback<void(const std::string& path, uint32 flags)>
+  typedef base::Callback<void(const std::string& path, uint32_t flags)>
       SyncableRegistrationCallback;
 
   PrefRegistrySyncable();
 
   // Exactly one callback can be set for the event of a syncable
   // preference being registered. It will be fired after the
   // registration has occurred.
   //
   // Calling this method after a callback has already been set will
   // make the object forget the previous callback and use the new one
   // instead.
   void SetSyncableRegistrationCallback(const SyncableRegistrationCallback& cb);
 
   // Returns a new PrefRegistrySyncable that uses the same defaults
   // store.
   scoped_refptr<PrefRegistrySyncable> ForkForIncognito();
 
  private:
   ~PrefRegistrySyncable() override;
 
   // PrefRegistrySimple overrides.
   void OnPrefRegistered(const std::string& path,
                         base::Value* default_value,
-                        uint32 flags) override;
+                        uint32_t flags) override;
 
   SyncableRegistrationCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefRegistrySyncable);
 };
 
 }  // namespace user_prefs
 
 #endif  // COMPONENTS_PREF_REGISTRY_PREF_REGISTRY_SYNCABLE_H_