Fix asserts in gcm_client_impl_unittest

components/gcm_driver/gcm_client_impl_unittest.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 "components/gcm_driver/gcm_client_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 404 matching lines @@
 
 GCMClientImplTest::~GCMClientImplTest() {}
 
 void GCMClientImplTest::SetUp() {
   testing::Test::SetUp();
   ASSERT_TRUE(CreateUniqueTempDir());
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   StartGCMClient();
   SetUpUrlFetcherFactory();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  std::string(),
-                  std::map<std::string, std::string>());
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken, std::string(),
+                      std::map<std::string, std::string>()));
 }
 
 void GCMClientImplTest::SetUpUrlFetcherFactory() {
   url_fetcher_factory_.set_remove_fetcher_on_delete(true);
 }
 
 void GCMClientImplTest::PumpLoopUntilIdle() {
   task_runner_->RunUntilIdle();
 }
 
@@ skipping 212 matching lines @@
   base::FilePath store_file_path =
       gcm_store_path().Append(FILE_PATH_LITERAL("CURRENT"));
   ASSERT_TRUE(base::AppendToFile(store_file_path, "A", 1));
 
   // Restart GCM client. The store should be reset and the loading should
   // complete successfully.
   reset_last_event();
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   StartGCMClient();
-  CompleteCheckin(kDeviceAndroidId2,
-                  kDeviceSecurityToken2,
-                  std::string(),
-                  std::map<std::string, std::string>());
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId2, kDeviceSecurityToken2, std::string(),
+                      std::map<std::string, std::string>()));
 
   EXPECT_EQ(LOADING_COMPLETED, last_event());
   EXPECT_EQ(kDeviceAndroidId2, mcs_client()->last_android_id());
   EXPECT_EQ(kDeviceSecurityToken2, mcs_client()->last_security_token());
 }
 
 TEST_F(GCMClientImplTest, DestroyStoreWhenNotNeeded) {
   // Close the GCM store.
   gcm_client()->Stop();
   PumpLoopUntilIdle();
@@ skipping 17 matching lines @@
   EXPECT_FALSE(device_checkin_info().android_id);
   EXPECT_FALSE(device_checkin_info().secret);
 }
 
 TEST_F(GCMClientImplTest, RegisterApp) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
   Register(kAppId, senders);
-  CompleteRegistration("reg_id");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("reg_id"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsRegistration(kAppId));
 }
 
 TEST_F(GCMClientImplTest, DISABLED_RegisterAppFromCache) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
   Register(kAppId, senders);
-  CompleteRegistration("reg_id");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("reg_id"));
   EXPECT_TRUE(ExistsRegistration(kAppId));
 
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
 
   // Recreate GCMClient in order to load from the persistent store.
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   StartGCMClient();
 
   EXPECT_TRUE(ExistsRegistration(kAppId));
 }
 
 TEST_F(GCMClientImplTest, RegisterPreviousSenderAgain) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   // Register a sender.
   std::vector<std::string> senders;
   senders.push_back("sender");
   Register(kAppId, senders);
-  CompleteRegistration("reg_id");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("reg_id"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsRegistration(kAppId));
 
   reset_last_event();
 
   // Register a different sender. Different registration ID from previous one
   // should be returned.
   std::vector<std::string> senders2;
   senders2.push_back("sender2");
   Register(kAppId, senders2);
-  CompleteRegistration("reg_id2");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("reg_id2"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id2", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsRegistration(kAppId));
 
   reset_last_event();
 
   // Register the 1st sender again. Different registration ID from previous one
   // should be returned.
   std::vector<std::string> senders3;
   senders3.push_back("sender");
   Register(kAppId, senders3);
-  CompleteRegistration("reg_id");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("reg_id"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsRegistration(kAppId));
 }
 
 TEST_F(GCMClientImplTest, UnregisterApp) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
   Register(kAppId, senders);
-  CompleteRegistration("reg_id");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("reg_id"));
   EXPECT_TRUE(ExistsRegistration(kAppId));
 
   Unregister(kAppId);
-  CompleteUnregistration(kAppId);
+  ASSERT_NO_FATAL_FAILURE(CompleteUnregistration(kAppId));
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_FALSE(ExistsRegistration(kAppId));
 }
 
 // Tests that stopping the GCMClient also deletes pending registration requests.
 // This is tested by checking that url fetcher contained in the request was
 // deleted.
