Rename GCMClient::Load to GCMClient::Start

chrome/browser/services/gcm/gcm_service_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 "chrome/browser/services/gcm/gcm_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
@@ skipping 216 matching lines @@
     return unregistration_result_;
   }
 
   void ClearRegistrationResult();
   void ClearUnregistrationResult();
 
   bool ServiceHasAppHandlers() const;
   GCMClientMock* GetGCMClient();
 
   void CreateService(bool start_automatically,
-                     GCMClientMock::LoadingDelay gcm_client_loading_delay);
+                     GCMClientMock::StartMode gcm_client_start_mode);
 
   void SignIn(const std::string& account_id);
   void SignOut();
 
   void Register(const std::string& app_id,
                 const std::vector<std::string>& sender_ids,
                 WaitToFinish wait_to_finish);
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message,
@@ skipping 58 matching lines @@
 bool TestGCMServiceWrapper::ServiceHasAppHandlers() const {
   return !service_->app_handlers_.empty();
 }
 
 GCMClientMock* TestGCMServiceWrapper::GetGCMClient() {
   return static_cast<GCMClientMock*>(service_->GetGCMClientForTesting());
 }
 
 void TestGCMServiceWrapper::CreateService(
     bool start_automatically,
-    GCMClientMock::LoadingDelay gcm_client_loading_delay) {
+    GCMClientMock::StartMode gcm_client_start_mode) {
   service_.reset(new TestGCMService(
       start_automatically,
       identity_provider_owner_.PassAs<IdentityProvider>(),
       request_context_));
   service_->Initialize(scoped_ptr<GCMClientFactory>(
-      new FakeGCMClientFactory(gcm_client_loading_delay)));
+      new FakeGCMClientFactory(gcm_client_start_mode)));
 
   gcm_app_handler_.reset(new FakeGCMAppHandler);
   service_->AddAppHandler(kTestAppID1, gcm_app_handler_.get());
   service_->AddAppHandler(kTestAppID2, gcm_app_handler_.get());
 }
 
 void TestGCMServiceWrapper::SignIn(const std::string& account_id) {
   token_service_.AddAccount(account_id);
   identity_provider_->LogIn(account_id);
   PumpIOLoop();
@@ skipping 105 matching lines @@
           content::BrowserThread::IO));
   wrapper_.reset(new TestGCMServiceWrapper(request_context_));
 }
 
 void GCMServiceTest::TearDown() {
   wrapper_.reset();
 }
 
 TEST_F(GCMServiceTest, CreateGCMServiceBeforeSignIn) {
   // Create CreateGMCService first.
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
   EXPECT_FALSE(wrapper_->service()->IsStarted());
 
   // Sign in. This will kick off the check-in.
   wrapper_->SignIn(kTestAccountID1);
   EXPECT_TRUE(wrapper_->service()->IsStarted());
 }
 
 TEST_F(GCMServiceTest, CreateGCMServiceAfterSignIn) {
   // Sign in. This will not initiate the check-in.
   wrapper_->SignIn(kTestAccountID1);
 
   // Create GCMeService after sign-in.
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
   EXPECT_TRUE(wrapper_->service()->IsStarted());
 }
 
 TEST_F(GCMServiceTest, Shutdown) {
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
   EXPECT_TRUE(wrapper_->ServiceHasAppHandlers());
 
   wrapper_->service()->ShutdownService();
   EXPECT_FALSE(wrapper_->ServiceHasAppHandlers());
 }
 
 TEST_F(GCMServiceTest, SignInAndSignOutUnderPositiveChannelSignal) {
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 
   // GCMClient should be loaded.
   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::LOADED, wrapper_->GetGCMClient()->status());
+  EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 
   wrapper_->SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::CHECKED_OUT, wrapper_->GetGCMClient()->status());
 }
 
 TEST_F(GCMServiceTest, SignInAndSignOutUnderNonPositiveChannelSignal) {
   // Non-positive channel signal will prevent GCMClient from checking in during
   // sign-in.
-  wrapper_->CreateService(false, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(false, GCMClientMock::NO_DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 
   // GCMClient should not be loaded.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::UNINITIALIZED, wrapper_->GetGCMClient()->status());
 
   wrapper_->SignOut();
 
   // Check-out should still be performed.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::CHECKED_OUT, wrapper_->GetGCMClient()->status());
 }
 
 TEST_F(GCMServiceTest, SignOutAndThenSignIn) {
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 
   // GCMClient should be loaded.
   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::LOADED, wrapper_->GetGCMClient()->status());
+  EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 
   wrapper_->SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::CHECKED_OUT, wrapper_->GetGCMClient()->status());
 
   // Sign-in with a different account.
   wrapper_->SignIn(kTestAccountID2);
 
   // GCMClient should be loaded again.
   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::LOADED, wrapper_->GetGCMClient()->status());
+  EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 }
 
 TEST_F(GCMServiceTest, StopAndRestartGCM) {
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 
   // GCMClient should be loaded.
   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::LOADED, wrapper_->GetGCMClient()->status());
+  EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 
   // Stops the GCM.
   wrapper_->service()->Stop();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be stopped.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::STOPPED, wrapper_->GetGCMClient()->status());
 
   // Restarts the GCM.
   wrapper_->service()->Start();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be loaded.
   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::LOADED, wrapper_->GetGCMClient()->status());
