Extract GCMClient data types into separate gcm_types.h

google_apis/gcm/gcm_client_impl.cc

 // Copyright 2013 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 "google_apis/gcm/gcm_client_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 67 matching lines @@
 
 const int kMaxRegistrationRetries = 5;
 const char kMessageTypeDataMessage[] = "gcm";
 const char kMessageTypeDeletedMessagesKey[] = "deleted_messages";
 const char kMessageTypeKey[] = "message_type";
 const char kMessageTypeSendErrorKey[] = "send_error";
 const char kSendErrorMessageIdKey[] = "google.message_id";
 const char kSendMessageFromValue[] = "gcm@chrome.com";
 const int64 kDefaultUserSerialNumber = 0LL;
 
-GCMClient::Result ToGCMClientResult(MCSClient::MessageSendStatus status) {
+Result ToGCMClientResult(MCSClient::MessageSendStatus status) {
   switch (status) {
     case MCSClient::QUEUED:
-      return GCMClient::SUCCESS;
+      return RESULT_SUCCESS;
     case MCSClient::QUEUE_SIZE_LIMIT_REACHED:
-      return GCMClient::NETWORK_ERROR;
+      return RESULT_NETWORK_ERROR;
     case MCSClient::APP_QUEUE_SIZE_LIMIT_REACHED:
-      return GCMClient::NETWORK_ERROR;
+      return RESULT_NETWORK_ERROR;
     case MCSClient::MESSAGE_TOO_LARGE:
-      return GCMClient::INVALID_PARAMETER;
+      return RESULT_INVALID_PARAMETER;
     case MCSClient::NO_CONNECTION_ON_ZERO_TTL:
-      return GCMClient::NETWORK_ERROR;
+      return RESULT_NETWORK_ERROR;
     case MCSClient::TTL_EXCEEDED:
-      return GCMClient::NETWORK_ERROR;
+      return RESULT_NETWORK_ERROR;
     case MCSClient::SENT:
     default:
       NOTREACHED();
       break;
   }
-  return GCMClientImpl::UNKNOWN_ERROR;
+  return RESULT_UNKNOWN_ERROR;
 }
 
 MessageType DecodeMessageType(const std::string& value) {
   if (kMessageTypeDeletedMessagesKey == value)
     return DELETED_MESSAGES;
   if (kMessageTypeSendErrorKey == value)
     return SEND_ERROR;
   if (kMessageTypeDataMessage == value)
     return DATA_MESSAGE;
   return UNKNOWN;
@@ skipping 304 matching lines @@
                              const std::vector<std::string>& sender_ids) {
   DCHECK_EQ(state_, READY);
 
   // If the same sender ids is provided, return the cached registration ID
   // directly.
   RegistrationInfoMap::const_iterator registrations_iter =
       registrations_.find(app_id);
   if (registrations_iter != registrations_.end() &&
       registrations_iter->second->sender_ids == sender_ids) {
     delegate_->OnRegisterFinished(
-        app_id, registrations_iter->second->registration_id, SUCCESS);
+        app_id, registrations_iter->second->registration_id, RESULT_SUCCESS);
     return;
   }
 
   RegistrationRequest::RequestInfo request_info(
       device_checkin_info_.android_id,
       device_checkin_info_.secret,
       app_id,
       sender_ids);
   DCHECK_EQ(0u, pending_registration_requests_.count(app_id));
 
@@ skipping 16 matching lines @@
     const std::string& app_id,
     const std::vector<std::string>& sender_ids,
     RegistrationRequest::Status status,
     const std::string& registration_id) {
   DCHECK(delegate_);
 
   Result result;
   PendingRegistrationRequests::iterator iter =
       pending_registration_requests_.find(app_id);
   if (iter == pending_registration_requests_.end())
-    result = UNKNOWN_ERROR;
+    result = RESULT_UNKNOWN_ERROR;
   else if (status == RegistrationRequest::INVALID_SENDER)
-    result = INVALID_PARAMETER;
+    result = RESULT_INVALID_PARAMETER;
   else if (registration_id.empty())
-    result = SERVER_ERROR;
+    result = RESULT_SERVER_ERROR;
   else
-    result = SUCCESS;
+    result = RESULT_SUCCESS;
 
-  if (result == SUCCESS) {
+  if (result == RESULT_SUCCESS) {
     // Cache it.
     linked_ptr<RegistrationInfo> registration(new RegistrationInfo);
     registration->sender_ids = sender_ids;
     registration->registration_id = registration_id;
     registrations_[app_id] = registration;
 
     // Save it in the persistent store.
     gcm_store_->AddRegistration(
         app_id,
         registration,
         base::Bind(&GCMClientImpl::UpdateRegistrationCallback,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   delegate_->OnRegisterFinished(
-      app_id, result == SUCCESS ? registration_id : std::string(), result);
+      app_id,
+      result == RESULT_SUCCESS ? registration_id : std::string(),
+      result);
 
   if (iter != pending_registration_requests_.end()) {
     delete iter->second;
     pending_registration_requests_.erase(iter);
   }
 }
 
 void GCMClientImpl::Unregister(const std::string& app_id) {
   DCHECK_EQ(state_, READY);
   if (pending_unregistration_requests_.count(app_id) == 1)
@@ skipping 25 matching lines @@
   unregistration_request->Start();
 }
 
 void GCMClientImpl::OnUnregisterCompleted(
     const std::string& app_id,
     UnregistrationRequest::Status status) {
   DVLOG(1) << "Unregister completed for app: " << app_id
            << " with " << (status ? "success." : "failure.");
   delegate_->OnUnregisterFinished(
       app_id,
-      status == UnregistrationRequest::SUCCESS ? SUCCESS : SERVER_ERROR);
+      status == UnregistrationRequest::SUCCESS ? RESULT_SUCCESS
+                                               : RESULT_SERVER_ERROR);
 
   PendingUnregistrationRequests::iterator iter =
       pending_unregistration_requests_.find(app_id);
   if (iter == pending_unregistration_requests_.end())
     return;
 
   delete iter->second;
   pending_unregistration_requests_.erase(iter);
 }
 
@@ skipping 104 matching lines @@
   // than |OnSendFinished|. SendErrorDetails.additional_data is left empty.
   // All other errors will be raised immediately, through asynchronous callback.
   // It is expected that TTL_EXCEEDED will be issued for a message that was
   // previously issued |OnSendFinished| with status SUCCESS.
   // For now, we do not report that the message has been sent and acked
   // successfully.
   // TODO(jianli): Consider adding UMA for this status.
   if (status == MCSClient::TTL_EXCEEDED) {
     SendErrorDetails send_error_details;
     send_error_details.message_id = message_id;
-    send_error_details.result = GCMClient::TTL_EXCEEDED;
+    send_error_details.result = RESULT_TTL_EXCEEDED;
     delegate_->OnMessageSendError(app_id, send_error_details);
   } else if (status != MCSClient::SENT) {
     delegate_->OnSendFinished(app_id, message_id, ToGCMClientResult(status));
   }
 }
 
 void GCMClientImpl::OnMCSError() {
   // TODO(fgorski): For now it replaces the initialization method. Long term it
   // should have an error or status passed in.
 }
@@ skipping 71 matching lines @@
     incoming_message.collapse_key = data_message_stanza.token();
   incoming_message.data = message_data;
   delegate_->OnMessageReceived(app_id, incoming_message);
 }
 
 void GCMClientImpl::HandleIncomingSendError(
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
   SendErrorDetails send_error_details;
   send_error_details.additional_data = message_data;
-  send_error_details.result = SERVER_ERROR;
+  send_error_details.result = RESULT_SERVER_ERROR;
 
   MessageData::iterator iter =
       send_error_details.additional_data.find(kSendErrorMessageIdKey);
   if (iter != send_error_details.additional_data.end()) {
     send_error_details.message_id = iter->second;
     send_error_details.additional_data.erase(iter);
   }
 
   recorder_.RecordIncomingSendError(
       data_message_stanza.category(),
       data_message_stanza.to(),
       data_message_stanza.id());
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 }  // namespace gcm