@@ skipping 160 matching lines @@
   StartGCMClient();
 }
 
 TEST_F(GCMClientImplCheckinTest, GServicesSettingsAfterInitialCheckin) {
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::Int64ToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
   EXPECT_EQ(base::TimeDelta::FromSeconds(kSettingsCheckinInterval),
             gservices_settings().GetCheckinInterval());
   EXPECT_EQ(GURL("http://alternative.url/checkin"),
             gservices_settings().GetCheckinURL());
   EXPECT_EQ(GURL("http://alternative.url/registration"),
             gservices_settings().GetRegistrationURL());
   EXPECT_EQ(GURL("https://alternative.gcm.host:7777"),
             gservices_settings().GetMCSMainEndpoint());
   EXPECT_EQ(GURL("https://alternative.gcm.host:443"),
             gservices_settings().GetMCSFallbackEndpoint());
 }
 
 // This test only checks that periodic checkin happens.
 TEST_F(GCMClientImplCheckinTest, PeriodicCheckin) {
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::Int64ToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   EXPECT_EQ(2, clock()->call_count());
 
   PumpLoopUntilIdle();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 }
 
 TEST_F(GCMClientImplCheckinTest, LoadGSettingsFromStore) {
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::Int64ToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   StartGCMClient();
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(kSettingsCheckinInterval),
             gservices_settings().GetCheckinInterval());
   EXPECT_EQ(GURL("http://alternative.url/checkin"),
             gservices_settings().GetCheckinURL());
   EXPECT_EQ(GURL("http://alternative.url/registration"),
             gservices_settings().GetRegistrationURL());
   EXPECT_EQ(GURL("https://alternative.gcm.host:7777"),
             gservices_settings().GetMCSMainEndpoint());
   EXPECT_EQ(GURL("https://alternative.gcm.host:443"),
             gservices_settings().GetMCSFallbackEndpoint());
 }
 
 // This test only checks that periodic checkin happens.
 TEST_F(GCMClientImplCheckinTest, CheckinWithAccounts) {
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::Int64ToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   std::vector<GCMClient::AccountTokenInfo> account_tokens;
   account_tokens.push_back(MakeAccountToken("test_user1@gmail.com", "token1"));
   account_tokens.push_back(MakeAccountToken("test_user2@gmail.com", "token2"));
   gcm_client()->SetAccountTokens(account_tokens);
 
   EXPECT_TRUE(device_checkin_info().last_checkin_accounts.empty());
   EXPECT_TRUE(device_checkin_info().accounts_set);
   EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
             device_checkin_info().account_tokens);
 
   PumpLoopUntilIdle();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   std::set<std::string> accounts;
   accounts.insert("test_user1@gmail.com");
   accounts.insert("test_user2@gmail.com");
   EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
   EXPECT_TRUE(device_checkin_info().accounts_set);
   EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
             device_checkin_info().account_tokens);
 }
 
 // This test only checks that periodic checkin happens.
 TEST_F(GCMClientImplCheckinTest, CheckinWhenAccountRemoved) {
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::Int64ToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   std::vector<GCMClient::AccountTokenInfo> account_tokens;
   account_tokens.push_back(MakeAccountToken("test_user1@gmail.com", "token1"));
   account_tokens.push_back(MakeAccountToken("test_user2@gmail.com", "token2"));
   gcm_client()->SetAccountTokens(account_tokens);
   PumpLoopUntilIdle();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   EXPECT_EQ(2UL, device_checkin_info().last_checkin_accounts.size());
   EXPECT_TRUE(device_checkin_info().accounts_set);
   EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
             device_checkin_info().account_tokens);
 
   account_tokens.erase(account_tokens.begin() + 1);
   gcm_client()->SetAccountTokens(account_tokens);
 
   PumpLoopUntilIdle();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   std::set<std::string> accounts;
   accounts.insert("test_user1@gmail.com");
   EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
   EXPECT_TRUE(device_checkin_info().accounts_set);
   EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
             device_checkin_info().account_tokens);
 }
 
 // This test only checks that periodic checkin happens.
 TEST_F(GCMClientImplCheckinTest, CheckinWhenAccountReplaced) {
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::Int64ToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   std::vector<GCMClient::AccountTokenInfo> account_tokens;
   account_tokens.push_back(MakeAccountToken("test_user1@gmail.com", "token1"));
   gcm_client()->SetAccountTokens(account_tokens);
 
   PumpLoopUntilIdle();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   std::set<std::string> accounts;
   accounts.insert("test_user1@gmail.com");
   EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
 
   // This should trigger another checkin, because the list of accounts is
   // different.
   account_tokens.clear();
   account_tokens.push_back(MakeAccountToken("test_user2@gmail.com", "token2"));
   gcm_client()->SetAccountTokens(account_tokens);
 
   PumpLoopUntilIdle();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  GServicesSettings::CalculateDigest(settings),
-                  settings);
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
+                      GServicesSettings::CalculateDigest(settings), settings));
 
   accounts.clear();
   accounts.insert("test_user2@gmail.com");
   EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
   EXPECT_TRUE(device_checkin_info().accounts_set);
   EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
             device_checkin_info().account_tokens);
 }
 
 class GCMClientImplStartAndStopTest : public GCMClientImplTest {
@@ skipping 14 matching lines @@
 
 void GCMClientImplStartAndStopTest::SetUp() {
   testing::Test::SetUp();
   ASSERT_TRUE(CreateUniqueTempDir());
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
 }
 
 void GCMClientImplStartAndStopTest::DefaultCompleteCheckin() {
   SetUpUrlFetcherFactory();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  std::string(),
-                  std::map<std::string, std::string>());
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken, std::string(),
+                      std::map<std::string, std::string>()));
   PumpLoopUntilIdle();
 }
 
 TEST_F(GCMClientImplStartAndStopTest, StartStopAndRestart) {
   // GCMClientImpl should be in INITIALIZED state at first.
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Delay start the GCM.
   gcm_client()->Start(GCMClient::DELAYED_START);
   PumpLoopUntilIdle();
@@ skipping 57 matching lines @@
 }
 
 TEST_F(GCMClientImplStartAndStopTest, ImmediateStartAndThenImmediateStart) {
   // GCMClientImpl should be in INITIALIZED state at first.
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Start the GCM immediately and complete the checkin.
   gcm_client()->Start(GCMClient::IMMEDIATE_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIAL_DEVICE_CHECKIN, gcm_client_state());
-  DefaultCompleteCheckin();
+  ASSERT_NO_FATAL_FAILURE(DefaultCompleteCheckin());
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 
   // Stop the GCM.
   gcm_client()->Stop();
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Start the GCM immediately. GCMClientImpl should be in READY state.
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   gcm_client()->Start(GCMClient::IMMEDIATE_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 }
 
 TEST_F(GCMClientImplStartAndStopTest, ImmediateStartAndThenDelayStart) {
   // GCMClientImpl should be in INITIALIZED state at first.
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Start the GCM immediately and complete the checkin.
   gcm_client()->Start(GCMClient::IMMEDIATE_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIAL_DEVICE_CHECKIN, gcm_client_state());
-  DefaultCompleteCheckin();
+  ASSERT_NO_FATAL_FAILURE(DefaultCompleteCheckin());
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 
   // Stop the GCM.
   gcm_client()->Stop();
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Delay start the GCM. GCMClientImpl should be in LOADED state.
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   gcm_client()->Start(GCMClient::DELAYED_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::LOADED, gcm_client_state());
 }
 
 TEST_F(GCMClientImplStartAndStopTest, DelayedStartRace) {
   // GCMClientImpl should be in INITIALIZED state at first.
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Delay start the GCM, then start it immediately while it's still loading.
   gcm_client()->Start(GCMClient::DELAYED_START);
   gcm_client()->Start(GCMClient::IMMEDIATE_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIAL_DEVICE_CHECKIN, gcm_client_state());
-  DefaultCompleteCheckin();
+  ASSERT_NO_FATAL_FAILURE(DefaultCompleteCheckin());
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 }
 
 TEST_F(GCMClientImplStartAndStopTest, DelayedStart) {
   // GCMClientImpl should be in INITIALIZED state at first.
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Delay start the GCM. The store will not be loaded and GCMClientImpl should
   // still be in INITIALIZED state.
   gcm_client()->Start(GCMClient::DELAYED_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Start the GCM immediately and complete the checkin.
   gcm_client()->Start(GCMClient::IMMEDIATE_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIAL_DEVICE_CHECKIN, gcm_client_state());
-  DefaultCompleteCheckin();
+  ASSERT_NO_FATAL_FAILURE(DefaultCompleteCheckin());
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 
   // Registration.
   std::vector<std::string> senders;
   senders.push_back("sender");
   Register(kAppId, senders);
-  CompleteRegistration("reg_id");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("reg_id"));
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 
   // Stop the GCM.
   gcm_client()->Stop();
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Delay start the GCM. GCM is indeed started without delay because the
   // registration record has been found.
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   gcm_client()->Start(GCMClient::DELAYED_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 }
 
 // Test for known account mappings and last token fetching time being passed
 // to OnGCMReady.
 TEST_F(GCMClientImplStartAndStopTest, OnGCMReadyAccountsAndTokenFetchingTime) {
   // Start the GCM and wait until it is ready.
   gcm_client()->Start(GCMClient::IMMEDIATE_START);
   PumpLoopUntilIdle();
-  DefaultCompleteCheckin();
+  ASSERT_NO_FATAL_FAILURE(DefaultCompleteCheckin());
 
   base::Time expected_time = base::Time::Now();
   gcm_client()->SetLastTokenFetchTime(expected_time);
   AccountMapping expected_mapping;
   expected_mapping.account_id = "accId";
   expected_mapping.email = "email@gmail.com";
   expected_mapping.status = AccountMapping::MAPPED;
   expected_mapping.status_change_timestamp = expected_time;
   gcm_client()->UpdateAccountMapping(expected_mapping);
   PumpLoopUntilIdle();
@@ skipping 99 matching lines @@
   return gcm_client()->registrations_.count(
       make_linked_ptr<RegistrationInfo>(instance_id_info.release())) > 0;
 }
 
 TEST_F(GCMClientInstanceIDTest, GetToken) {
   AddInstanceID(kAppId, kInstanceID);
 
   // Get a token.
   EXPECT_FALSE(ExistsToken(kAppId, kSender, kScope));
   GetToken(kAppId, kSender, kScope);
-  CompleteRegistration("token1");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token1"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("token1", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsToken(kAppId, kSender, kScope));
 
   // Get another token.
   EXPECT_FALSE(ExistsToken(kAppId, kSender2, kScope));
   GetToken(kAppId, kSender2, kScope);
-  CompleteRegistration("token2");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token2"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("token2", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsToken(kAppId, kSender2, kScope));
   // The 1st token still exists.
   EXPECT_TRUE(ExistsToken(kAppId, kSender, kScope));
 }
 
@@ skipping 18 matching lines @@
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::INVALID_PARAMETER, last_result());
 }
 
 TEST_F(GCMClientInstanceIDTest, DeleteSingleToken) {
   AddInstanceID(kAppId, kInstanceID);
 
   // Get a token.
   EXPECT_FALSE(ExistsToken(kAppId, kSender, kScope));
   GetToken(kAppId, kSender, kScope);
-  CompleteRegistration("token1");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token1"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("token1", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsToken(kAppId, kSender, kScope));
 
   reset_last_event();
 
   // Get another token.
   EXPECT_FALSE(ExistsToken(kAppId, kSender2, kScope));
   GetToken(kAppId, kSender2, kScope);
-  CompleteRegistration("token2");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token2"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("token2", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsToken(kAppId, kSender2, kScope));
   // The 1st token still exists.
   EXPECT_TRUE(ExistsToken(kAppId, kSender, kScope));
 
   reset_last_event();
 
   // Delete the 2nd token.
   DeleteToken(kAppId, kSender2, kScope);
-  CompleteDeleteToken();
+  ASSERT_NO_FATAL_FAILURE(CompleteDeleteToken());
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   // The 2nd token is gone while the 1st token still exists.
   EXPECT_TRUE(ExistsToken(kAppId, kSender, kScope));
   EXPECT_FALSE(ExistsToken(kAppId, kSender2, kScope));
 
   reset_last_event();
 
   // Delete the 1st token.
   DeleteToken(kAppId, kSender, kScope);
-  CompleteDeleteToken();
+  ASSERT_NO_FATAL_FAILURE(CompleteDeleteToken());
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   // Both tokens are gone now.
   EXPECT_FALSE(ExistsToken(kAppId, kSender, kScope));
   EXPECT_FALSE(ExistsToken(kAppId, kSender, kScope));
 
   reset_last_event();
 
   // Trying to delete the token again will get an error.
   DeleteToken(kAppId, kSender, kScope);
   PumpLoopUntilIdle();
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::INVALID_PARAMETER, last_result());
 }
 
 TEST_F(GCMClientInstanceIDTest, DeleteAllTokens) {
   AddInstanceID(kAppId, kInstanceID);
 
   // Get a token.
   EXPECT_FALSE(ExistsToken(kAppId, kSender, kScope));
   GetToken(kAppId, kSender, kScope);
-  CompleteRegistration("token1");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token1"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("token1", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsToken(kAppId, kSender, kScope));
 
   reset_last_event();
 
   // Get another token.
   EXPECT_FALSE(ExistsToken(kAppId, kSender2, kScope));
   GetToken(kAppId, kSender2, kScope);
-  CompleteRegistration("token2");
+  ASSERT_NO_FATAL_FAILURE(CompleteRegistration("token2"));
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("token2", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsToken(kAppId, kSender2, kScope));
   // The 1st token still exists.
   EXPECT_TRUE(ExistsToken(kAppId, kSender, kScope));
 
   reset_last_event();
 
   // Delete all tokens.
   DeleteToken(kAppId, "*", "*");
-  CompleteDeleteToken();
+  ASSERT_NO_FATAL_FAILURE(CompleteDeleteToken());
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   // All tokens are gone now.
   EXPECT_FALSE(ExistsToken(kAppId, kSender, kScope));
   EXPECT_FALSE(ExistsToken(kAppId, kSender, kScope));
 }
 
 TEST_F(GCMClientInstanceIDTest, DeleteAllTokensBeforeGetAnyToken) {
   AddInstanceID(kAppId, kInstanceID);
 
   // Delete all tokens without getting a token first.
   DeleteToken(kAppId, "*", "*");
   // No need to call CompleteDeleteToken since unregistration request should
   // not be triggered.
   PumpLoopUntilIdle();
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
 }
 
 }  // namespace gcm