Extract GCMClient data types into separate gcm_types.h

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 56 matching lines @@
     MESSAGE_EVENT,
     MESSAGES_DELETED_EVENT,
     SEND_ERROR_EVENT
   };
 
   FakeGCMAppHandler();
   virtual ~FakeGCMAppHandler();
 
   const Event& received_event() const { return received_event_; }
   const std::string& app_id() const { return app_id_; }
-  const GCMClient::IncomingMessage& message() const { return message_; }
-  const GCMClient::SendErrorDetails& send_error_details() const {
+  const IncomingMessage& message() const { return message_; }
+  const SendErrorDetails& send_error_details() const {
     return send_error_details_;
   }
 
   void WaitForNotification();
 
   // GCMAppHandler:
   virtual void ShutdownHandler() OVERRIDE;
   virtual void OnMessage(const std::string& app_id,
-                         const GCMClient::IncomingMessage& message) OVERRIDE;
+                         const IncomingMessage& message) OVERRIDE;
   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE;
   virtual void OnSendError(
       const std::string& app_id,
-      const GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
+      const SendErrorDetails& send_error_details) OVERRIDE;
 
  private:
   void ClearResults();
 
   scoped_ptr<base::RunLoop> run_loop_;
 
   Event received_event_;
   std::string app_id_;
