Extract GCMClient data types into separate gcm_types.h

chrome/browser/services/gcm/gcm_service.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 <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 114 matching lines @@
 class GCMService::IOWorker : public GCMClient::Delegate {
  public:
   // Called on UI thread.
   IOWorker();
   virtual ~IOWorker();
 
   // Overridden from GCMClient::Delegate:
   // Called on IO thread.
   virtual void OnRegisterFinished(const std::string& app_id,
                                   const std::string& registration_id,
-                                  GCMClient::Result result) OVERRIDE;
+                                  Result result) OVERRIDE;
   virtual void OnUnregisterFinished(const std::string& app_id,
-                                    GCMClient::Result result) OVERRIDE;
+                                    Result result) OVERRIDE;
   virtual void OnSendFinished(const std::string& app_id,
                               const std::string& message_id,
-                              GCMClient::Result result) OVERRIDE;
+                              Result result) OVERRIDE;
   virtual void OnMessageReceived(
       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 OnMessageSendError(
       const std::string& app_id,
-      const GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
+      const SendErrorDetails& send_error_details) OVERRIDE;
   virtual void OnGCMReady() OVERRIDE;
 
   // Called on IO thread.
   void Initialize(scoped_ptr<GCMClientFactory> gcm_client_factory,
                   const base::FilePath& store_path,
                   const std::vector<std::string>& account_ids,
                   const scoped_refptr<net::URLRequestContextGetter>&
                       url_request_context_getter);
   void Load(const base::WeakPtr<GCMService>& service);
   void Stop();
   void CheckOut();
   void Register(const std::string& app_id,
                 const std::vector<std::string>& sender_ids);
   void Unregister(const std::string& app_id);
   void Send(const std::string& app_id,
             const std::string& receiver_id,
-            const GCMClient::OutgoingMessage& message);
+            const OutgoingMessage& message);
   void GetGCMStatistics(bool clear_logs);
   void SetGCMRecording(bool recording);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
  private:
   base::WeakPtr<GCMService> service_;
 
   scoped_ptr<GCMClient> gcm_client_;
@@ skipping 35 matching lines @@
                           store_path,
                           account_ids,
                           blocking_task_runner,
                           url_request_context_getter,
                           this);
 }
 
 void GCMService::IOWorker::OnRegisterFinished(
     const std::string& app_id,
     const std::string& registration_id,
-    GCMClient::Result result) {
+    Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    FROM_HERE,
                                    base::Bind(&GCMService::RegisterFinished,
                                               service_,
                                               app_id,
                                               registration_id,
                                               result));
 }
 
 void GCMService::IOWorker::OnUnregisterFinished(const std::string& app_id,
-                                                GCMClient::Result result) {
+                                                Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GCMService::UnregisterFinished, service_, app_id, result));
 }
 
 void GCMService::IOWorker::OnSendFinished(const std::string& app_id,
                                           const std::string& message_id,
-                                          GCMClient::Result result) {
+                                          Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    FROM_HERE,
                                    base::Bind(&GCMService::SendFinished,
                                               service_,
                                               app_id,
                                               message_id,
                                               result));
 }
 
 void GCMService::IOWorker::OnMessageReceived(
     const std::string& app_id,
-    const GCMClient::IncomingMessage& message) {
+    const IncomingMessage& message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    FROM_HERE,
                                    base::Bind(&GCMService::MessageReceived,
                                               service_,
                                               app_id,
                                               message));
 }
 
 void GCMService::IOWorker::OnMessagesDeleted(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    FROM_HERE,
                                    base::Bind(&GCMService::MessagesDeleted,
                                               service_,
                                               app_id));
 }
 
 void GCMService::IOWorker::OnMessageSendError(
     const std::string& app_id,
-    const GCMClient::SendErrorDetails& send_error_details) {
+    const SendErrorDetails& send_error_details) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    FROM_HERE,
                                    base::Bind(&GCMService::MessageSendError,
                                               service_,
                                               app_id,
                                               send_error_details));
 }
 
@@ skipping 35 matching lines @@
 }
 
 void GCMService::IOWorker::Unregister(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->Unregister(app_id);
 }
 
 void GCMService::IOWorker::Send(const std::string& app_id,
                                 const std::string& receiver_id,
-                                const GCMClient::OutgoingMessage& message) {
+                                const OutgoingMessage& message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->Send(app_id, receiver_id, message);
 }
 
 void GCMService::IOWorker::GetGCMStatistics(bool clear_logs) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  gcm::GCMClient::GCMStatistics stats;
