[GCM] Make sure GCM checkout logic is invoked when the profile is signed out

chrome/browser/services/gcm/gcm_profile_service_unittest.cc

 // Copyright (c) 2013 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 <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 196 matching lines @@
   Event received_event_;
   std::string app_id_;
   GCMClient::IncomingMessage message_;
   std::string send_error_message_id_;
   GCMClient::Result send_error_result_;
 };
 
 class FakeGCMClientFactory : public GCMClientFactory {
  public:
   FakeGCMClientFactory(
-      GCMClientMock::Status gcm_client_initial_status,
+      GCMClientMock::LoadingDelay gcm_client_loading_delay,
       GCMClientMock::ErrorSimulation gcm_client_error_simulation)
-      : gcm_client_initial_status_(gcm_client_initial_status),
+      : gcm_client_loading_delay_(gcm_client_loading_delay),
         gcm_client_error_simulation_(gcm_client_error_simulation),
         gcm_client_(NULL) {
   }
 
   virtual ~FakeGCMClientFactory() {
   }
 
   virtual scoped_ptr<GCMClient> BuildInstance() OVERRIDE {
-    gcm_client_ = new GCMClientMock(gcm_client_initial_status_,
+    gcm_client_ = new GCMClientMock(gcm_client_loading_delay_,
                                     gcm_client_error_simulation_);
     return scoped_ptr<GCMClient>(gcm_client_);
   }
 
   GCMClientMock* gcm_client() const { return gcm_client_; }
 
  private:
-  GCMClientMock::Status gcm_client_initial_status_;
+  GCMClientMock::LoadingDelay gcm_client_loading_delay_;
   GCMClientMock::ErrorSimulation gcm_client_error_simulation_;
   GCMClientMock* gcm_client_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGCMClientFactory);
 };
 
 class GCMProfileServiceTestConsumer : public GCMProfileService::TestingDelegate{
  public:
   static BrowserContextKeyedService* BuildFakeSigninManager(
       content::BrowserContext* context) {
     return new FakeSigninManager(static_cast<Profile*>(context));
   }
 
   static BrowserContextKeyedService* BuildGCMProfileService(
       content::BrowserContext* context) {
     return new GCMProfileService(static_cast<Profile*>(context));
   }
 
   explicit GCMProfileServiceTestConsumer(Waiter* waiter)
       : waiter_(waiter),
         extension_service_(NULL),
         signin_manager_(NULL),
-        gcm_client_initial_status_(GCMClientMock::READY),
+        gcm_client_loading_delay_(GCMClientMock::NO_DELAY_LOADING),
         gcm_client_error_simulation_(GCMClientMock::ALWAYS_SUCCEED),
         registration_result_(GCMClient::SUCCESS),
         has_persisted_registration_info_(false),
         send_result_(GCMClient::SUCCESS) {
     // Create a new profile.
     profile_.reset(new TestingProfile);
 
     // Use a fake version of SigninManager.
     signin_manager_ = static_cast<FakeSigninManager*>(
         SigninManagerFactory::GetInstance()->SetTestingFactoryAndUse(
             profile(), &GCMProfileServiceTestConsumer::BuildFakeSigninManager));
 
     // Create extension service in order to uninstall the extension.
     extensions::TestExtensionSystem* extension_system(
         static_cast<extensions::TestExtensionSystem*>(
             extensions::ExtensionSystem::Get(profile())));
     extension_system->CreateExtensionService(
         CommandLine::ForCurrentProcess(), base::FilePath(), false);
     extension_service_ = extension_system->Get(profile())->extension_service();
 
     // Enable GCM such that tests could be run on all channels.
-    GCMProfileService::enable_gcm_for_testing_ = true;
+    profile()->GetPrefs()->SetBoolean(prefs::kGCMChannelEnabled, true);
 
     // Mock a GCMEventRouter.
     gcm_event_router_.reset(new FakeGCMEventRouter(waiter_));
   }
 
   virtual ~GCMProfileServiceTestConsumer() {
   }
 
   // Returns a barebones test extension.
   scoped_refptr<Extension> CreateExtension() {
@@ skipping 35 matching lines @@
         extension->id(), UnloadedExtensionInfo::REASON_TERMINATE);
     extension_service_->AddExtension(extension);
   }
 
   void CreateGCMProfileServiceInstance() {
     GCMProfileService* gcm_profile_service = static_cast<GCMProfileService*>(
         GCMProfileServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             profile(), &GCMProfileServiceTestConsumer::BuildGCMProfileService));
     gcm_profile_service->set_testing_delegate(this);
     scoped_ptr<GCMClientFactory> gcm_client_factory(
-        new FakeGCMClientFactory(gcm_client_initial_status_,
+        new FakeGCMClientFactory(gcm_client_loading_delay_,
                                  gcm_client_error_simulation_));
     gcm_profile_service->Initialize(gcm_client_factory.Pass());
     waiter_->PumpIOLoop();
   }
 
   void SignIn(const std::string& username) {
     signin_manager_->SignIn(username);
     waiter_->PumpIOLoop();
     waiter_->PumpUILoop();
   }
