[GCM] Reset store on checkin rejection and add checkin state to internals

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 <initializer_list>
 #include <memory>
@@ skipping 262 matching lines @@
   void InitializeGCMClient();
   void StartGCMClient();
   void Register(const std::string& app_id,
                 const std::vector<std::string>& senders);
   void Unregister(const std::string& app_id);
   void ReceiveMessageFromMCS(const MCSMessage& message);
   void ReceiveOnMessageSentToMCS(
       const std::string& app_id,
       const std::string& message_id,
       const MCSClient::MessageSendStatus status);
+  void FailCheckin(net::HttpStatusCode response_code);
   void CompleteCheckin(uint64_t android_id,
                        uint64_t security_token,
                        const std::string& digest,
                        const std::map<std::string, std::string>& settings);
+  void CompleteCheckinImpl(uint64_t android_id,
+                           uint64_t security_token,
+                           const std::string& digest,
+                           const std::map<std::string, std::string>& settings,
+                           net::HttpStatusCode response_code);
   void CompleteRegistration(const std::string& registration_id);
   void CompleteUnregistration(const std::string& app_id);
   void VerifyPendingRequestFetcherDeleted();
 
   bool ExistsRegistration(const std::string& app_id) const;
   void AddRegistration(const std::string& app_id,
                        const std::vector<std::string>& sender_ids,
                        const std::string& registration_id);
 
   // GCMClient::Delegate overrides (for verification).
@@ skipping 153 matching lines @@
 
 bool GCMClientImplTest::CreateUniqueTempDir() {
   return temp_directory_.CreateUniqueTempDir();
 }
 
 void GCMClientImplTest::BuildGCMClient(base::TimeDelta clock_step) {
   gcm_client_.reset(new GCMClientImpl(base::WrapUnique<GCMInternalsBuilder>(
       new FakeGCMInternalsBuilder(clock_step))));
 }
 
+void GCMClientImplTest::FailCheckin(net::HttpStatusCode response_code) {
+  std::map<std::string, std::string> settings;
+  CompleteCheckinImpl(0, 0, GServicesSettings::CalculateDigest(settings),
+                      settings, response_code);
+}
+
 void GCMClientImplTest::CompleteCheckin(
     uint64_t android_id,
     uint64_t security_token,
     const std::string& digest,
     const std::map<std::string, std::string>& settings) {
+  CompleteCheckinImpl(android_id, security_token, digest, settings,
+                      net::HTTP_OK);
+}
+
+void GCMClientImplTest::CompleteCheckinImpl(
+    uint64_t android_id,
+    uint64_t security_token,
+    const std::string& digest,
+    const std::map<std::string, std::string>& settings,
+    net::HttpStatusCode response_code) {
   checkin_proto::AndroidCheckinResponse response;
   response.set_stats_ok(true);
   response.set_android_id(android_id);
   response.set_security_token(security_token);
 
   // For testing G-services settings.
   if (!digest.empty()) {
     response.set_digest(digest);
     for (std::map<std::string, std::string>::const_iterator it =
              settings.begin();
          it != settings.end();
          ++it) {
       checkin_proto::GservicesSetting* setting = response.add_setting();
       setting->set_name(it->first);
       setting->set_value(it->second);
     }
     response.set_settings_diff(false);
   }
 
   std::string response_string;
   response.SerializeToString(&response_string);
 
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
-  fetcher->set_response_code(net::HTTP_OK);
+  fetcher->set_response_code(response_code);
   fetcher->SetResponseString(response_string);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   // Give a chance for GCMStoreImpl::Backend to finish persisting data.
   PumpLoopUntilIdle();
 }
 
 void GCMClientImplTest::CompleteRegistration(
     const std::string& registration_id) {
   std::string response(kRegistrationResponsePrefix);
   response.append(registration_id);
@@ skipping 707 matching lines @@
                       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);
 }
 
+TEST_F(GCMClientImplCheckinTest, ResetStoreWhenCheckinRejected) {
+  std::map<std::string, std::string> settings;
+  ASSERT_NO_FATAL_FAILURE(FailCheckin(net::HTTP_UNAUTHORIZED));
+  PumpLoopUntilIdle();
+
+  // Store should have been destroyed. Restart client and verify the initial
+  // checkin response is persisted.

[Peter Beverloo, 2016/10/28 15:52:30]

fwiw, I've found using the base::HistogramTester an excellent tool in verifying
such "should"s, since we record them as UMAs. See the GCMKeyStoreTest, for
example.

[Nicolas Zea, 2016/11/01 00:18:16]

In this scenario there aren't any new histograms being recorded though. The
checkin has its own histogram for the response, but I'm not sure that's
something we should be verifying here.

Or do you think that we should record a different histogram in this scenario?

[Peter Beverloo, 2016/11/01 15:19:14]

Resetting the store would record to the GCM.ResetStore histogram, right? That
means you'd be able to test it with something like

ASSERT_TRUE(histogram_tester_.ExpectTotalCount("GCM.ResetStore", 1));

Anyway, neither important nor blocking.

+  BuildGCMClient(base::TimeDelta());
+  InitializeGCMClient();
+  StartGCMClient();
+  ASSERT_NO_FATAL_FAILURE(
+      CompleteCheckin(kDeviceAndroidId2, kDeviceSecurityToken2,
+                      GServicesSettings::CalculateDigest(settings), settings));
+
+  EXPECT_EQ(LOADING_COMPLETED, last_event());
+  EXPECT_EQ(kDeviceAndroidId2, mcs_client()->last_android_id());
+  EXPECT_EQ(kDeviceSecurityToken2, mcs_client()->last_security_token());
+}
+
 class GCMClientImplStartAndStopTest : public GCMClientImplTest {
  public:
   GCMClientImplStartAndStopTest();
   ~GCMClientImplStartAndStopTest() override;
 
   void SetUp() override;
 
   void DefaultCompleteCheckin();
 };
 
@@ skipping 646 matching lines @@
   ReceiveMessageFromMCS(message);
 
   EXPECT_EQ(MESSAGE_RECEIVED, last_event());
   EXPECT_EQ(kExtensionAppId, last_app_id());
   EXPECT_EQ(expected_data.size(), last_message().data.size());
   EXPECT_EQ(expected_data, last_message().data);
   EXPECT_EQ(kSender, last_message().sender_id);
 }
 
 }  // namespace gcm