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

chrome/browser/signin/cross_device_promo_unittest.cc

 // Copyright 2015 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/cross_device_promo.h"
 
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/signin/chrome_signin_client_factory.h"
 #include "chrome/browser/signin/cross_device_promo_factory.h"
 #include "chrome/browser/signin/fake_gaia_cookie_manager_service.h"
 #include "chrome/browser/signin/fake_signin_manager_builder.h"
 #include "chrome/browser/signin/gaia_cookie_manager_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
@@ skipping 11 matching lines @@
 #include "components/variations/variations_associated_data.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 typedef std::map<std::string, std::string> VariationsMap;
 
-int64 InTwoHours() {
+int64_t InTwoHours() {
   return (base::Time::Now() + base::TimeDelta::FromHours(2)).ToInternalValue();
 }
 
 }  // namespace
 
 class CrossDevicePromoObserver : public CrossDevicePromo::Observer {
  public:
   explicit CrossDevicePromoObserver(CrossDevicePromo* promo)
       : eligible_(false),
         times_set_eligible_(0),
@@ skipping 357 matching lines @@
   EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
   cookie_manager_service()->set_list_accounts_stale_for_testing(true);
   cookie_manager_service()->SetListAccountsResponseOneAccount("f@bar.com", "1");
   std::vector<gaia::ListedAccount> accounts;
   EXPECT_FALSE(cookie_manager_service()->ListAccounts(&accounts));
   base::RunLoop().RunUntilIdle();
 
   // Ensure we appropriate schedule a check for device activity.
   {
     base::HistogramTester test_missing_list_devices;
-    int64 earliest_time_to_check_list_devices =
+    int64_t earliest_time_to_check_list_devices =
         base::Time::Now().ToInternalValue();
     EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
-    int64 latest_time_to_check_list_devices = InTwoHours();
+    int64_t latest_time_to_check_list_devices = InTwoHours();
     test_missing_list_devices.ExpectUniqueSample(
         "Signin.XDevicePromo.Eligibility",
         signin_metrics::UNKNOWN_COUNT_DEVICES, 1);
     EXPECT_TRUE(
         prefs()->HasPrefPath(prefs::kCrossDevicePromoNextFetchListDevicesTime));
-    int64 when_to_check_list_devices =
+    int64_t when_to_check_list_devices =
         prefs()->GetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime);
     EXPECT_LT(earliest_time_to_check_list_devices, when_to_check_list_devices);
     EXPECT_GT(latest_time_to_check_list_devices, when_to_check_list_devices);
   }
 
   // Don't reschedule the device activity check if there's one pending.
   {
     base::HistogramTester test_unknown_devices;
-    int64 list_devices_time = InTwoHours();
+    int64_t list_devices_time = InTwoHours();
     prefs()->SetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime,
                       list_devices_time);
     EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
     test_unknown_devices.ExpectUniqueSample(
         "Signin.XDevicePromo.Eligibility",
         signin_metrics::UNKNOWN_COUNT_DEVICES, 1);
     // The scheduled time to fetch device activity should not have changed.
     EXPECT_EQ(
         list_devices_time,
         prefs()->GetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime));