@@ skipping 56 matching lines @@
     send_message_id_ = message_id;
     send_result_ = result;
     waiter_->SignalCompleted();
   }
 
   GCMProfileService* GetGCMProfileService() const {
     return GCMProfileServiceFactory::GetForProfile(profile());
   }
 
   GCMClientMock* GetGCMClient() const {
-    return static_cast<FakeGCMClientFactory*>(
-        GetGCMProfileService()->gcm_client_factory_.get())->gcm_client();
+    return static_cast<GCMClientMock*>(
+        GetGCMProfileService()->GetGCMClientForTesting());
   }
 
   const std::string& GetUsername() const {
     return GetGCMProfileService()->username_;
   }
 
   bool IsGCMClientReady() const {
     return GetGCMProfileService()->gcm_client_ready_;
   }
 
   bool ExistsCachedRegistrationInfo() const {
     return !GetGCMProfileService()->registration_info_map_.empty();
   }
 
   Profile* profile() const { return profile_.get(); }
   FakeGCMEventRouter* gcm_event_router() const {
     return gcm_event_router_.get();
   }
 
-  void set_gcm_client_initial_status(GCMClientMock::Status status) {
-    gcm_client_initial_status_ = status;
+  void set_gcm_client_loading_delay(GCMClientMock::LoadingDelay delay) {
+    gcm_client_loading_delay_ = delay;
   }
   void set_gcm_client_error_simulation(GCMClientMock::ErrorSimulation error) {
     gcm_client_error_simulation_ = error;
   }
 
   const std::string& registration_id() const { return registration_id_; }
   GCMClient::Result registration_result() const { return registration_result_; }
   const std::string& send_message_id() const { return send_message_id_; }
   GCMClient::Result send_result() const { return send_result_; }
 
@@ skipping 11 matching lines @@
   virtual GCMEventRouter* GetEventRouter() const OVERRIDE {
     return gcm_event_router_.get();
   }
 
   Waiter* waiter_;  // Not owned.
   scoped_ptr<TestingProfile> profile_;
   ExtensionService* extension_service_;  // Not owned.
   FakeSigninManager* signin_manager_;  // Not owned.
   scoped_ptr<FakeGCMEventRouter> gcm_event_router_;
 
-  GCMClientMock::Status gcm_client_initial_status_;
+  GCMClientMock::LoadingDelay gcm_client_loading_delay_;
   GCMClientMock::ErrorSimulation gcm_client_error_simulation_;
 
   std::string registration_id_;
   GCMClient::Result registration_result_;
   bool has_persisted_registration_info_;
 
   std::string send_message_id_;
   GCMClient::Result send_result_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMProfileServiceTestConsumer);
@@ skipping 98 matching lines @@
 
 TEST_F(GCMProfileServiceTest, CreateGCMProfileServiceAfterProfileSignIn) {
   // Sign in to a profile. This will not initiate the check-in.
   consumer()->SignIn(kTestingUsername);
 
   // Create GCMProfileService after sign-in.
   consumer()->CreateGCMProfileServiceInstance();
   EXPECT_FALSE(consumer()->GetUsername().empty());
 }
 
