Make GCMProfileService own GCMDriver, instead of deriving from it

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"
@@ skipping 83 matching lines @@
   scoped_ptr<base::RunLoop> run_loop_;
 
   Event received_event_;
   std::string app_id_;
   GCMClient::IncomingMessage message_;
   GCMClient::SendErrorDetails send_error_details_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGCMAppHandler);
 };
 
-class TestGCMDriver : public GCMDriver {
- public:
-  TestGCMDriver(
-      bool start_automatically,
-      scoped_ptr<IdentityProvider> identity_provider,
-      const scoped_refptr<net::URLRequestContextGetter>& request_context);
-  virtual ~TestGCMDriver();
-
- protected:
-  // GCMDriver:
-  virtual bool ShouldStartAutomatically() const OVERRIDE;
-  virtual base::FilePath GetStorePath() const OVERRIDE;
-  virtual scoped_refptr<net::URLRequestContextGetter>
-      GetURLRequestContextGetter() const OVERRIDE;
-
- private:
-  base::ScopedTempDir temp_dir_;
-  scoped_refptr<net::URLRequestContextGetter> request_context_;
-  const bool start_automatically_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestGCMDriver);
-};
-
 FakeGCMAppHandler::FakeGCMAppHandler() : received_event_(NO_EVENT) {
 }
 
 FakeGCMAppHandler::~FakeGCMAppHandler() {
 }
 
 void FakeGCMAppHandler::WaitForNotification() {
   run_loop_.reset(new base::RunLoop);
   run_loop_->Run();
   run_loop_.reset();
@@ skipping 31 matching lines @@
     run_loop_->Quit();
 }
 
 void FakeGCMAppHandler::ClearResults() {
   received_event_ = NO_EVENT;
   app_id_.clear();
   message_ = GCMClient::IncomingMessage();
   send_error_details_ = GCMClient::SendErrorDetails();
 }
 
-TestGCMDriver::TestGCMDriver(
-    bool start_automatically,
-    scoped_ptr<IdentityProvider> identity_provider,
-    const scoped_refptr<net::URLRequestContextGetter>& request_context)
-    : GCMDriver(identity_provider.Pass()),
-      request_context_(request_context),
-      start_automatically_(start_automatically) {
-  if (!temp_dir_.CreateUniqueTempDir())
-    ADD_FAILURE();
-}
-
-TestGCMDriver::~TestGCMDriver() {
-}
-
-bool TestGCMDriver::ShouldStartAutomatically() const {
-  return start_automatically_;
-}
-
-base::FilePath TestGCMDriver::GetStorePath() const {
-  return temp_dir_.path();
-}
-
-scoped_refptr<net::URLRequestContextGetter>
-TestGCMDriver::GetURLRequestContextGetter() const {
-  return request_context_;
-}
-
 }  // namespace
 
 class GCMDriverTest : public testing::Test {
  public:
   enum WaitToFinish {
     DO_NOT_WAIT,
     WAIT
   };
 
   GCMDriverTest();
   virtual ~GCMDriverTest();
 
   // testing::Test:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
-  TestGCMDriver* driver() { return driver_.get(); }
+  GCMDriver* driver() { return driver_.get(); }
   FakeGCMAppHandler* gcm_app_handler() { return gcm_app_handler_.get(); }
   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_; }
   GCMClient::Result unregistration_result() const {
     return unregistration_result_;
   }
 
-  void ClearRegistrationResult();
-  void ClearUnregistrationResult();
+  void ClearResults();
 
   bool HasAppHandlers() const;
   FakeGCMClient* GetGCMClient();
 
-  void CreateDriver(bool start_automatically,
-                    FakeGCMClient::StartMode gcm_client_start_mode);
+  void CreateDriver(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,
             WaitToFinish wait_to_finish);
   void Unregister(const std::string& app_id, WaitToFinish wait_to_finish);
 
   void WaitForAsyncOperation();
 
  private:
   void RegisterCompleted(const std::string& registration_id,
                          GCMClient::Result result);
   void SendCompleted(const std::string& message_id, GCMClient::Result result);
   void UnregisterCompleted(GCMClient::Result result);
 
   scoped_ptr<content::TestBrowserThreadBundle> thread_bundle_;
+  base::ScopedTempDir temp_dir_;
   FakeOAuth2TokenService token_service_;
   scoped_ptr<FakeIdentityProvider> identity_provider_owner_;
   FakeIdentityProvider* identity_provider_;
-  scoped_ptr<TestGCMDriver> driver_;
+  scoped_ptr<GCMDriver> driver_;
   scoped_ptr<FakeGCMAppHandler> gcm_app_handler_;
 
   base::Closure async_operation_completed_callback_;
 
   std::string registration_id_;
   GCMClient::Result registration_result_;
   std::string send_message_id_;
   GCMClient::Result send_result_;
   GCMClient::Result unregistration_result_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriverTest);
 };
 
 GCMDriverTest::GCMDriverTest()
     : identity_provider_(NULL),
       registration_result_(GCMClient::UNKNOWN_ERROR),
       send_result_(GCMClient::UNKNOWN_ERROR),
       unregistration_result_(GCMClient::UNKNOWN_ERROR) {
   identity_provider_owner_.reset(new FakeIdentityProvider(&token_service_));
   identity_provider_ = identity_provider_owner_.get();
 }
 
 GCMDriverTest::~GCMDriverTest() {
 }
 
 void GCMDriverTest::SetUp() {
   thread_bundle_.reset(new content::TestBrowserThreadBundle(
       content::TestBrowserThreadBundle::REAL_IO_THREAD));
+  ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 }
 
 void GCMDriverTest::TearDown() {
   if (!driver_)
     return;
 
-  driver_->ShutdownService();
+  driver_->Shutdown();
   driver_.reset();
   PumpIOLoop();
 }
 
-void GCMDriverTest::ClearRegistrationResult() {
+void GCMDriverTest::ClearResults() {
   registration_id_.clear();
   registration_result_ = GCMClient::UNKNOWN_ERROR;
-}
 
-void GCMDriverTest::ClearUnregistrationResult() {
+  send_message_id_.clear();
+  send_result_ = GCMClient::UNKNOWN_ERROR;
+
   unregistration_result_ = GCMClient::UNKNOWN_ERROR;
 }
 
 bool GCMDriverTest::HasAppHandlers() const {
   return !driver_->app_handlers().empty();
 }
 
 FakeGCMClient* GCMDriverTest::GetGCMClient() {
   return static_cast<FakeGCMClient*>(driver_->GetGCMClientForTesting());
 }
 
 void GCMDriverTest::CreateDriver(
-    bool start_automatically,
     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,
+  driver_.reset(new GCMDriver(
+      scoped_ptr<GCMClientFactory>(new FakeGCMClientFactory(
+          gcm_client_start_mode)).Pass(),
       identity_provider_owner_.PassAs<IdentityProvider>(),
+      temp_dir_.path(),
       request_context));
-  driver_->Initialize(scoped_ptr<GCMClientFactory>(
-      new FakeGCMClientFactory(gcm_client_start_mode)));
 
   gcm_app_handler_.reset(new FakeGCMAppHandler);
   driver_->AddAppHandler(kTestAppID1, gcm_app_handler_.get());
   driver_->AddAppHandler(kTestAppID2, gcm_app_handler_.get());
 }
 
 void GCMDriverTest::SignIn(const std::string& account_id) {
   token_service_.AddAccount(account_id);
   identity_provider_->LogIn(account_id);
   PumpIOLoop();
@@ skipping 68 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, FakeGCMClient::NO_DELAY_START);
+  CreateDriver(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, FakeGCMClient::NO_DELAY_START);
+  CreateDriver(FakeGCMClient::NO_DELAY_START);
   EXPECT_TRUE(driver()->IsStarted());
 }
 
 TEST_F(GCMDriverTest, Shutdown) {
-  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
+  CreateDriver(FakeGCMClient::NO_DELAY_START);
   EXPECT_TRUE(HasAppHandlers());
 
-  driver()->ShutdownService();
+  driver()->Shutdown();
   EXPECT_FALSE(HasAppHandlers());
 }
 
 TEST_F(GCMDriverTest, SignInAndSignOutUnderPositiveChannelSignal) {
-  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
+  CreateDriver(FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient should be loaded.
   EXPECT_TRUE(driver()->IsGCMClientReady());
   EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
   SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(driver()->IsGCMClientReady());
   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, FakeGCMClient::NO_DELAY_START);
-  SignIn(kTestAccountID1);
-
-  // GCMClient should not be loaded.
-  EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status());
-
-  SignOut();
-
-  // Check-out should still be performed.
-  EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
-}
-
 TEST_F(GCMDriverTest, SignOutAndThenSignIn) {
-  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
+  CreateDriver(FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
   // GCMClient should be loaded.
   EXPECT_TRUE(driver()->IsGCMClientReady());
   EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
   SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(driver()->IsGCMClientReady());
   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(FakeGCMClient::STARTED, GetGCMClient()->status());
 }
 
-TEST_F(GCMDriverTest, StopAndRestartGCM) {
-  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
+TEST_F(GCMDriverTest, DisableAndReenableGCM) {
+  CreateDriver(FakeGCMClient::NO_DELAY_START);
   SignIn(kTestAccountID1);
 
-  // GCMClient should be loaded.
+  // GCMClient should be started.
   EXPECT_TRUE(driver()->IsGCMClientReady());
   EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
-  // Stops the GCM.
-  driver()->Stop();
+  // Disables the GCM.
+  driver()->Disable();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be stopped.
   EXPECT_FALSE(driver()->IsGCMClientReady());
   EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status());
 
-  // Restarts the GCM.
-  driver()->Start();
+  // Enables the GCM.
+  driver()->Enable();
   PumpIOLoop();
   PumpUILoop();
 
-  // GCMClient should be loaded.
+  // GCMClient should be started.
   EXPECT_TRUE(driver()->IsGCMClientReady());
   EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
 
-  // Stops the GCM.
-  driver()->Stop();
+  // Disables the GCM.
+  driver()->Disable();
   PumpIOLoop();
   PumpUILoop();
 
   // GCMClient should be stopped.
   EXPECT_FALSE(driver()->IsGCMClientReady());
   EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status());
 
   // Sign out.
   SignOut();
 
   // GCMClient should be checked out.
   EXPECT_FALSE(driver()->IsGCMClientReady());
   EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status());
 }
 
