ListAccounts will return the Gaia ID as well as the email of the account.

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 "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/prefs/browser_prefs.h"
@@ skipping 268 matching lines @@
                                        1);
   }
 }
 
 TEST_F(CrossDevicePromoTest, TrackAccountsInCookie) {
   InitPromoVariation();
   EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
 
   ASSERT_FALSE(prefs()->HasPrefPath(
       prefs::kCrossDevicePromoObservedSingleAccountCookie));
-  std::vector<std::pair<std::string, bool>> accounts;
+  std::vector<gaia::ListedAccount> accounts;
 
   // Setting a single cookie sets the time.
   base::Time before_setting_cookies = base::Time::Now();
   cookie_manager_service()->set_list_accounts_fetched_once_for_testing(false);
   cookie_manager_service()->SetListAccountsResponseOneAccount("foo@bar.com");
   EXPECT_FALSE(cookie_manager_service()->ListAccounts(&accounts));
   base::RunLoop().RunUntilIdle();
 
   base::Time after_setting_cookies = base::Time::Now();
   ASSERT_TRUE(prefs()->HasPrefPath(
@@ skipping 49 matching lines @@
     base::HistogramTester test_single_account;
     EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
     test_single_account.ExpectUniqueSample(
         "Signin.XDevicePromo.Eligibility",
         signin_metrics::NOT_SINGLE_GAIA_ACCOUNT, 1);
   }
 
   // Notice a single account.
   {
     base::HistogramTester test_single_account;
-    std::vector<std::pair<std::string, bool>> accounts;
+    std::vector<gaia::ListedAccount> accounts;
     cookie_manager_service()->set_list_accounts_fetched_once_for_testing(false);
     cookie_manager_service()->SetListAccountsResponseOneAccount("foo@bar.com");
     EXPECT_FALSE(cookie_manager_service()->ListAccounts(&accounts));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
     test_single_account.ExpectUniqueSample(
         "Signin.XDevicePromo.Eligibility",
         signin_metrics::UNKNOWN_COUNT_DEVICES, 1);
   }
 
   // Set a single account that hasn't been around for "long enough".
   {
     base::HistogramTester test_single_account;
     prefs()->SetInt64(prefs::kCrossDevicePromoObservedSingleAccountCookie,
                       InOneHour());
     EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
     test_single_account.ExpectBucketCount(
         "Signin.XDevicePromo.Eligibility",
         signin_metrics::NOT_SINGLE_GAIA_ACCOUNT, 1);
   }
 }
 
 TEST_F(CrossDevicePromoTest, NumDevicesEligibility) {
   // Start with a variation, signed in, and one account in the cookie jar.
   InitPromoVariation();
   EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
   cookie_manager_service()->set_list_accounts_fetched_once_for_testing(false);
   cookie_manager_service()->SetListAccountsResponseOneAccount("foo@bar.com");
-  std::vector<std::pair<std::string, bool>> accounts;
+  std::vector<gaia::ListedAccount> accounts;
   EXPECT_FALSE(cookie_manager_service()->ListAccounts(&accounts));
   base::RunLoop().RunUntilIdle();
 
   // Ensure we appropriate schedule a check for listing devices.
   {
     base::HistogramTester test_missing_list_devices;
     int64 earliest_time_to_check_list_devices =
         base::Time::Now().ToInternalValue();
     EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
     int64 latest_time_to_check_list_devices = InOneHour();
@@ skipping 49 matching lines @@
   variations_params["MinutesBetweenBrowsingSessions"] = "0";
   variations_params["MinutesMaxContextSwitchDuration"] = "10";
   variations_params["RPCThrottle"] = "101";
   EXPECT_TRUE(variations::AssociateVariationParams("CrossDevicePromo", "A",
                                                    variations_params));
   base::FieldTrialList::CreateFieldTrial("CrossDevicePromo", "A");
 
   EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
   cookie_manager_service()->set_list_accounts_fetched_once_for_testing(false);
   cookie_manager_service()->SetListAccountsResponseOneAccount("foo@bar.com");
-  std::vector<std::pair<std::string, bool>> accounts;
+  std::vector<gaia::ListedAccount> accounts;
   EXPECT_FALSE(cookie_manager_service()->ListAccounts(&accounts));
   base::RunLoop().RunUntilIdle();
 
   // Ensure Device Activity Fetch gets throttled.
   {
     base::HistogramTester test_throttle_rpc;
     prefs()->SetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime,
                       base::Time::Now().ToInternalValue());
     EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
     test_throttle_rpc.ExpectUniqueSample(
         "Signin.XDevicePromo.Eligibility",
         signin_metrics::THROTTLED_FETCHING_DEVICE_ACTIVITY, 1);
   }
 }
 
 TEST_F(CrossDevicePromoTest, NumDevicesKnown) {
   // Start with a variation, signed in, and one account, sync devices in 1 hour.
   InitPromoVariation();
   EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
   cookie_manager_service()->set_list_accounts_fetched_once_for_testing(false);
   cookie_manager_service()->SetListAccountsResponseOneAccount("foo@bar.com");
-  std::vector<std::pair<std::string, bool>> accounts;
+  std::vector<gaia::ListedAccount> accounts;
   EXPECT_FALSE(cookie_manager_service()->ListAccounts(&accounts));
   base::RunLoop().RunUntilIdle();
   prefs()->SetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime,
                     InOneHour());
 
   // If there is no device present.
   {
     base::HistogramTester test_no_devices;
     prefs()->SetInteger(prefs::kCrossDevicePromoNumDevices, 0);
     EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
     test_no_devices.ExpectUniqueSample("Signin.XDevicePromo.Eligibility",
                                        signin_metrics::ZERO_DEVICES, 1);
   }
 
   // If there is one device present.
   {
     prefs()->SetInteger(prefs::kCrossDevicePromoNumDevices, 1);
     EXPECT_TRUE(promo()->CheckPromoEligibilityForTesting());
   }
 }
 
 TEST_F(CrossDevicePromoTest, FetchDeviceResults) {
   // Start with a variation, signed in, and one account, sync devices in 1 hour.
   InitPromoVariation();
   EXPECT_FALSE(promo()->CheckPromoEligibilityForTesting());
   cookie_manager_service()->set_list_accounts_fetched_once_for_testing(false);
   cookie_manager_service()->SetListAccountsResponseOneAccount("foo@bar.com");
-  std::vector<std::pair<std::string, bool>> accounts;
+  std::vector<gaia::ListedAccount> accounts;
   EXPECT_FALSE(cookie_manager_service()->ListAccounts(&accounts));
   base::RunLoop().RunUntilIdle();
   prefs()->SetInt64(prefs::kCrossDevicePromoNextFetchListDevicesTime,
                     base::Time::Now().ToInternalValue());
   prefs()->SetInteger(prefs::kCrossDevicePromoNumDevices, 1);
 
   // If there is no device found.
   {
     base::HistogramTester test_no_devices;
     std::vector<DeviceActivityFetcher::DeviceActivity> devices;
@@ skipping 89 matching lines @@
     EXPECT_EQ(2, prefs()->GetInteger(prefs::kCrossDevicePromoNumDevices));
     EXPECT_EQ(device2_last_active.ToInternalValue(),
               prefs()->GetInt64(prefs::kCrossDevicePromoLastDeviceActiveTime));
     EXPECT_TRUE(prefs()->GetBoolean(prefs::kCrossDevicePromoActive));
     test_two_devices.ExpectUniqueSample("Signin.XDevicePromo.Eligibility",
                                         signin_metrics::ELIGIBLE, 1);
     EXPECT_TRUE(observer.is_active());
     EXPECT_EQ(1, observer.times_set_active());
   }
 }