Keep the GCM data intact when the user signs out of the profile

components/gcm_driver/gcm_driver_desktop_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_driver_desktop.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
@@ skipping 255 matching lines @@
   driver_->RemoveAppHandler(kTestAppID2);
 }
 
 void GCMDriverTest::SignIn(const std::string& account_id) {
   driver_->OnSignedIn();
   PumpIOLoop();
   PumpUILoop();
 }
 
 void GCMDriverTest::SignOut() {
-  driver_->Purge();
+  driver_->OnSignedOut();
   PumpIOLoop();
   PumpUILoop();
 }
 
 void GCMDriverTest::Register(const std::string& app_id,
                              const std::vector<std::string>& sender_ids,
                              WaitToFinish wait_to_finish) {
   base::RunLoop run_loop;
   async_operation_completed_callback_ = run_loop.QuitClosure();
   driver_->Register(app_id,
@@ skipping 85 matching lines @@
   EXPECT_FALSE(driver()->IsStarted());
   EXPECT_FALSE(driver()->IsConnected());
   EXPECT_FALSE(gcm_connection_observer()->connected());
 
   // GCM will be started after app handler is added.
   AddAppHandlers();
   EXPECT_TRUE(driver()->IsStarted());
   PumpIOLoop();
   EXPECT_TRUE(driver()->IsConnected());
   EXPECT_TRUE(gcm_connection_observer()->connected());
+
+  // Sign-in will not affect GCM state.
+  SignIn(kTestAccountID1);
+  PumpIOLoop();
+  EXPECT_TRUE(driver()->IsStarted());
+  EXPECT_TRUE(driver()->IsConnected());
+
+  // Sign-out will not affect GCM state.
+  SignOut();
+  PumpIOLoop();
+  EXPECT_TRUE(driver()->IsStarted());
+  EXPECT_TRUE(driver()->IsConnected());
 }
 
 TEST_F(GCMDriverTest, Shutdown) {
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   EXPECT_FALSE(HasAppHandlers());
 
   AddAppHandlers();
   EXPECT_TRUE(HasAppHandlers());
 
   ShutdownDriver();
   EXPECT_FALSE(HasAppHandlers());
   EXPECT_FALSE(driver()->IsConnected());
   EXPECT_FALSE(gcm_connection_observer()->connected());
 }
 
 TEST_F(GCMDriverTest, SignInAndSignOutOnGCMEnabled) {
   // By default, GCM is enabled.
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   AddAppHandlers();
 
   // GCMClient should be started after sign-in.
   SignIn(kTestAccountID1);
   EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
-  // GCMClient should be checked out after sign-out.
+  // GCMClient should be stopped out after sign-out.
+  // Note: Before we enable the feature that drops the sign-in enforcement and
+  // make GCM work for all users, GCM is only applicable to signed-in users.
+  // Once the users sign out, the GCM will be shut down while the GCM store
+  // remains intact.
   SignOut();
-  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status());
 }
 
 TEST_F(GCMDriverTest, SignInAndSignOutOnGCMDisabled) {
   // By default, GCM is enabled.
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   AddAppHandlers();
 
   // Disable GCM.
   driver()->Disable();
 
   // GCMClient should not be started after sign-in.
   SignIn(kTestAccountID1);
   EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status());
 
-  // Check-out should still be performed after sign-out.
+  // GCMClient should remain not started after sign-out.
   SignOut();
-  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status());
 }
 
 TEST_F(GCMDriverTest, SignOutAndThenSignIn) {
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   AddAppHandlers();
 
   // GCMClient should be started after sign-in.
   SignIn(kTestAccountID1);
   EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
-  // GCMClient should be checked out after sign-out.
+  // GCMClient should be stopped after sign-out.
   SignOut();
-  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status());
 
   // Sign-in with a different account.
   SignIn(kTestAccountID2);
 
   // GCMClient should be started again.
   EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 }
 
 TEST_F(GCMDriverTest, DisableAndReenableGCM) {
   CreateDriver(FakeGCMClient::NO_DELAY_START);
@@ skipping 23 matching lines @@
   driver()->Disable();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be stopped.
   EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status());
 
   // Sign out.
   SignOut();
 
-  // GCMClient should be checked out.
-  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
+  // GCMClient should be stopped.
+  EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status());
 }
 
 TEST_F(GCMDriverTest, StartOrStopGCMOnDemand) {
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient is not started.
   EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status());
 
   // GCMClient is started after an app handler has been added.