-TEST_F(GCMDriverTest, RegisterWhenNotSignedIn) {
-  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
-
+TEST_F(GCMDriverTest, RegisterFailed) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
+
+  CreateDriver(FakeGCMClient::NO_DELAY_START);
+
+  // Registration fails when GCM is disabled.
+  driver()->Disable();
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
+  EXPECT_TRUE(registration_id().empty());
+  EXPECT_EQ(GCMClient::GCM_DISABLED, registration_result());
 
+  ClearResults();
+
+  // Registration fails when the sign-in does not occur.
+  driver()->Enable();
+  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, FakeGCMClient::NO_DELAY_START);
-  SignIn(kTestAccountID1);
+TEST_F(GCMDriverTest, UnregisterFailed) {
+  CreateDriver(FakeGCMClient::NO_DELAY_START);
 
-  // GCMClient should not be checked in.
-  EXPECT_FALSE(driver()->IsGCMClientReady());
-  EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status());
+  // Unregistration fails when GCM is disabled.
+  driver()->Disable();
+  Unregister(kTestAppID1, GCMDriverTest::WAIT);
+  EXPECT_EQ(GCMClient::GCM_DISABLED, unregistration_result());
 
-  // Invoking register will make GCMClient checked in.
-  std::vector<std::string> sender_ids;
-  sender_ids.push_back("sender1");
-  Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
+  ClearResults();
 
-  // GCMClient should be checked in.
-  EXPECT_TRUE(driver()->IsGCMClientReady());
-  EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status());
-
-  // Registration should succeed.
-  const std::string expected_registration_id =
-      FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids);
-  EXPECT_EQ(expected_registration_id, registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, registration_result());
+  // Unregistration fails when the sign-in does not occur.
+  driver()->Enable();
+  Unregister(kTestAppID1, GCMDriverTest::WAIT);
+  EXPECT_EQ(GCMClient::NOT_SIGNED_IN, unregistration_result());
 }
 
-TEST_F(GCMDriverTest, SendWhenNotSignedIn) {
-  CreateDriver(true, FakeGCMClient::NO_DELAY_START);
-
+TEST_F(GCMDriverTest, SendFailed) {
   GCMClient::OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
+
+  CreateDriver(FakeGCMClient::NO_DELAY_START);
+
+  // Sending fails when GCM is disabled.
+  driver()->Disable();
   Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT);
+  EXPECT_TRUE(send_message_id().empty());
+  EXPECT_EQ(GCMClient::GCM_DISABLED, send_result());
 
+  ClearResults();
+
+  // Registration fails when the sign-in does not occur.
+  driver()->Enable();
+  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, FakeGCMClient::NO_DELAY_START);
-  SignIn(kTestAccountID1);
-
-  // GCMClient should not be checked in.
-  EXPECT_FALSE(driver()->IsGCMClientReady());
-  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(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, FakeGCMClient::DELAY_START);
+  CreateDriver(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, FakeGCMClient::DELAY_START);
+  CreateDriver(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, FakeGCMClient::NO_DELAY_START);
+  CreateDriver(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 =
       FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids);
 
@@ skipping 16 matching lines @@
   sender_ids.push_back("sender2");
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
   const std::string expected_registration_id =
       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();
+  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());
@@ skipping 66 matching lines @@
 
   // Start unregistration without waiting for it to complete. This time no async
   // operation is pending.
   Unregister(kTestAppID1, GCMDriverTest::DO_NOT_WAIT);
 
   // Test that unregistration fails with async operation pending when there is
   // an unregistration already in progress.
   Unregister(kTestAppID1, GCMDriverTest::WAIT);
   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
             unregistration_result());
-  ClearUnregistrationResult();
+  ClearResults();
 
   // Complete unregistration.
   WaitForAsyncOperation();
   EXPECT_EQ(GCMClient::SUCCESS, unregistration_result());
 }
 
 TEST_F(GCMDriverFunctionalTest, RegisterWhenAsyncOperationPending) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   // First start registration without waiting for it to complete.
   Register(kTestAppID1,
                      sender_ids,
                      GCMDriverTest::DO_NOT_WAIT);
 
   // Test that registration fails with async operation pending when there is a
   // registration already in progress.
   Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT);
   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
             registration_result());
-  ClearRegistrationResult();
+  ClearResults();
 
   // Complete the registration.
   WaitForAsyncOperation();
   EXPECT_EQ(GCMClient::SUCCESS, registration_result());
 
   // Start unregistration without waiting for it to complete. This time no async
   // operation is pending.
   Unregister(kTestAppID1, GCMDriverTest::DO_NOT_WAIT);
 
   // Test that registration fails with async operation pending when there is an
@@ skipping 94 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