@@ skipping 97 matching lines @@
   prefs()->SetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime,
                     base::Time::Now().ToInternalValue());
   prefs()->SetInteger(prefs::kCrossDevicePromoNumDevices, 1);
 
   // Verify that if the device activity fetcher returns zero devices the
   // eligibility metric will report a ZERO_DEVICES event, and will not report
   // the promo as eligible to be shown.
   {
     base::HistogramTester test_no_devices;
     std::vector<DeviceActivityFetcher::DeviceActivity> devices;
-    int64 in_two_hours = InTwoHours();
+    int64_t in_two_hours = InTwoHours();
     promo()->OnFetchDeviceActivitySuccess(devices);
     EXPECT_LE(
         in_two_hours,
         prefs()->GetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime));
     EXPECT_EQ(0, prefs()->GetInteger(prefs::kCrossDevicePromoNumDevices));
     test_no_devices.ExpectUniqueSample("Signin.XDevicePromo.Eligibility",
                                        signin_metrics::ZERO_DEVICES, 1);
   }
 
   // Verify that if the device activity fetcher returns one device that was
   // recently active, the promo is marked as eligible and the eligibility
   // metric reports an ELIGIBLE event.
   {
     CrossDevicePromoObserver observer(promo());
     EXPECT_FALSE(observer.is_eligible());
     base::HistogramTester test_one_device;
     std::vector<DeviceActivityFetcher::DeviceActivity> devices;
     base::Time device_last_active =
         base::Time::Now() - base::TimeDelta::FromMinutes(4);
     DeviceActivityFetcher::DeviceActivity device;
     device.last_active = device_last_active;
     device.name = "Aslan";
     devices.push_back(device);
 
-    int64 in_two_hours = InTwoHours();
+    int64_t in_two_hours = InTwoHours();
     promo()->OnFetchDeviceActivitySuccess(devices);
     EXPECT_LE(
         in_two_hours,
         prefs()->GetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime));
     EXPECT_EQ(1, prefs()->GetInteger(prefs::kCrossDevicePromoNumDevices));
     EXPECT_EQ(device_last_active.ToInternalValue(),
               prefs()->GetInt64(prefs::kCrossDevicePromoLastDeviceActiveTime));
     EXPECT_TRUE(prefs()->GetBoolean(prefs::kCrossDevicePromoShouldBeShown));
     test_one_device.ExpectUniqueSample("Signin.XDevicePromo.Eligibility",
                                        signin_metrics::ELIGIBLE, 1);
     EXPECT_TRUE(observer.is_eligible());
     EXPECT_EQ(1, observer.times_set_eligible());
   }
 
   // Verify that if the device activity fetcher returns one device that was not
   // recently active then the eligibility metric will report a NO_ACTIVE_DEVICES
   // event, and will not report the promo as eligible to be shown.
   {
     CrossDevicePromoObserver observer(promo());
     EXPECT_FALSE(observer.is_eligible());
     base::HistogramTester test_one_device;
     std::vector<DeviceActivityFetcher::DeviceActivity> devices;
     base::Time device_last_active =
         base::Time::Now() - base::TimeDelta::FromMinutes(30);
     DeviceActivityFetcher::DeviceActivity device;
     device.last_active = device_last_active;
     device.name = "Aslan";
     devices.push_back(device);
 
-    int64 in_two_hours = InTwoHours();
+    int64_t in_two_hours = InTwoHours();
     promo()->OnFetchDeviceActivitySuccess(devices);
     EXPECT_LE(
         in_two_hours,
         prefs()->GetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime));
     EXPECT_EQ(1, prefs()->GetInteger(prefs::kCrossDevicePromoNumDevices));
     EXPECT_EQ(device_last_active.ToInternalValue(),
               prefs()->GetInt64(prefs::kCrossDevicePromoLastDeviceActiveTime));
     EXPECT_FALSE(prefs()->GetBoolean(prefs::kCrossDevicePromoShouldBeShown));
     test_one_device.ExpectUniqueSample("Signin.XDevicePromo.Eligibility",
                                        signin_metrics::NO_ACTIVE_DEVICES, 1);
@@ skipping 14 matching lines @@
         base::Time::Now() - base::TimeDelta::FromMinutes(3);
     DeviceActivityFetcher::DeviceActivity device1;
     device1.last_active = device1_last_active;
     device1.name = "Aslan";
     devices.push_back(device1);
     DeviceActivityFetcher::DeviceActivity device2;
     device2.last_active = device2_last_active;
     device2.name = "Balrog";
     devices.push_back(device2);
 
-    int64 in_two_hours = InTwoHours();
+    int64_t in_two_hours = InTwoHours();
     promo()->OnFetchDeviceActivitySuccess(devices);
     EXPECT_LE(
         in_two_hours,
         prefs()->GetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime));
     EXPECT_EQ(2, prefs()->GetInteger(prefs::kCrossDevicePromoNumDevices));
     EXPECT_EQ(device2_last_active.ToInternalValue(),
               prefs()->GetInt64(prefs::kCrossDevicePromoLastDeviceActiveTime));
     EXPECT_TRUE(prefs()->GetBoolean(prefs::kCrossDevicePromoShouldBeShown));
     test_two_devices.ExpectUniqueSample("Signin.XDevicePromo.Eligibility",
                                         signin_metrics::ELIGIBLE, 1);
     EXPECT_TRUE(observer.is_eligible());
     EXPECT_EQ(1, observer.times_set_eligible());
   }
 }