Switch to standard integer types in extensions/browser/.

extensions/browser/extension_prefs.cc

 // Copyright 2014 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 "extensions/browser/extension_prefs.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <iterator>
 #include <utility>
 
+#include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
 #include "components/crx_file/id_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_pref_store.h"
 #include "extensions/browser/extension_prefs_factory.h"
 #include "extensions/browser/extension_prefs_observer.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/browser/pref_names.h"
@@ skipping 820 matching lines @@
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& id) const {
   const base::DictionaryValue* ext_prefs = GetExtensionPref(id);
   return ext_prefs && IsBlacklistBitSet(ext_prefs);
 }
 
 namespace {
 
 // Serializes a 64bit integer as a string value.
 void SaveInt64(base::DictionaryValue* dictionary,
                const char* key,
-               const int64 value) {
+               const int64_t value) {
   if (!dictionary)
     return;
 
   std::string string_value = base::Int64ToString(value);
   dictionary->SetString(key, string_value);
 }
 
 // Deserializes a 64bit integer stored as a string value.
 bool ReadInt64(const base::DictionaryValue* dictionary,
                const char* key,
-               int64* value) {
+               int64_t* value) {
   if (!dictionary)
     return false;
 
   std::string string_value;
   if (!dictionary->GetString(key, &string_value))
     return false;
 
   return base::StringToInt64(string_value, value);
 }
 
 // Serializes |time| as a string value mapped to |key| in |dictionary|.
 void SaveTime(base::DictionaryValue* dictionary,
               const char* key,
               const base::Time& time) {
   SaveInt64(dictionary, key, time.ToInternalValue());
 }
 
 // The opposite of SaveTime. If |key| is not found, this returns an empty Time
 // (is_null() will return true).
 base::Time ReadTime(const base::DictionaryValue* dictionary, const char* key) {
-  int64 value;
+  int64_t value;
   if (ReadInt64(dictionary, key, &value))
     return base::Time::FromInternalValue(value);
 
   return base::Time();
 }
 
 }  // namespace
 
 base::Time ExtensionPrefs::LastPingDay(const std::string& extension_id) const {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
@@ skipping 682 matching lines @@
 base::Time ExtensionPrefs::GetInstallTime(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension) {
     NOTREACHED();
     return base::Time();
   }
   std::string install_time_str;
   if (!extension->GetString(kPrefInstallTime, &install_time_str))
     return base::Time();
-  int64 install_time_i64 = 0;
+  int64_t install_time_i64 = 0;
   if (!base::StringToInt64(install_time_str, &install_time_i64))
     return base::Time();
   return base::Time::FromInternalValue(install_time_i64);
 }
 
 bool ExtensionPrefs::DoNotSync(const std::string& extension_id) const {
   bool do_not_sync;
   if (!ReadPrefAsBoolean(extension_id, kPrefDoNotSync, &do_not_sync))
     return false;
 
   return do_not_sync;
 }
 
 base::Time ExtensionPrefs::GetLastLaunchTime(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return base::Time();
 
   std::string launch_time_str;
   if (!extension->GetString(kPrefLastLaunchTime, &launch_time_str))
     return base::Time();
-  int64 launch_time_i64 = 0;
+  int64_t launch_time_i64 = 0;
   if (!base::StringToInt64(launch_time_str, &launch_time_i64))
     return base::Time();
   return base::Time::FromInternalValue(launch_time_i64);
 }
 
 void ExtensionPrefs::SetLastLaunchTime(const std::string& extension_id,
                                        const base::Time& time) {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
   SaveTime(update.Get(), kPrefLastLaunchTime, time);
@@ skipping 447 matching lines @@
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   FOR_EACH_OBSERVER(
       ExtensionPrefsObserver,
       observer_list_,
       OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions