Rename GCMClientMock to FakeGCMClient

chrome/browser/services/gcm/gcm_driver_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_driver.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
+#include "chrome/browser/services/gcm/fake_gcm_client.h"
 #include "chrome/browser/services/gcm/fake_gcm_client_factory.h"
 #include "chrome/browser/services/gcm/gcm_app_handler.h"
-#include "chrome/browser/services/gcm/gcm_client_mock.h"
 #include "components/gcm_driver/gcm_client_factory.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/fake_identity_provider.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
@@ skipping 198 matching lines @@
   const std::string& send_message_id() const { return send_message_id_; }
   GCMClient::Result send_result() const { return send_result_; }
   GCMClient::Result unregistration_result() const {
     return unregistration_result_;
   }
 
   void ClearRegistrationResult();
   void ClearUnregistrationResult();
 
   bool HasAppHandlers() const;
-  GCMClientMock* GetGCMClient();
+  FakeGCMClient* GetGCMClient();
 
   void CreateDriver(bool start_automatically,
-                    GCMClientMock::StartMode gcm_client_start_mode);
+                    FakeGCMClient::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 @@
 }
 
 void GCMDriverTest::ClearUnregistrationResult() {
   unregistration_result_ = GCMClient::UNKNOWN_ERROR;
 }
 
 bool GCMDriverTest::HasAppHandlers() const {
   return !driver_->app_handlers().empty();
 }
 
-GCMClientMock* GCMDriverTest::GetGCMClient() {
-  return static_cast<GCMClientMock*>(driver_->GetGCMClientForTesting());
+FakeGCMClient* GCMDriverTest::GetGCMClient() {
+  return static_cast<FakeGCMClient*>(driver_->GetGCMClientForTesting());
 }
 
 void GCMDriverTest::CreateDriver(
     bool start_automatically,
-    GCMClientMock::StartMode gcm_client_start_mode) {
+    FakeGCMClient::StartMode gcm_client_start_mode) {
   scoped_refptr<net::URLRequestContextGetter> request_context =
       new net::TestURLRequestContextGetter(
           content::BrowserThread::GetMessageLoopProxyForThread(
               content::BrowserThread::IO));
   driver_.reset(new TestGCMDriver(
       start_automatically,
       identity_provider_owner_.PassAs<IdentityProvider>(),
       request_context));
   driver_->Initialize(scoped_ptr<GCMClientFactory>(
       new FakeGCMClientFactory(gcm_client_start_mode)));
@@ skipping 78 matching lines @@
 }
 
 void GCMDriverTest::UnregisterCompleted(GCMClient::Result result) {
   unregistration_result_ = result;
   if (!async_operation_completed_callback_.is_null())
     async_operation_completed_callback_.Run();
 }
 
 TEST_F(GCMDriverTest, CreateGCMDriverBeforeSignIn) {
   // Create CreateGMCService first.
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
   EXPECT_FALSE(driver()->IsStarted());
 
   // Sign in. This will kick off the check-in.
   SignIn(kTestAccountID1);
   EXPECT_TRUE(driver()->IsStarted());
 }
 
 TEST_F(GCMDriverTest, CreateGCMDriverAfterSignIn) {
   // Sign in. This will not initiate the check-in.
   SignIn(kTestAccountID1);
 
   // Create GCMeService after sign-in.
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
   EXPECT_TRUE(driver()->IsStarted());
 }
 
 TEST_F(GCMDriverTest, Shutdown) {
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
   EXPECT_TRUE(HasAppHandlers());
 
   driver()->ShutdownService();
   EXPECT_FALSE(HasAppHandlers());
 }
 
 TEST_F(GCMDriverTest, SignInAndSignOutUnderPositiveChannelSignal) {
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient should be loaded.
   EXPECT_TRUE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STARTED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
   SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::CHECKED_OUT, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
 }
 
 TEST_F(GCMDriverTest, SignInAndSignOutUnderNonPositiveChannelSignal) {
   // Non-positive channel signal will prevent GCMClient from checking in during
   // sign-in.
-  CreateDriver(false, GCMClientMock::NO_DELAY_START);
+  CreateDriver(false, FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient should not be loaded.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::UNINITIALIZED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status());
 
   SignOut();
 
   // Check-out should still be performed.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::CHECKED_OUT, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
 }
 
 TEST_F(GCMDriverTest, SignOutAndThenSignIn) {
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient should be loaded.
   EXPECT_TRUE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STARTED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
   SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::CHECKED_OUT, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
 
   // Sign-in with a different account.
   SignIn(kTestAccountID2);
 
   // GCMClient should be loaded again.
   EXPECT_TRUE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STARTED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 }
 
 TEST_F(GCMDriverTest, StopAndRestartGCM) {
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient should be loaded.
   EXPECT_TRUE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STARTED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
   // Stops the GCM.
   driver()->Stop();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be stopped.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STOPPED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status());
 
   // Restarts the GCM.
   driver()->Start();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be loaded.
   EXPECT_TRUE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STARTED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
   // Stops the GCM.
   driver()->Stop();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be stopped.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STOPPED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status());
 
   // Sign out.
   SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::CHECKED_OUT, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
 }
 
 TEST_F(GCMDriverTest, RegisterWhenNotSignedIn) {
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
 
   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(GCMDriverTest, RegisterUnderNonPositiveChannelSignal) {
   // Non-positive channel signal will prevent GCMClient from checking in during
   // sign-in.
-  CreateDriver(false, GCMClientMock::NO_DELAY_START);
+  CreateDriver(false, FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient should not be checked in.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::UNINITIALIZED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status());
 
   // Invoking register will make GCMClient checked in.
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
 
   // GCMClient should be checked in.
   EXPECT_TRUE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STARTED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
   // Registration should succeed.
   const std::string expected_registration_id =
-      GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
+      FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids);
   EXPECT_EQ(expected_registration_id, registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 }
 
 TEST_F(GCMDriverTest, SendWhenNotSignedIn) {
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
 
   GCMClient::OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT);
 
   EXPECT_TRUE(send_message_id().empty());
   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, send_result());
 }
 
 TEST_F(GCMDriverTest, SendUnderNonPositiveChannelSignal) {
   // Non-positive channel signal will prevent GCMClient from checking in during
   // sign-in.
-  CreateDriver(false, GCMClientMock::NO_DELAY_START);
+  CreateDriver(false, FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient should not be checked in.
   EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::UNINITIALIZED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status());
 
   // Invoking send will make GCMClient checked in.
   GCMClient::OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT);
 
   // GCMClient should be checked in.
   EXPECT_TRUE(driver()->IsGCMClientReady());
-  EXPECT_EQ(GCMClientMock::STARTED, GetGCMClient()->status());
+  EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
   // Sending should succeed.
   EXPECT_EQ(message.id, send_message_id());
   EXPECT_EQ(GCMClient::SUCCESS, send_result());
 }
 
 TEST_F(GCMDriverTest, GCMClientNotReadyBeforeRegistration) {
   // Make GCMClient not ready initially.
-  CreateDriver(true, GCMClientMock::DELAY_START);
+  CreateDriver(true, FakeGCMClient::DELAY_START);
   SignIn(kTestAccountID1);
 
   // The registration is on hold until GCMClient is ready.
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   Register(kTestAppID1,
                      sender_ids,
                      GCMDriverTest::DO_NOT_WAIT);
   PumpIOLoop();
   PumpUILoop();
   EXPECT_TRUE(registration_id().empty());
   EXPECT_EQ(GCMClient::UNKNOWN_ERROR, registration_result());
 
   // Register operation will be invoked after GCMClient becomes ready.
   GetGCMClient()->PerformDelayedLoading();
   WaitForAsyncOperation();
   EXPECT_FALSE(registration_id().empty());
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 }
 
 TEST_F(GCMDriverTest, GCMClientNotReadyBeforeSending) {
   // Make GCMClient not ready initially.
-  CreateDriver(true, GCMClientMock::DELAY_START);
+  CreateDriver(true, FakeGCMClient::DELAY_START);
   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";
   Send(kTestAppID1, kUserID1, message, GCMDriverTest::DO_NOT_WAIT);
   PumpIOLoop();
   PumpUILoop();
@@ skipping 23 matching lines @@
 
 GCMDriverFunctionalTest::GCMDriverFunctionalTest() {
 }
 
 GCMDriverFunctionalTest::~GCMDriverFunctionalTest() {
 }
 
 void GCMDriverFunctionalTest::SetUp() {
   GCMDriverTest::SetUp();
 
-  CreateDriver(true, GCMClientMock::NO_DELAY_START);
+  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
   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 =
-      GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
+      FakeGCMClient::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 =
-      GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
+      FakeGCMClient::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.
   ClearRegistrationResult();
 
   // 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 =
-      GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
+      FakeGCMClient::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 =
-      GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
+      FakeGCMClient::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.
@@ skipping 175 matching lines @@
 
 TEST_F(GCMDriverFunctionalTest, MessagesDeleted) {
   GetGCMClient()->DeleteMessages(kTestAppID1);
   gcm_app_handler()->WaitForNotification();
   EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT,
             gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 }
 
 }  // namespace gcm