-  GCMClient::IncomingMessage message_;
-  GCMClient::SendErrorDetails send_error_details_;
+  IncomingMessage message_;
+  SendErrorDetails send_error_details_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGCMAppHandler);
 };
 
 class TestGCMService : public GCMService {
  public:
   TestGCMService(
       bool start_automatically,
       scoped_ptr<IdentityProvider> identity_provider,
       const scoped_refptr<net::URLRequestContextGetter>& request_context);
@@ skipping 23 matching lines @@
 void FakeGCMAppHandler::WaitForNotification() {
   run_loop_.reset(new base::RunLoop);
   run_loop_->Run();
   run_loop_.reset();
 }
 
 void FakeGCMAppHandler::ShutdownHandler() {
 }
 
 void FakeGCMAppHandler::OnMessage(const std::string& app_id,
-                                  const GCMClient::IncomingMessage& message) {
+                                  const IncomingMessage& message) {
   ClearResults();
   received_event_ = MESSAGE_EVENT;
   app_id_ = app_id;
   message_ = message;
   if (run_loop_)
     run_loop_->Quit();
 }
 
 void FakeGCMAppHandler::OnMessagesDeleted(const std::string& app_id) {
   ClearResults();
   received_event_ = MESSAGES_DELETED_EVENT;
   app_id_ = app_id;
   if (run_loop_)
     run_loop_->Quit();
 }
 
 void FakeGCMAppHandler::OnSendError(
     const std::string& app_id,
-    const GCMClient::SendErrorDetails& send_error_details) {
+    const SendErrorDetails& send_error_details) {
   ClearResults();
   received_event_ = SEND_ERROR_EVENT;
   app_id_ = app_id;
   send_error_details_ = send_error_details;
   if (run_loop_)
     run_loop_->Quit();
 }
 
 void FakeGCMAppHandler::ClearResults() {
   received_event_ = NO_EVENT;
   app_id_.clear();
-  message_ = GCMClient::IncomingMessage();
-  send_error_details_ = GCMClient::SendErrorDetails();
+  message_ = IncomingMessage();
+  send_error_details_ = SendErrorDetails();
 }
 
 TestGCMService::TestGCMService(
     bool start_automatically,
     scoped_ptr<IdentityProvider> identity_provider,
     const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : GCMService(identity_provider.Pass()),
       request_context_(request_context),
       start_automatically_(start_automatically) {
   if (!temp_dir_.CreateUniqueTempDir())
@@ skipping 25 matching lines @@
     WAIT
   };
 
   explicit TestGCMServiceWrapper(
       const scoped_refptr<net::URLRequestContextGetter>& request_context);
   ~TestGCMServiceWrapper();
 
   TestGCMService* service() { return service_.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_; }
+  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 {
+  Result send_result() const { return send_result_; }
+  Result unregistration_result() const {
     return unregistration_result_;
   }
 
   void ClearRegistrationResult();
   void ClearUnregistrationResult();
 
   bool ServiceHasAppHandlers() const;
   GCMClientMock* GetGCMClient();
 
   void CreateService(bool start_automatically,
                      GCMClientMock::LoadingDelay gcm_client_loading_delay);
 
   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,
+            const 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);
+                         Result result);
+  void SendCompleted(const std::string& message_id, Result result);
+  void UnregisterCompleted(Result result);
 
   scoped_refptr<net::URLRequestContextGetter> request_context_;
   FakeOAuth2TokenService token_service_;
   scoped_ptr<FakeIdentityProvider> identity_provider_owner_;
   FakeIdentityProvider* identity_provider_;
   scoped_ptr<TestGCMService> service_;
   scoped_ptr<FakeGCMAppHandler> gcm_app_handler_;
 
   base::Closure async_operation_completed_callback_;
 
   std::string registration_id_;
-  GCMClient::Result registration_result_;
+  Result registration_result_;
   std::string send_message_id_;
-  GCMClient::Result send_result_;
-  GCMClient::Result unregistration_result_;
+  Result send_result_;
+  Result unregistration_result_;
 
   DISALLOW_COPY_AND_ASSIGN(TestGCMServiceWrapper);
 };
 
 TestGCMServiceWrapper::TestGCMServiceWrapper(
     const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : request_context_(request_context),
       identity_provider_(NULL),
-      registration_result_(GCMClient::UNKNOWN_ERROR),
-      send_result_(GCMClient::UNKNOWN_ERROR),
-      unregistration_result_(GCMClient::UNKNOWN_ERROR) {
+      registration_result_(RESULT_UNKNOWN_ERROR),
+      send_result_(RESULT_UNKNOWN_ERROR),
+      unregistration_result_(RESULT_UNKNOWN_ERROR) {
   identity_provider_owner_.reset(new FakeIdentityProvider(&token_service_));
   identity_provider_ = identity_provider_owner_.get();
 }
 
 TestGCMServiceWrapper::~TestGCMServiceWrapper() {
   if (!service_)
     return;
 
   service_->ShutdownService();
   service_.reset();
   PumpIOLoop();
 }
 
 void TestGCMServiceWrapper::ClearRegistrationResult() {
   registration_id_.clear();
-  registration_result_ = GCMClient::UNKNOWN_ERROR;
+  registration_result_ = RESULT_UNKNOWN_ERROR;
 }
 
 void TestGCMServiceWrapper::ClearUnregistrationResult() {
-  unregistration_result_ = GCMClient::UNKNOWN_ERROR;
+  unregistration_result_ = RESULT_UNKNOWN_ERROR;
 }
 
 bool TestGCMServiceWrapper::ServiceHasAppHandlers() const {
   return !service_->app_handlers_.empty();
 }
 
 GCMClientMock* TestGCMServiceWrapper::GetGCMClient() {
   return static_cast<GCMClientMock*>(service_->GetGCMClientForTesting());
 }
 
@@ skipping 33 matching lines @@
   service_->Register(app_id,
                      sender_ids,
                      base::Bind(&TestGCMServiceWrapper::RegisterCompleted,
                                 base::Unretained(this)));
   if (wait_to_finish == WAIT)
     run_loop.Run();
 }
 
 void TestGCMServiceWrapper::Send(const std::string& app_id,
                                  const std::string& receiver_id,
-                                 const GCMClient::OutgoingMessage& message,
+                                 const OutgoingMessage& message,
                                  WaitToFinish wait_to_finish) {
   base::RunLoop run_loop;
   async_operation_completed_callback_ = run_loop.QuitClosure();
   service_->Send(app_id,
                  receiver_id,
                  message,
                  base::Bind(&TestGCMServiceWrapper::SendCompleted,
                             base::Unretained(this)));
   if (wait_to_finish == WAIT)
     run_loop.Run();
@@ skipping 11 matching lines @@
 }
 
 void TestGCMServiceWrapper::WaitForAsyncOperation() {
   base::RunLoop run_loop;
   async_operation_completed_callback_ = run_loop.QuitClosure();
   run_loop.Run();
 }
 
 void TestGCMServiceWrapper::RegisterCompleted(
     const std::string& registration_id,
-    GCMClient::Result result) {
+    Result result) {
   registration_id_ = registration_id;
   registration_result_ = result;
   if (!async_operation_completed_callback_.is_null())
     async_operation_completed_callback_.Run();
 }
 
 void TestGCMServiceWrapper::SendCompleted(const std::string& message_id,
-                                          GCMClient::Result result) {
+                                          Result result) {
   send_message_id_ = message_id;
   send_result_ = result;
   if (!async_operation_completed_callback_.is_null())
     async_operation_completed_callback_.Run();
 }
 
-void TestGCMServiceWrapper::UnregisterCompleted(GCMClient::Result result) {
+void TestGCMServiceWrapper::UnregisterCompleted(Result result) {
   unregistration_result_ = result;
   if (!async_operation_completed_callback_.is_null())
     async_operation_completed_callback_.Run();
 }
 
 class GCMServiceTest : public testing::Test {
  protected:
   GCMServiceTest();
   virtual ~GCMServiceTest();
 
@@ skipping 153 matching lines @@
 }
 
 TEST_F(GCMServiceTest, RegisterWhenNotSignedIn) {
   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
 
   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());
+  EXPECT_EQ(RESULT_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_->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());
 
   // 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());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceTest, SendWhenNotSignedIn) {
   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_LOADING);
 
-  GCMClient::OutgoingMessage message;
+  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());
+  EXPECT_EQ(RESULT_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_->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;
+  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());
 
   // Sending should succeed.
   EXPECT_EQ(message.id, wrapper_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->send_result());
 }
 
 // Tests a single instance of GCMService.
 class GCMServiceSingleInstanceTest : public GCMServiceTest {
  public:
   GCMServiceSingleInstanceTest();
   virtual ~GCMServiceSingleInstanceTest();
 
   // GCMServiceTest:
   virtual void SetUp() OVERRIDE;
@@ skipping 16 matching lines @@
 }
 
 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);
 
   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, RegisterError) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1@error");
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 
   EXPECT_TRUE(wrapper_->registration_id().empty());
-  EXPECT_NE(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_NE(RESULT_SUCCESS, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, RegisterAgainWithSameSenderIDs) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   sender_ids.push_back("sender2");
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
   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());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 
   // Clears the results the would be set by the Register callback in preparation
   // to call register 2nd time.
   wrapper_->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");
   wrapper_->Register(kTestAppID1,
                      another_sender_ids,
                      TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, RegisterAgainWithDifferentSenderIDs) {
   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);
 
   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 
   // Make sender IDs different.
   sender_ids.push_back("sender2");
   const std::string expected_registration_id2 =
       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
 
   // 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());
+  EXPECT_EQ(RESULT_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_->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();
   EXPECT_TRUE(wrapper_->registration_id().empty());
-  EXPECT_EQ(GCMClient::UNKNOWN_ERROR, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_UNKNOWN_ERROR, wrapper_->registration_result());
 
   // Register operation will be invoked after GCMClient becomes ready.
   wrapper_->GetGCMClient()->PerformDelayedLoading();
   wrapper_->WaitForAsyncOperation();
   EXPECT_FALSE(wrapper_->registration_id().empty());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, RegisterAfterSignOut) {
   // This will trigger check-out.
   wrapper_->SignOut();
 
   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());
+  EXPECT_EQ(RESULT_NOT_SIGNED_IN, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, UnregisterExplicitly) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 
   EXPECT_FALSE(wrapper_->registration_id().empty());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 
   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::WAIT);
 
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->unregistration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->unregistration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, UnregisterWhenAsyncOperationPending) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   // First start registration without waiting for it to complete.
   wrapper_->Register(kTestAppID1,
                      sender_ids,
                      TestGCMServiceWrapper::DO_NOT_WAIT);
 
   // Test that unregistration fails with async operation pending when there is a
   // registration already in progress.
   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::WAIT);
-  EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
+  EXPECT_EQ(RESULT_ASYNC_OPERATION_PENDING,
             wrapper_->unregistration_result());
 
   // Complete the unregistration.
   wrapper_->WaitForAsyncOperation();
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 
   // Start unregistration without waiting for it to complete. This time no async
   // operation is pending.
   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::DO_NOT_WAIT);
 
   // Test that unregistration fails with async operation pending when there is
   // an unregistration already in progress.
   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::WAIT);
-  EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
+  EXPECT_EQ(RESULT_ASYNC_OPERATION_PENDING,
             wrapper_->unregistration_result());
   wrapper_->ClearUnregistrationResult();
 
   // Complete unregistration.
   wrapper_->WaitForAsyncOperation();
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->unregistration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->unregistration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, RegisterWhenAsyncOperationPending) {
   std::vector<std::string> sender_ids;
   sender_ids.push_back("sender1");
   // First start registration without waiting for it to complete.
   wrapper_->Register(kTestAppID1,
                      sender_ids,
                      TestGCMServiceWrapper::DO_NOT_WAIT);
 
   // Test that registration fails with async operation pending when there is a
   // registration already in progress.
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
-  EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
+  EXPECT_EQ(RESULT_ASYNC_OPERATION_PENDING,
             wrapper_->registration_result());
   wrapper_->ClearRegistrationResult();
 
   // Complete the registration.
   wrapper_->WaitForAsyncOperation();
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 
   // Start unregistration without waiting for it to complete. This time no async
   // operation is pending.
   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::DO_NOT_WAIT);
 
   // Test that registration fails with async operation pending when there is an
   // unregistration already in progress.
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
-  EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
+  EXPECT_EQ(RESULT_ASYNC_OPERATION_PENDING,
             wrapper_->registration_result());
 
   // Complete the first unregistration expecting success.
   wrapper_->WaitForAsyncOperation();
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->unregistration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->unregistration_result());
 
   // Test that it is ok to register again after unregistration.
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, Send) {
-  GCMClient::OutgoingMessage message;
+  OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   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());
+  EXPECT_EQ(RESULT_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_->SignIn(kTestAccountID1);
 
   // The sending is on hold until GCMClient is ready.
-  GCMClient::OutgoingMessage message;
+  OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   message.data["key2"] = "value2";
   wrapper_->Send(kTestAppID1,
                  kUserID1,
                  message,
                  TestGCMServiceWrapper::DO_NOT_WAIT);
   PumpIOLoop();
   PumpUILoop();
 
   EXPECT_TRUE(wrapper_->send_message_id().empty());
-  EXPECT_EQ(GCMClient::UNKNOWN_ERROR, wrapper_->send_result());
+  EXPECT_EQ(RESULT_UNKNOWN_ERROR, wrapper_->send_result());
 
   // Send operation will be invoked after GCMClient becomes ready.
   wrapper_->GetGCMClient()->PerformDelayedLoading();
   wrapper_->WaitForAsyncOperation();
   EXPECT_EQ(message.id, wrapper_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->send_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, SendAfterSignOut) {
   // This will trigger check-out.
   wrapper_->SignOut();
 
-  GCMClient::OutgoingMessage message;
+  OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   message.data["key2"] = "value2";
   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 
   EXPECT_TRUE(wrapper_->send_message_id().empty());
-  EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->send_result());
+  EXPECT_EQ(RESULT_NOT_SIGNED_IN, wrapper_->send_result());
 }
 
 TEST_F(GCMServiceSingleInstanceTest, SendError) {
-  GCMClient::OutgoingMessage message;
+  OutgoingMessage message;
   // Embedding error in id will tell the mock to simulate the send error.
   message.id = "1@error";
   message.data["key1"] = "value1";
   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());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->send_result());
 
   // Wait for the send error.
   wrapper_->gcm_app_handler()->WaitForNotification();
   EXPECT_EQ(FakeGCMAppHandler::SEND_ERROR_EVENT,
             wrapper_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
   EXPECT_EQ(message.id,
             wrapper_->gcm_app_handler()->send_error_details().message_id);
-  EXPECT_NE(GCMClient::SUCCESS,
+  EXPECT_NE(RESULT_SUCCESS,
             wrapper_->gcm_app_handler()->send_error_details().result);
   EXPECT_EQ(message.data,
             wrapper_->gcm_app_handler()->send_error_details().additional_data);
 }
 
 TEST_F(GCMServiceSingleInstanceTest, MessageReceived) {
   wrapper_->Register(kTestAppID1,
                      ToSenderList("sender"),
                      TestGCMServiceWrapper::WAIT);
-  GCMClient::IncomingMessage message;
+  IncomingMessage message;
   message.data["key1"] = "value1";
   message.data["key2"] = "value2";
   message.sender_id = "sender";
   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, message);
   wrapper_->gcm_app_handler()->WaitForNotification();
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
   EXPECT_EQ(message.data, wrapper_->gcm_app_handler()->message().data);
   EXPECT_TRUE(wrapper_->gcm_app_handler()->message().collapse_key.empty());
   EXPECT_EQ(message.sender_id,
             wrapper_->gcm_app_handler()->message().sender_id);
 }
 
 TEST_F(GCMServiceSingleInstanceTest, MessageWithCollapseKeyReceived) {
   wrapper_->Register(kTestAppID1,
                      ToSenderList("sender"),
                      TestGCMServiceWrapper::WAIT);
-  GCMClient::IncomingMessage message;
+  IncomingMessage message;
   message.data["key1"] = "value1";
   message.collapse_key = "collapse_key_value";
   message.sender_id = "sender";
   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, message);
   wrapper_->gcm_app_handler()->WaitForNotification();
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
   EXPECT_EQ(message.data, wrapper_->gcm_app_handler()->message().data);
   EXPECT_EQ(message.collapse_key,
@@ skipping 55 matching lines @@
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 
   // Register the same app in a different instance.
   std::vector<std::string> sender_ids2;
   sender_ids2.push_back("foo");
   sender_ids2.push_back("bar");
   wrapper2_->Register(kTestAppID1, sender_ids2, TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids),
             wrapper_->registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 
   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids2),
             wrapper2_->registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper2_->registration_result());
 
   // Register a different app in a different instance.
   std::vector<std::string> sender_ids3;
   sender_ids3.push_back("sender1");
   sender_ids3.push_back("sender2");
   sender_ids3.push_back("sender3");
   wrapper2_->Register(kTestAppID2, sender_ids3, TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids3),
             wrapper2_->registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper2_->registration_result());
 }
 
 TEST_F(GCMServiceMultipleInstanceTest, Send) {
   // Send a message from one app in one instance.
-  GCMClient::OutgoingMessage message;
+  OutgoingMessage message;
   message.id = "1";
   message.data["key1"] = "value1";
   message.data["key2"] = "value2";
   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 
   // Send a message from same app in another instance.
-  GCMClient::OutgoingMessage message2;
+  OutgoingMessage message2;
   message2.id = "2";
   message2.data["foo"] = "bar";
   wrapper2_->Send(kTestAppID1, kUserID2, message2, TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(message.id, wrapper_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->send_result());
 
   EXPECT_EQ(message2.id, wrapper2_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper2_->send_result());
 
   // Send another message from different app in another instance.
-  GCMClient::OutgoingMessage message3;
+  OutgoingMessage message3;
   message3.id = "3";
   message3.data["hello"] = "world";
   wrapper2_->Send(kTestAppID2, kUserID1, message3, TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(message3.id, wrapper2_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper2_->send_result());
 }
 
 TEST_F(GCMServiceMultipleInstanceTest, MessageReceived) {
   wrapper_->Register(kTestAppID1,
                      ToSenderList("sender"),
                      TestGCMServiceWrapper::WAIT);
   wrapper2_->Register(kTestAppID1,
                       ToSenderList("sender"),
                       TestGCMServiceWrapper::WAIT);
   wrapper2_->Register(kTestAppID2,
                       ToSenderList("sender2"),
                       TestGCMServiceWrapper::WAIT);
 
   // Trigger an incoming message for an app in one instance.
-  GCMClient::IncomingMessage message;
+  IncomingMessage message;
   message.data["key1"] = "value1";
   message.data["key2"] = "value2";
   message.sender_id = "sender";
   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, message);
   wrapper_->gcm_app_handler()->WaitForNotification();
 
   // Trigger an incoming message for the same app in another instance.
-  GCMClient::IncomingMessage message2;
+  IncomingMessage message2;
   message2.data["foo"] = "bar";
   message2.sender_id = "sender";
   wrapper2_->GetGCMClient()->ReceiveMessage(kTestAppID1, message2);
   wrapper2_->gcm_app_handler()->WaitForNotification();
 
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
   EXPECT_EQ(message.data, wrapper_->gcm_app_handler()->message().data);
   EXPECT_EQ("sender", wrapper_->gcm_app_handler()->message().sender_id);
 
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper2_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, wrapper2_->gcm_app_handler()->app_id());
   EXPECT_EQ(message2.data, wrapper2_->gcm_app_handler()->message().data);
   EXPECT_EQ("sender", wrapper2_->gcm_app_handler()->message().sender_id);
 
   // Trigger another incoming message for a different app in another instance.
-  GCMClient::IncomingMessage message3;
+  IncomingMessage message3;
   message3.data["bar1"] = "foo1";
   message3.data["bar2"] = "foo2";
   message3.sender_id = "sender2";
   wrapper2_->GetGCMClient()->ReceiveMessage(kTestAppID2, message3);
   wrapper2_->gcm_app_handler()->WaitForNotification();
 
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper2_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID2, wrapper2_->gcm_app_handler()->app_id());
   EXPECT_EQ(message3.data, wrapper2_->gcm_app_handler()->message().data);