-TEST_F(GCMProfileServiceTest, RegsiterWhenNotSignedIn) {
+TEST_F(GCMProfileServiceTest, SignInAndSignOutUnderPositiveChannelSignal) {
+  // Positive channel signal is provided in SetUp.
+  consumer()->CreateGCMProfileServiceInstance();
+  consumer()->SignIn(kTestingUsername);
+
+  // GCMClient should be loaded.
+  EXPECT_TRUE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::LOADED, consumer()->GetGCMClient()->status());
+
+  consumer()->SignOut();
+
+  // GCMClient should be checked out.
+  EXPECT_FALSE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::CHECKED_OUT, consumer()->GetGCMClient()->status());
+}
+
+TEST_F(GCMProfileServiceTest, SignInAndSignOutUnderNegativeChannelSignal) {
+  // Negative channel signal will prevent GCMClient from checking in when the
+  // profile is signed in.
+  profile()->GetPrefs()->SetBoolean(prefs::kGCMChannelEnabled, false);
+
+  consumer()->CreateGCMProfileServiceInstance();
+  consumer()->SignIn(kTestingUsername);
+
+  // GCMClient should not be loaded.
+  EXPECT_FALSE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::UNINITIALIZED, consumer()->GetGCMClient()->status());
+
+  consumer()->SignOut();
+
+  // Check-out should still be performed.
+  EXPECT_FALSE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::CHECKED_OUT, consumer()->GetGCMClient()->status());
+}
+
+TEST_F(GCMProfileServiceTest, SignOutAndThenSignIn) {
+  // Positive channel signal is provided in SetUp.
+  consumer()->CreateGCMProfileServiceInstance();
+  consumer()->SignIn(kTestingUsername);
+
+  // GCMClient should not be loaded.

[Nicolas Zea, 2014/02/22 00:20:47]

update comment

+  EXPECT_TRUE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::LOADED, consumer()->GetGCMClient()->status());
+
+  consumer()->SignOut();
+
+  // GCMClient should be checked out.
+  EXPECT_FALSE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::CHECKED_OUT, consumer()->GetGCMClient()->status());
+
+  // Sign-in with a different username.
+  consumer()->SignIn(kTestingUsername2);
+
+  // GCMClient should be loaded again.
+  EXPECT_TRUE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::LOADED, consumer()->GetGCMClient()->status());
+}
+
+TEST_F(GCMProfileServiceTest, RegisterWhenNotSignedIn) {
+  consumer()->CreateGCMProfileServiceInstance();
+
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   consumer()->Register(kTestingAppId, sender_ids);
 
   EXPECT_TRUE(consumer()->registration_id().empty());
   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, consumer()->registration_result());
 }
 
+TEST_F(GCMProfileServiceTest, RegisterUnderNeutralChannelSignal) {
+  // Neutral channel signal will prevent GCMClient from checking in when the
+  // profile is signed in.
+  profile()->GetPrefs()->ClearPref(prefs::kGCMChannelEnabled);
+
+  consumer()->CreateGCMProfileServiceInstance();
+  consumer()->SignIn(kTestingUsername);
+
+  // GCMClient should not be checked in.
+  EXPECT_FALSE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::UNINITIALIZED, consumer()->GetGCMClient()->status());
+
+  // Invoking register will make GCMClient checked in.
+  std::vector<std::string> sender_ids;
+  sender_ids.push_back("sender1");
+  consumer()->Register(kTestingAppId, sender_ids);
+  WaitUntilCompleted();
+
+  // GCMClient should be checked in.
+  EXPECT_TRUE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::LOADED, consumer()->GetGCMClient()->status());
+
+  // Registration should succeed.
+  std::string expected_registration_id =
+      GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
+  EXPECT_EQ(expected_registration_id, consumer()->registration_id());
+  EXPECT_EQ(GCMClient::SUCCESS, consumer()->registration_result());
+}
+
 TEST_F(GCMProfileServiceTest, SendWhenNotSignedIn) {
+  consumer()->CreateGCMProfileServiceInstance();
+
   GCMClient::OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   consumer()->Send(kTestingAppId, kUserId, message);
 
   EXPECT_TRUE(consumer()->send_message_id().empty());
   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, consumer()->send_result());
 }
 
