Switch to standard integer types in google_apis/.

google_apis/gcm/engine/gcm_store_impl.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 "google_apis/gcm/engine/gcm_store_impl.h"
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
@@ skipping 159 matching lines @@
     : public base::RefCountedThreadSafe<GCMStoreImpl::Backend> {
  public:
   Backend(const base::FilePath& path,
           scoped_refptr<base::SequencedTaskRunner> foreground_runner,
           scoped_ptr<Encryptor> encryptor);
 
   // Blocking implementations of GCMStoreImpl methods.
   void Load(StoreOpenMode open_mode, const LoadCallback& callback);
   void Close();
   void Destroy(const UpdateCallback& callback);
-  void SetDeviceCredentials(uint64 device_android_id,
-                            uint64 device_security_token,
+  void SetDeviceCredentials(uint64_t device_android_id,
+                            uint64_t device_security_token,
                             const UpdateCallback& callback);
   void AddRegistration(const std::string& serialized_key,
                        const std::string& serialized_value,
                        const UpdateCallback& callback);
   void RemoveRegistration(const std::string& serialized_key,
                           const UpdateCallback& callback);
   void AddIncomingMessage(const std::string& persistent_id,
                           const UpdateCallback& callback);
   void RemoveIncomingMessages(const PersistentIdList& persistent_ids,
                               const UpdateCallback& callback);
   void AddOutgoingMessage(const std::string& persistent_id,
                           const MCSMessage& message,
                           const UpdateCallback& callback);
   void RemoveOutgoingMessages(
       const PersistentIdList& persistent_ids,
       const base::Callback<void(bool, const AppIdToMessageCountMap&)>
           callback);
   void AddUserSerialNumber(const std::string& username,
-                           int64 serial_number,
+                           int64_t serial_number,
                            const UpdateCallback& callback);
   void RemoveUserSerialNumber(const std::string& username,
                               const UpdateCallback& callback);
   void SetLastCheckinInfo(const base::Time& time,
                           const std::set<std::string>& accounts,
                           const UpdateCallback& callback);
   void SetGServicesSettings(
       const std::map<std::string, std::string>& settings,
       const std::string& digest,
       const UpdateCallback& callback);
@@ skipping 15 matching lines @@
                             const UpdateCallback& callback);
   void SetValue(const std::string& key,
                 const std::string& value,
                 const UpdateCallback& callback);
 
  private:
   friend class base::RefCountedThreadSafe<Backend>;
   ~Backend();
 
   LoadStatus OpenStoreAndLoadData(StoreOpenMode open_mode, LoadResult* result);
-  bool LoadDeviceCredentials(uint64* android_id, uint64* security_token);
+  bool LoadDeviceCredentials(uint64_t* android_id, uint64_t* security_token);
   bool LoadRegistrations(std::map<std::string, std::string>* registrations);
   bool LoadIncomingMessages(std::vector<std::string>* incoming_messages);
   bool LoadOutgoingMessages(OutgoingMessageMap* outgoing_messages);
   bool LoadLastCheckinInfo(base::Time* last_checkin_time,
                            std::set<std::string>* accounts);
   bool LoadGServicesSettings(std::map<std::string, std::string>* settings,
                              std::string* digest);
   bool LoadAccountMappingInfo(AccountMappings* account_mappings);
   bool LoadLastTokenFetchTime(base::Time* last_token_fetch_time);
   bool LoadHeartbeatIntervals(std::map<std::string, int>* heartbeat_intervals);
@@ skipping 100 matching lines @@
   for (const auto& registration : result->registrations) {
     if (base::StartsWith(registration.first, "iid-",
                          base::CompareCase::SENSITIVE))
       instance_id_token_count++;
     else
       gcm_registration_count++;
   }
 
   // Only record histograms if GCM had already been set up for this device.
   if (result->device_android_id != 0 && result->device_security_token != 0) {
-    int64 file_size = 0;
+    int64_t file_size = 0;
     if (base::GetFileSize(path_, &file_size)) {
       UMA_HISTOGRAM_COUNTS("GCM.StoreSizeKB",
                            static_cast<int>(file_size / 1024));
     }
 
     UMA_HISTOGRAM_COUNTS("GCM.RestoredRegistrations", gcm_registration_count);
     UMA_HISTOGRAM_COUNTS("GCM.RestoredOutgoingMessages",
                          result->outgoing_messages.size());
     UMA_HISTOGRAM_COUNTS("GCM.RestoredIncomingMessages",
                          result->incoming_messages.size());
@@ skipping 31 matching lines @@
       leveldb::DestroyDB(path_.AsUTF8Unsafe(), leveldb::Options());
   if (s.ok()) {
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
     return;
   }
   LOG(ERROR) << "Destroy failed: " << s.ToString();
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
 }
 
 void GCMStoreImpl::Backend::SetDeviceCredentials(
-    uint64 device_android_id,
-    uint64 device_security_token,
+    uint64_t device_android_id,
+    uint64_t device_security_token,
     const UpdateCallback& callback) {
   DVLOG(1) << "Saving device credentials with AID " << device_android_id;
   if (!db_.get()) {
     LOG(ERROR) << "GCMStore db doesn't exist.";
     foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
     return;
   }
 
   leveldb::WriteOptions write_options;
   write_options.sync = true;
@@ skipping 196 matching lines @@
                                                false,
                                                AppIdToMessageCountMap()));
 }
 
 void GCMStoreImpl::Backend::SetLastCheckinInfo(
     const base::Time& time,
     const std::set<std::string>& accounts,
     const UpdateCallback& callback) {
   leveldb::WriteBatch write_batch;
 
-  int64 last_checkin_time_internal = time.ToInternalValue();
+  int64_t last_checkin_time_internal = time.ToInternalValue();
   write_batch.Put(MakeSlice(kLastCheckinTimeKey),
                   MakeSlice(base::Int64ToString(last_checkin_time_internal)));
 
   std::string serialized_accounts;
   for (std::set<std::string>::iterator iter = accounts.begin();
        iter != accounts.end();
        ++iter) {
     serialized_accounts += *iter;
     serialized_accounts += ",";
   }
@@ skipping 242 matching lines @@
   write_options.sync = true;
 
   const leveldb::Status s =
       db_->Put(write_options, MakeSlice(key), MakeSlice(value));
 
   if (!s.ok())
     LOG(ERROR) << "LevelDB had problems injecting a value: " << s.ToString();
   foreground_task_runner_->PostTask(FROM_HERE, base::Bind(callback, s.ok()));
 }
 