@@ skipping 25 matching lines @@
 
   // Register a different app in a different instance.
   std::vector<std::string> sender_ids3;
   sender_ids3.push_back("sender1");
   sender_ids3.push_back("sender2");
   sender_ids3.push_back("sender3");
   wrapper2_->Register(kTestAppID2, sender_ids3, TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids),
             wrapper_->registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->registration_result());
 
   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids3),
             wrapper2_->registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->registration_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper2_->registration_result());
 
   // Send a message from one instance.
-  GCMClient::OutgoingMessage out_message;
+  OutgoingMessage out_message;
   out_message.id = "1";
   out_message.data["out1"] = "out_data1";
   out_message.data["out1_2"] = "out_data1_2";
   wrapper_->Send(kTestAppID1,
                  kUserID1,
                  out_message,
                  TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(out_message.id, wrapper_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper_->send_result());
 
   // Trigger an incoming message for an app in one instance.
-  GCMClient::IncomingMessage in_message;
+  IncomingMessage in_message;
   in_message.data["in1"] = "in_data1";
   in_message.data["in1_2"] = "in_data1_2";
   in_message.sender_id = "sender1";
   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, in_message);
   wrapper_->gcm_app_handler()->WaitForNotification();
 
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
   EXPECT_EQ(in_message.data, wrapper_->gcm_app_handler()->message().data);
 
   // Trigger 2 incoming messages, one for each app respectively, in another
   // instance.