+TEST_F(GCMProfileServiceTest, SendUnderNeutralChannelSignal) {
+  // Neutral channel signal will prevent GCMClient from checking in when the
+  // profile is signed in.
+  profile()->GetPrefs()->ClearPref(prefs::kGCMChannelEnabled);
+
+  consumer()->CreateGCMProfileServiceInstance();
+  consumer()->SignIn(kTestingUsername);
+
+  // GCMClient should not be checked in.
+  EXPECT_FALSE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::UNINITIALIZED, consumer()->GetGCMClient()->status());
+
+  // Invoking send will make GCMClient checked in.
+  GCMClient::OutgoingMessage message;
+  message.id = "1";
+  message.data["key1"] = "value1";
+  consumer()->Send(kTestingAppId, kUserId, message);
+  WaitUntilCompleted();
+
+  // GCMClient should be checked in.
+  EXPECT_TRUE(consumer()->IsGCMClientReady());
+  EXPECT_EQ(GCMClientMock::LOADED, consumer()->GetGCMClient()->status());
+
+  // Sending should succeed.
+  EXPECT_EQ(consumer()->send_message_id(), message.id);
+  EXPECT_EQ(GCMClient::SUCCESS, consumer()->send_result());
+}
+
 // Tests single-profile.
 class GCMProfileServiceSingleProfileTest : public GCMProfileServiceTest {
  public:
   GCMProfileServiceSingleProfileTest() {
   }
 
   virtual ~GCMProfileServiceSingleProfileTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     GCMProfileServiceTest::SetUp();
 
     consumer()->CreateGCMProfileServiceInstance();
     consumer()->SignIn(kTestingUsername);
   }
 };
 
-TEST_F(GCMProfileServiceSingleProfileTest, SignOut) {
-  EXPECT_TRUE(consumer()->IsGCMClientReady());
-
-  // This will trigger check-out.
-  consumer()->SignOut();
-
-  EXPECT_FALSE(consumer()->IsGCMClientReady());
-}
-
-TEST_F(GCMProfileServiceSingleProfileTest, SignOutAndThenSignIn) {
-  EXPECT_TRUE(consumer()->IsGCMClientReady());
-
-  // This will trigger check-out.
-  consumer()->SignOut();
-
-  EXPECT_FALSE(consumer()->IsGCMClientReady());
-
-  // Sign-in with a different username.
-  consumer()->SignIn(kTestingUsername2);
-
-  EXPECT_TRUE(consumer()->IsGCMClientReady());
-}
-
 TEST_F(GCMProfileServiceSingleProfileTest, Register) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   consumer()->Register(kTestingAppId, sender_ids);
   std::string expected_registration_id =
       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
 
   WaitUntilCompleted();
   EXPECT_EQ(expected_registration_id, consumer()->registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, consumer()->registration_result());
@@ skipping 125 matching lines @@
 
   WaitUntilCompleted();
   EXPECT_FALSE(consumer()->registration_id().empty());
   EXPECT_EQ(GCMClient::SUCCESS, consumer()->registration_result());
   std::string old_registration_id = consumer()->registration_id();
 
   // Clears the results that would be set by the Register callback in
   // preparation to call register 2nd time.
   consumer()->clear_registration_result();
 
-  // Needs to create a GCMClient instance that is not ready initiallly.
-  consumer()->set_gcm_client_initial_status(GCMClientMock::NOT_READY);
-
   // Simulate start-up by recreating GCMProfileService.
+  consumer()->set_gcm_client_loading_delay(GCMClientMock::DELAY_LOADING);
   consumer()->CreateGCMProfileServiceInstance();
 
   // Simulate start-up by reloading extension.
   consumer()->ReloadExtension(extension);
 
   // Read the registration info from the extension's state store.
   // This would hold up because GCMClient is in loading state.
   consumer()->Register(extension->id(), sender_ids);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(consumer()->registration_id().empty());
   EXPECT_EQ(GCMClient::UNKNOWN_ERROR, consumer()->registration_result());
 
   // Register operation will be invoked after GCMClient becomes ready.
-  consumer()->GetGCMClient()->SetReady();
+  consumer()->GetGCMClient()->PerformDelayedLoading();
   WaitUntilCompleted();
   EXPECT_EQ(old_registration_id, consumer()->registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, consumer()->registration_result());
 }
 
 TEST_F(GCMProfileServiceSingleProfileTest,
        PersistedRegistrationInfoRemoveAfterSignOut) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   consumer()->Register(kTestingAppId, sender_ids);
@@ skipping 443 matching lines @@
   consumer()->gcm_event_router()->clear_results();
   WaitUntilCompleted();
 
   EXPECT_EQ(FakeGCMEventRouter::MESSAGE_EVENT,
             consumer()->gcm_event_router()->received_event());
   EXPECT_TRUE(
       in_message5.data == consumer()->gcm_event_router()->message().data);
 }
 
 }  // namespace gcm