+  GCMClient::GCMStatistics stats;
 
   if (gcm_client_.get()) {
     if (clear_logs)
       gcm_client_->ClearActivityLogs();
     stats = gcm_client_->GetStatistics();
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GCMService::GetGCMStatisticsFinished, service_, stats));
 }
 
 void GCMService::IOWorker::SetGCMRecording(bool recording) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  gcm::GCMClient::GCMStatistics stats;
+  GCMClient::GCMStatistics stats;
 
   if (gcm_client_.get()) {
     gcm_client_->SetRecording(recording);
     stats = gcm_client_->GetStatistics();
     stats.gcm_client_created = true;
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
@@ skipping 91 matching lines @@
 }
 
 void GCMService::Register(const std::string& app_id,
                           const std::vector<std::string>& sender_ids,
                           RegisterCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty());
   DCHECK(!sender_ids.empty());
   DCHECK(!callback.is_null());
 
-  GCMClient::Result result = EnsureAppReady(app_id);
-  if (result != GCMClient::SUCCESS) {
+  Result result = EnsureAppReady(app_id);
+  if (result != RESULT_SUCCESS) {
     callback.Run(std::string(), result);
     return;
   }
 
   // If previous un/register operation is still in progress, bail out.
   if (IsAsyncOperationPending(app_id)) {
-    callback.Run(std::string(), GCMClient::ASYNC_OPERATION_PENDING);
+    callback.Run(std::string(), RESULT_ASYNC_OPERATION_PENDING);
     return;
   }
 
   register_callbacks_[app_id] = callback;
 
   // Delay the register operation until GCMClient is ready.
   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
     delayed_task_controller_->AddTask(base::Bind(&GCMService::DoRegister,
                                                  weak_ptr_factory_.GetWeakPtr(),
                                                  app_id,
@@ skipping 26 matching lines @@
                  app_id,
                  normalized_sender_ids));
 }
 
 void GCMService::Unregister(const std::string& app_id,
                             UnregisterCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty());
   DCHECK(!callback.is_null());
 
-  GCMClient::Result result = EnsureAppReady(app_id);
-  if (result != GCMClient::SUCCESS) {
+  Result result = EnsureAppReady(app_id);
+  if (result != RESULT_SUCCESS) {
     callback.Run(result);
     return;
   }
 
   // If previous un/register operation is still in progress, bail out.
   if (IsAsyncOperationPending(app_id)) {
-    callback.Run(GCMClient::ASYNC_OPERATION_PENDING);
+    callback.Run(RESULT_ASYNC_OPERATION_PENDING);
     return;
   }
 
   unregister_callbacks_[app_id] = callback;
 
   // Delay the unregister operation until GCMClient is ready.
   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
     delayed_task_controller_->AddTask(base::Bind(&GCMService::DoUnregister,
                                                  weak_ptr_factory_.GetWeakPtr(),
                                                  app_id));
@@ skipping 12 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMService::IOWorker::Unregister,
                  base::Unretained(io_worker_.get()),
                  app_id));
 }
 
 void GCMService::Send(const std::string& app_id,
                       const std::string& receiver_id,
-                      const GCMClient::OutgoingMessage& message,
+                      const OutgoingMessage& message,
                       SendCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty());
   DCHECK(!receiver_id.empty());
   DCHECK(!callback.is_null());
 
-  GCMClient::Result result = EnsureAppReady(app_id);
-  if (result != GCMClient::SUCCESS) {
+  Result result = EnsureAppReady(app_id);
+  if (result != RESULT_SUCCESS) {
     callback.Run(std::string(), result);
     return;
   }
 
   // If the message with send ID is still in progress, bail out.
   std::pair<std::string, std::string> key(app_id, message.id);
   if (send_callbacks_.find(key) != send_callbacks_.end()) {
-    callback.Run(message.id, GCMClient::INVALID_PARAMETER);
+    callback.Run(message.id, RESULT_INVALID_PARAMETER);
     return;
   }
 
   send_callbacks_[key] = callback;
 
   // Delay the send operation until all GCMClient is ready.
   if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
     delayed_task_controller_->AddTask(base::Bind(&GCMService::DoSend,
                                                  weak_ptr_factory_.GetWeakPtr(),
                                                  app_id,
                                                  receiver_id,
                                                  message));
     return;
   }
 
   DoSend(app_id, receiver_id, message);
 }
 
 void GCMService::DoSend(const std::string& app_id,
                         const std::string& receiver_id,
-                        const GCMClient::OutgoingMessage& message) {
+                        const OutgoingMessage& message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMService::IOWorker::Send,
                  base::Unretained(io_worker_.get()),
                  app_id,
                  receiver_id,
                  message));
 }