-  GCMClient::IncomingMessage in_message2;
+  IncomingMessage in_message2;
   in_message2.data["in2"] = "in_data2";
   in_message2.sender_id = "sender3";
   wrapper2_->GetGCMClient()->ReceiveMessage(kTestAppID2, in_message2);
 
-  GCMClient::IncomingMessage in_message3;
+  IncomingMessage in_message3;
   in_message3.data["in3"] = "in_data3";
   in_message3.data["in3_2"] = "in_data3_2";
   in_message3.sender_id = "foo";
   wrapper2_->GetGCMClient()->ReceiveMessage(kTestAppID1, in_message3);
 
   wrapper2_->gcm_app_handler()->WaitForNotification();
 
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper2_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID2, wrapper2_->gcm_app_handler()->app_id());
   EXPECT_EQ(in_message2.data, wrapper2_->gcm_app_handler()->message().data);
 
   wrapper2_->gcm_app_handler()->WaitForNotification();
 
   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
             wrapper2_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, wrapper2_->gcm_app_handler()->app_id());
   EXPECT_EQ(in_message3.data, wrapper2_->gcm_app_handler()->message().data);
 
   // Send two messages, one for each app respectively, from another instance.
-  GCMClient::OutgoingMessage out_message2;
+  OutgoingMessage out_message2;
   out_message2.id = "2";
   out_message2.data["out2"] = "out_data2";
   wrapper2_->Send(kTestAppID1,
                   kUserID2,
                   out_message2,
                   TestGCMServiceWrapper::WAIT);
 