-bool GCMStoreImpl::Backend::LoadDeviceCredentials(uint64* android_id,
-                                                  uint64* security_token) {
+bool GCMStoreImpl::Backend::LoadDeviceCredentials(uint64_t* android_id,
+                                                  uint64_t* security_token) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   std::string result;
   leveldb::Status s = db_->Get(read_options, MakeSlice(kDeviceAIDKey), &result);
   if (s.ok()) {
     if (!base::StringToUint64(result, android_id)) {
       LOG(ERROR) << "Failed to restore device id.";
       return false;
     }
@@ skipping 70 matching lines @@
 
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(read_options));
   for (iter->Seek(MakeSlice(kOutgoingMsgKeyStart));
        iter->Valid() && iter->key().ToString() < kOutgoingMsgKeyEnd;
        iter->Next()) {
     leveldb::Slice s = iter->value();
     if (s.size() <= 1) {
       LOG(ERROR) << "Error reading incoming message with key " << s.ToString();
       return false;
     }
-    uint8 tag = iter->value().data()[0];
+    uint8_t tag = iter->value().data()[0];
     std::string id = ParseOutgoingKey(iter->key().ToString());
     scoped_ptr<google::protobuf::MessageLite> message(
         BuildProtobufFromTag(tag));
     if (!message.get() ||
         !message->ParseFromString(iter->value().ToString().substr(1))) {
       LOG(ERROR) << "Failed to parse outgoing message with id " << id
                  << " and tag " << tag;
       return false;
     }
     DVLOG(1) << "Found outgoing message with id " << id << " of type "
              << base::UintToString(tag);
     (*outgoing_messages)[id] = make_linked_ptr(message.release());
   }
 
   return true;
 }
 
 bool GCMStoreImpl::Backend::LoadLastCheckinInfo(
     base::Time* last_checkin_time,
     std::set<std::string>* accounts) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   std::string result;
   leveldb::Status s = db_->Get(read_options,
                                MakeSlice(kLastCheckinTimeKey),
                                &result);
-  int64 time_internal = 0LL;
+  int64_t time_internal = 0LL;
   if (s.ok() && !base::StringToInt64(result, &time_internal)) {
     LOG(ERROR) << "Failed to restore last checkin time. Using default = 0.";
     time_internal = 0LL;
   }
 
   // In case we cannot read last checkin time, we default it to 0, as we don't
   // want that situation to cause the whole load to fail.
   *last_checkin_time = base::Time::FromInternalValue(time_internal);
 
   accounts->clear();
@@ skipping 60 matching lines @@
 }
 
 bool GCMStoreImpl::Backend::LoadLastTokenFetchTime(
     base::Time* last_token_fetch_time) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;
 
   std::string result;
   leveldb::Status s =
       db_->Get(read_options, MakeSlice(kLastTokenFetchTimeKey), &result);
-  int64 time_internal = 0LL;
+  int64_t time_internal = 0LL;
   if (s.ok() && !base::StringToInt64(result, &time_internal)) {
     LOG(ERROR) <<
         "Failed to restore last token fetching time. Using default = 0.";
     time_internal = 0LL;
   }
 
   // In case we cannot read last token fetching time, we default it to 0.
   *last_token_fetch_time = base::Time::FromInternalValue(time_internal);
 
   return true;
@@ skipping 76 matching lines @@
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::Close, backend_));
 }
 
 void GCMStoreImpl::Destroy(const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::Destroy, backend_, callback));
 }
 
-void GCMStoreImpl::SetDeviceCredentials(uint64 device_android_id,
-                                        uint64 device_security_token,
+void GCMStoreImpl::SetDeviceCredentials(uint64_t device_android_id,
+                                        uint64_t device_security_token,
                                         const UpdateCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::SetDeviceCredentials,
                  backend_,
                  device_android_id,
                  device_security_token,
                  callback));
 }
 
@@ skipping 262 matching lines @@
            removed_message_counts.begin();
        iter != removed_message_counts.end(); ++iter) {
     DCHECK_NE(app_message_counts_.count(iter->first), 0U);
     app_message_counts_[iter->first] -= iter->second;
     DCHECK_GE(app_message_counts_[iter->first], 0);
   }
   callback.Run(true);
 }
 
 }  // namespace gcm