Switch to standard integer types in chrome/browser/, part 4 of 4.

chrome/browser/signin/easy_unlock_service_signin_chromeos.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 "chrome/browser/signin/easy_unlock_service_signin_chromeos.h"
 
+#include <stdint.h>
+
 #include "base/base64url.h"
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_challenge_wrapper.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_factory.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
 #include "chrome/browser/signin/easy_unlock_app_manager.h"
 #include "chrome/browser/signin/easy_unlock_metrics.h"
 #include "chromeos/login/auth/user_context.h"
 #include "chromeos/tpm/tpm_token_loader.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/switches.h"
 
 namespace {
 
 // The maximum allowed backoff interval when waiting for cryptohome to start.
-uint32 kMaxCryptohomeBackoffIntervalMs = 10000u;
+uint32_t kMaxCryptohomeBackoffIntervalMs = 10000u;
 
 // If the data load fails, the initial interval after which the load will be
 // retried. Further intervals will exponentially increas by factor 2.
-uint32 kInitialCryptohomeBackoffIntervalMs = 200u;
+uint32_t kInitialCryptohomeBackoffIntervalMs = 200u;
 
 // Calculates the backoff interval that should be used next.
 // |backoff| The last backoff interval used.
-uint32 GetNextBackoffInterval(uint32 backoff) {
+uint32_t GetNextBackoffInterval(uint32_t backoff) {
   if (backoff == 0u)
     return kInitialCryptohomeBackoffIntervalMs;
   return backoff * 2;
 }
 
 void LoadDataForUser(
     const AccountId& account_id,
-    uint32 backoff_ms,
+    uint32_t backoff_ms,
     const chromeos::EasyUnlockKeyManager::GetDeviceDataListCallback& callback);
 
 // Callback passed to |LoadDataForUser()|.
 // If |LoadDataForUser| function succeeded, it invokes |callback| with the
 // results.
 // If |LoadDataForUser| failed and further retries are allowed, schedules new
 // |LoadDataForUser| call with some backoff. If no further retires are allowed,
 // it invokes |callback| with the |LoadDataForUser| results.
 void RetryDataLoadOnError(
     const AccountId& account_id,
-    uint32 backoff_ms,
+    uint32_t backoff_ms,
     const chromeos::EasyUnlockKeyManager::GetDeviceDataListCallback& callback,
     bool success,
     const chromeos::EasyUnlockDeviceKeyDataList& data_list) {
   if (success) {
     callback.Run(success, data_list);
     return;
   }
 
-  uint32 next_backoff_ms = GetNextBackoffInterval(backoff_ms);
+  uint32_t next_backoff_ms = GetNextBackoffInterval(backoff_ms);
   if (next_backoff_ms > kMaxCryptohomeBackoffIntervalMs) {
     callback.Run(false, data_list);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&LoadDataForUser, account_id, next_backoff_ms, callback),
       base::TimeDelta::FromMilliseconds(next_backoff_ms));
 }
 
 // Loads device data list associated with the user's Easy unlock keys.
 void LoadDataForUser(
     const AccountId& account_id,
-    uint32 backoff_ms,
+    uint32_t backoff_ms,
     const chromeos::EasyUnlockKeyManager::GetDeviceDataListCallback& callback) {
   chromeos::EasyUnlockKeyManager* key_manager =
       chromeos::UserSessionManager::GetInstance()->GetEasyUnlockKeyManager();
   DCHECK(key_manager);
 
   key_manager->GetDeviceDataList(
       chromeos::UserContext(account_id),
       base::Bind(&RetryDataLoadOnError, account_id, backoff_ms, callback));
 }
 
@@ skipping 102 matching lines @@
 }
 
 EasyUnlockService::TurnOffFlowStatus
     EasyUnlockServiceSignin::GetTurnOffFlowStatus() const {
   return EasyUnlockService::IDLE;
 }
 
 std::string EasyUnlockServiceSignin::GetChallenge() const {
   const UserData* data = FindLoadedDataForCurrentUser();
   // TODO(xiyuan): Use correct remote device instead of hard coded first one.
-  uint32 device_index = 0;
+  uint32_t device_index = 0;
   if (!data || data->devices.size() <= device_index)
     return std::string();
   return data->devices[device_index].challenge;
 }
 
 std::string EasyUnlockServiceSignin::GetWrappedSecret() const {
   const UserData* data = FindLoadedDataForCurrentUser();
   // TODO(xiyuan): Use correct remote device instead of hard coded first one.
-  uint32 device_index = 0;
+  uint32_t device_index = 0;
   if (!data || data->devices.size() <= device_index)
     return std::string();
   return data->devices[device_index].wrapped_secret;
 }
 
 void EasyUnlockServiceSignin::RecordEasySignInOutcome(
     const AccountId& account_id,
     bool success) const {
   DCHECK(GetAccountId() == account_id)
       << "GetAccountId()=" << GetAccountId().Serialize()
@@ skipping 242 matching lines @@
   if (account_id_.is_valid())
     return nullptr;
 
   const auto it = user_data_.find(account_id_);
   if (it == user_data_.end())
     return nullptr;
   if (it->second->state != USER_DATA_STATE_LOADED)
     return nullptr;
   return it->second;
 }