@@ skipping 99 matching lines @@
 
   RemoveCachedData();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMService::IOWorker::CheckOut,
                  base::Unretained(io_worker_.get())));
 }
 
-GCMClient::Result GCMService::EnsureAppReady(const std::string& app_id) {
+Result GCMService::EnsureAppReady(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // Ensure that check-in has been done.
   EnsureLoaded();
 
   // If the service was not started, bail out.
   if (account_id_.empty())
-    return GCMClient::NOT_SIGNED_IN;
+    return RESULT_NOT_SIGNED_IN;
 
-  return GCMClient::SUCCESS;
+  return RESULT_SUCCESS;
 }
 
 bool GCMService::IsAsyncOperationPending(const std::string& app_id) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   return register_callbacks_.find(app_id) != register_callbacks_.end() ||
          unregister_callbacks_.find(app_id) != unregister_callbacks_.end();
 }
 
 void GCMService::RegisterFinished(const std::string& app_id,
                                   const std::string& registration_id,
-                                  GCMClient::Result result) {
+                                  Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   std::map<std::string, RegisterCallback>::iterator callback_iter =
       register_callbacks_.find(app_id);
   if (callback_iter == register_callbacks_.end()) {
     // The callback could have been removed when the app is uninstalled.
     return;
   }
 
   RegisterCallback callback = callback_iter->second;
   register_callbacks_.erase(callback_iter);
   callback.Run(registration_id, result);
 }
 
 void GCMService::UnregisterFinished(const std::string& app_id,
-                                    GCMClient::Result result) {
+                                    Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   std::map<std::string, UnregisterCallback>::iterator callback_iter =
       unregister_callbacks_.find(app_id);
   if (callback_iter == unregister_callbacks_.end())
     return;
 
   UnregisterCallback callback = callback_iter->second;
   unregister_callbacks_.erase(callback_iter);
   callback.Run(result);
 }
 
 void GCMService::SendFinished(const std::string& app_id,
                               const std::string& message_id,
-                              GCMClient::Result result) {
+                              Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   std::map<std::pair<std::string, std::string>, SendCallback>::iterator
       callback_iter = send_callbacks_.find(
           std::pair<std::string, std::string>(app_id, message_id));
   if (callback_iter == send_callbacks_.end()) {
     // The callback could have been removed when the app is uninstalled.
     return;
   }
 
   SendCallback callback = callback_iter->second;
   send_callbacks_.erase(callback_iter);
   callback.Run(message_id, result);
 }
 
 void GCMService::MessageReceived(const std::string& app_id,
-                                 GCMClient::IncomingMessage message) {
+                                 IncomingMessage message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Drop the event if signed out.
   if (account_id_.empty())
     return;
 
   GetAppHandler(app_id)->OnMessage(app_id, message);
 }
 
 void GCMService::MessagesDeleted(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Drop the event if signed out.
   if (account_id_.empty())
     return;
 
   GetAppHandler(app_id)->OnMessagesDeleted(app_id);
 }
 
 void GCMService::MessageSendError(
     const std::string& app_id,
-    const GCMClient::SendErrorDetails& send_error_details) {
+    const SendErrorDetails& send_error_details) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Drop the event if signed out.
   if (account_id_.empty())
     return;
 
   GetAppHandler(app_id)->OnSendError(app_id, send_error_details);
 }
 
 void GCMService::GCMClientReady() {
@@ skipping 14 matching lines @@
   return iter == app_handlers_.end() ? &default_app_handler_ : iter->second;
 }
 
 void GCMService::GetGCMStatisticsFinished(
     GCMClient::GCMStatistics stats) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   request_gcm_statistics_callback_.Run(stats);
 }
 
 }  // namespace gcm