+  EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 
   // Stops the GCM.
   wrapper_->service()->Stop();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be stopped.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::STOPPED, wrapper_->GetGCMClient()->status());
 
   // Sign out.
   wrapper_->SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::CHECKED_OUT, wrapper_->GetGCMClient()->status());
 }
 
 TEST_F(GCMServiceTest, RegisterWhenNotSignedIn) {
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 
   EXPECT_TRUE(wrapper_->registration_id().empty());
   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceTest, RegisterUnderNonPositiveChannelSignal) {
   // Non-positive channel signal will prevent GCMClient from checking in during
   // sign-in.
-  wrapper_->CreateService(false, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(false, GCMClientMock::NO_DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 
   // GCMClient should not be checked in.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::UNINITIALIZED, wrapper_->GetGCMClient()->status());
 
   // Invoking register will make GCMClient checked in.
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 
   // GCMClient should be checked in.
   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::LOADED, wrapper_->GetGCMClient()->status());
+  EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 
   // Registration should succeed.
   const std::string expected_registration_id =
       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceTest, SendWhenNotSignedIn) {
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 
   GCMClient::OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 
   EXPECT_TRUE(wrapper_->send_message_id().empty());
   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->send_result());
 }
 
 TEST_F(GCMServiceTest, SendUnderNonPositiveChannelSignal) {
   // Non-positive channel signal will prevent GCMClient from checking in during
   // sign-in.
-  wrapper_->CreateService(false, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(false, GCMClientMock::NO_DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 
   // GCMClient should not be checked in.
   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
   EXPECT_EQ(GCMClientMock::UNINITIALIZED, wrapper_->GetGCMClient()->status());
 
   // Invoking send will make GCMClient checked in.
   GCMClient::OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 
   // GCMClient should be checked in.
   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::LOADED, wrapper_->GetGCMClient()->status());
+  EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 
   // Sending should succeed.
   EXPECT_EQ(message.id, wrapper_->send_message_id());
   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
 }
 
 // Tests a single instance of GCMService.
 class GCMServiceSingleInstanceTest : public GCMServiceTest {
  public:
   GCMServiceSingleInstanceTest();
   virtual ~GCMServiceSingleInstanceTest();
 
   // GCMServiceTest:
   virtual void SetUp() OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GCMServiceSingleInstanceTest);
 };
 
 GCMServiceSingleInstanceTest::GCMServiceSingleInstanceTest() {
 }
 
 GCMServiceSingleInstanceTest::~GCMServiceSingleInstanceTest() {
 }
 
 void GCMServiceSingleInstanceTest::SetUp() {
   GCMServiceTest::SetUp();
 
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 }
 
 TEST_F(GCMServiceSingleInstanceTest, Register) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
   const std::string expected_registration_id =
       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
 
@@ skipping 56 matching lines @@
   // Calling register 2nd time with the different sender IDs will get back a new
   // registration ID.
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
   EXPECT_EQ(expected_registration_id2, wrapper_->registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, GCMClientNotReadyBeforeRegistration) {
   // Make GCMClient not ready initially.
   wrapper_.reset(new TestGCMServiceWrapper(request_context_));
-  wrapper_->CreateService(true, GCMClientMock::DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 
   // The registration is on hold until GCMClient is ready.
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   wrapper_->Register(kTestAppID1,
                      sender_ids,
                      TestGCMServiceWrapper::DO_NOT_WAIT);
   PumpIOLoop();
   PumpUILoop();
@@ skipping 111 matching lines @@
   message.data["key2"] = "value2";
   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(message.id, wrapper_->send_message_id());
   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, GCMClientNotReadyBeforeSending) {
   // Make GCMClient not ready initially.
   wrapper_.reset(new TestGCMServiceWrapper(request_context_));
-  wrapper_->CreateService(true, GCMClientMock::DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::DELAY_START);
   wrapper_->SignIn(kTestAccountID1);
 
   // The sending is on hold until GCMClient is ready.
   GCMClient::OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   message.data["key2"] = "value2";
   wrapper_->Send(kTestAppID1,
                  kUserID1,
                  message,
@@ skipping 115 matching lines @@
 }
 
 GCMServiceMultipleInstanceTest::~GCMServiceMultipleInstanceTest() {
 }
 
 void GCMServiceMultipleInstanceTest::SetUp() {
   GCMServiceTest::SetUp();
 
   wrapper2_.reset(new TestGCMServiceWrapper(request_context_));
 
-  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
-  wrapper2_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
+  wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
+  wrapper2_->CreateService(true, GCMClientMock::NO_DELAY_START);
 
   // Initiate check-in for each instance.
   wrapper_->SignIn(kTestAccountID1);
   wrapper2_->SignIn(kTestAccountID2);
 }
 
 void GCMServiceMultipleInstanceTest::TearDown() {
   wrapper2_.reset();
 }
 
@@ skipping 289 matching lines @@
   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, in_message5);
 
   wrapper_->gcm_app_handler()->WaitForNotification();
 
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper_->gcm_app_handler()->received_event());
   EXPECT_EQ(in_message5.data, wrapper_->gcm_app_handler()->message().data);
 }
 
 }  // namespace gcm