@@ skipping 189 matching lines @@
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   AddAppHandlers();
   SignIn(kTestAccountID1);
 }
 
 TEST_F(GCMDriverFunctionalTest, Register) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
   const std::string expected_registration_id =
-      FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids);
+      GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids);
 
   EXPECT_EQ(expected_registration_id, registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 }
 
 TEST_F(GCMDriverFunctionalTest, RegisterError) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1@error");
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
 
   EXPECT_TRUE(registration_id().empty());
   EXPECT_NE(GCMClient::SUCCESS, registration_result());
 }
 
 TEST_F(GCMDriverFunctionalTest, RegisterAgainWithSameSenderIDs) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   sender_ids.push_back("sender2");
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
   const std::string expected_registration_id =
-      FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids);
+      GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids);
 
   EXPECT_EQ(expected_registration_id, registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 
   // Clears the results the would be set by the Register callback in preparation
   // to call register 2nd time.
   ClearResults();
 
   // Calling register 2nd time with the same set of sender IDs but different
   // ordering will get back the same registration ID.
   std::vector<std::string> another_sender_ids;
   another_sender_ids.push_back("sender2");
   another_sender_ids.push_back("sender1");
   Register(kTestAppID1, another_sender_ids, GCMDriverTest::WAIT);
 
   EXPECT_EQ(expected_registration_id, registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 }
 
 TEST_F(GCMDriverFunctionalTest, RegisterAgainWithDifferentSenderIDs) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
   const std::string expected_registration_id =
-      FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids);
+      GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids);
 
   EXPECT_EQ(expected_registration_id, registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 
   // Make sender IDs different.
   sender_ids.push_back("sender2");
   const std::string expected_registration_id2 =
-      FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids);
+      GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids);
 
   // Calling register 2nd time with the different sender IDs will get back a new
   // registration ID.
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
   EXPECT_EQ(expected_registration_id2, registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 }
 
 TEST_F(GCMDriverFunctionalTest, RegisterAfterSignOut) {
-  // This will trigger check-out.
   SignOut();
 
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
 
   EXPECT_TRUE(registration_id().empty());
   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, registration_result());
 }
 
+TEST_F(GCMDriverFunctionalTest, RegisterAfterSignOutAndSignInAgain) {
+  std::vector<std::string> sender_ids;
+  sender_ids.push_back("sender1");
+  const std::string expected_registration_id =
+      GetGCMClient()->GetRegistrationIdFromSenderIds(sender_ids);
+
+  Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
+  EXPECT_EQ(expected_registration_id, registration_id());
+  EXPECT_EQ(GCMClient::SUCCESS, registration_result());
+
+  // After signing out, the GCM is stopped and calling register should fail.
+  SignOut();
+  Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
+  EXPECT_TRUE(registration_id().empty());
+  EXPECT_EQ(GCMClient::NOT_SIGNED_IN, registration_result());
+
+  // After signing in again, same registration ID should be returned because
+  // the GCM data is not affected.
+  SignIn(kTestAccountID1);
+
+  Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
+  EXPECT_EQ(expected_registration_id, registration_id());
+  EXPECT_EQ(GCMClient::SUCCESS, registration_result());
+}
+
 TEST_F(GCMDriverFunctionalTest, UnregisterExplicitly) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
 
   EXPECT_FALSE(registration_id().empty());
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 
   Unregister(kTestAppID1, GCMDriverTest::WAIT);
 
@@ skipping 81 matching lines @@
 
   EXPECT_EQ(message.id, send_message_id());
   EXPECT_EQ(GCMClient::SUCCESS, send_result());
 
   gcm_app_handler()->WaitForNotification();
   EXPECT_EQ(message.id, gcm_app_handler()->acked_message_id());
   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 }
 
 TEST_F(GCMDriverFunctionalTest, SendAfterSignOut) {
-  // This will trigger check-out.
   SignOut();
 
   GCMClient::OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   message.data["key2"] = "value2";
   Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT);
 
   EXPECT_TRUE(send_message_id().empty());
   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, send_result());
@@ skipping 300 matching lines @@
   // After start-up, the request should still be scheduled at the expected
   // updated interval.
   actual_delay_seconds =
       syncer()->current_request_delay_interval().InSeconds();
   EXPECT_TRUE(CompareDelaySeconds(expected_delay_seconds, actual_delay_seconds))
       << "expected delay: " << expected_delay_seconds
       << " actual delay: " << actual_delay_seconds;
 }
 
 }  // namespace gcm