-  GCMClient::OutgoingMessage out_message3;
+  OutgoingMessage out_message3;
   out_message3.id = "3";
   out_message3.data["out3"] = "out_data3";
   wrapper2_->Send(kTestAppID2,
                   kUserID2,
                   out_message3,
                   TestGCMServiceWrapper::DO_NOT_WAIT);
 
   EXPECT_EQ(out_message2.id, wrapper2_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper2_->send_result());
 
   wrapper2_->WaitForAsyncOperation();
 
   EXPECT_EQ(out_message3.id, wrapper2_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper2_->send_result());
 
   // Sign out of one instance.
   wrapper_->SignOut();
 
   // Register/send stops working for signed-out instance.
   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
   EXPECT_TRUE(wrapper_->registration_id().empty());
-  EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->registration_result());
+  EXPECT_EQ(RESULT_NOT_SIGNED_IN, wrapper_->registration_result());
 
   wrapper_->Send(kTestAppID2,
                  kUserID2,
                  out_message3,
                  TestGCMServiceWrapper::WAIT);
   EXPECT_TRUE(wrapper_->send_message_id().empty());
-  EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->send_result());
+  EXPECT_EQ(RESULT_NOT_SIGNED_IN, wrapper_->send_result());
 
   // Deleted messages event will go through for another signed-in instance.
   wrapper2_->GetGCMClient()->DeleteMessages(kTestAppID2);
   wrapper2_->gcm_app_handler()->WaitForNotification();
 
   EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT,
             wrapper2_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID2, wrapper2_->gcm_app_handler()->app_id());
 
   // Send error event will go through for another signed-in instance.
-  GCMClient::OutgoingMessage out_message4;
+  OutgoingMessage out_message4;
   out_message4.id = "1@error";
   out_message4.data["out4"] = "out_data4";
   wrapper2_->Send(kTestAppID1,
                   kUserID1,
                   out_message4,
                   TestGCMServiceWrapper::WAIT);
 
   EXPECT_EQ(out_message4.id, wrapper2_->send_message_id());
-  EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
+  EXPECT_EQ(RESULT_SUCCESS, wrapper2_->send_result());
 
   wrapper2_->gcm_app_handler()->WaitForNotification();
   EXPECT_EQ(FakeGCMAppHandler::SEND_ERROR_EVENT,
             wrapper2_->gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, wrapper2_->gcm_app_handler()->app_id());
   EXPECT_EQ(out_message4.id,
             wrapper2_->gcm_app_handler()->send_error_details().message_id);
-  EXPECT_NE(GCMClient::SUCCESS,
+  EXPECT_NE(RESULT_SUCCESS,
             wrapper2_->gcm_app_handler()->send_error_details().result);
   EXPECT_EQ(out_message4.data,
             wrapper2_->gcm_app_handler()->send_error_details().additional_data);
 
   // Sign in with a different account.
   wrapper_->SignIn(kTestAccountID3);
 
   // Signing out cleared all registrations, so we need to register again.
   wrapper_->Register(kTestAppID1,
                      ToSenderList("sender1"),
                      TestGCMServiceWrapper::WAIT);
 
   // Incoming message will go through for the new signed-in account.
-  GCMClient::IncomingMessage in_message5;
+  IncomingMessage in_message5;
   in_message5.data["in5"] = "in_data5";
   in_message5.sender_id = "sender1";
   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