Split PushMessagingStatus enum according to use case

chrome/browser/services/gcm/push_messaging_service_impl.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/push_messaging_service_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 114 matching lines @@
     // TODO(mvanouwerkerk): Show a warning in the developer console of the
     // Service Worker corresponding to app_id.
     // TODO(johnme): Add diagnostic observers (e.g. UMA and an internals page)
     // to know when bad things happen.
   }
 }
 
 void PushMessagingServiceImpl::DeliverMessageCallback(
     const PushMessagingApplicationId& application_id,
     const GCMClient::IncomingMessage& message,
-    content::PushMessagingStatus status) {
+    content::PushDeliveryStatus status) {
   // TODO(mvanouwerkerk): UMA logging.
   // TODO(mvanouwerkerk): Is there a way to recover from failure?
 }
 
 void PushMessagingServiceImpl::OnMessagesDeleted(const std::string& app_id) {
   // TODO(mvanouwerkerk): Fire push error event on the Service Worker
   // corresponding to app_id.
 }
 
 void PushMessagingServiceImpl::OnSendError(
@@ skipping 19 matching lines @@
   if (!gcm_profile_service_->driver()) {
     NOTREACHED() << "There is no GCMDriver. Has GCMProfileService shut down?";
   }
 
   PushMessagingApplicationId application_id =
       PushMessagingApplicationId(origin, service_worker_registration_id);
   DCHECK(application_id.IsValid());
 
   if (profile_->GetPrefs()->GetInteger(
           prefs::kPushMessagingRegistrationCount) >= kMaxRegistrations) {
-    RegisterEnd(
-        callback,
-        std::string(),
-        content::PUSH_MESSAGING_STATUS_REGISTRATION_FAILED_LIMIT_REACHED);
+    RegisterEnd(callback,
+                std::string(),
+                content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
     return;
   }
 
   // If this is registering for the first time then the driver does not have
   // this as an app handler and registration would fail.
   if (gcm_profile_service_->driver()->GetAppHandler(
           kPushMessagingApplicationIdPrefix) != this)
     gcm_profile_service_->driver()->AddAppHandler(
         kPushMessagingApplicationIdPrefix, this);
 
@@ skipping 16 matching lines @@
   int bridge_id = -1;
 
   const PermissionRequestID id(
       renderer_id, web_contents->GetRoutingID(), bridge_id, GURL());
 
   GURL embedder = web_contents->GetLastCommittedURL();
   gcm::PushMessagingPermissionContext* permission_context =
       gcm::PushMessagingPermissionContextFactory::GetForProfile(profile_);
 
   if (permission_context == NULL) {
-    RegisterEnd(
-        callback,
-        std::string(),
-        content::PUSH_MESSAGING_STATUS_REGISTRATION_FAILED_PERMISSION_DENIED);
+    RegisterEnd(callback,
+                std::string(),
+                content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   permission_context->RequestPermission(
       web_contents,
       id,
       embedder,
       user_gesture,
       base::Bind(&PushMessagingServiceImpl::DidRequestPermission,
                  weak_factory_.GetWeakPtr(),
                  application_id,
                  sender_id,
                  callback));
 }
 
 void PushMessagingServiceImpl::RegisterEnd(
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& registration_id,
-    content::PushMessagingStatus status) {
+    content::PushRegistrationStatus status) {
   GURL endpoint = GURL("https://android.googleapis.com/gcm/send");
   callback.Run(endpoint, registration_id, status);
-  if (status == content::PUSH_MESSAGING_STATUS_OK) {
+  if (status == content::PUSH_REGISTRATION_STATUS_SUCCESS) {
     // TODO(johnme): Make sure the pref doesn't get out of sync after crashes.
     int registration_count = profile_->GetPrefs()->GetInteger(
         prefs::kPushMessagingRegistrationCount);
     profile_->GetPrefs()->SetInteger(prefs::kPushMessagingRegistrationCount,
                                      registration_count + 1);
   }
 }
 
 void PushMessagingServiceImpl::DidRegister(
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& registration_id,
     GCMClient::Result result) {
-  content::PushMessagingStatus status =
+  content::PushRegistrationStatus status =
       result == GCMClient::SUCCESS
-          ? content::PUSH_MESSAGING_STATUS_OK
-          : content::PUSH_MESSAGING_STATUS_REGISTRATION_FAILED_SERVICE_ERROR;
+          ? content::PUSH_REGISTRATION_STATUS_SUCCESS
+          : content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
   RegisterEnd(callback, registration_id, status);
 }
 
 void PushMessagingServiceImpl::DidRequestPermission(
     const PushMessagingApplicationId& application_id,
     const std::string& sender_id,
     const content::PushMessagingService::RegisterCallback& register_callback,
     bool allow) {
   if (!allow) {
-    RegisterEnd(
-        register_callback,
-        std::string(),
-        content::PUSH_MESSAGING_STATUS_REGISTRATION_FAILED_PERMISSION_DENIED);
+    RegisterEnd(register_callback,
+                std::string(),
+                content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   // The GCMDriver could be NULL if GCMProfileService has been shut down.
   if (!gcm_profile_service_->driver())
     return;
 
   std::vector<std::string> sender_ids(1, sender_id);
 
   gcm_profile_service_->driver()->Register(
       application_id.ToString(),
       sender_ids,
       base::Bind(&PushMessagingServiceImpl::DidRegister,
                  weak_factory_.GetWeakPtr(),
                  register_callback));
 }
 
 // TODO(johnme): Unregister should decrement the pref, and call
 // RemoveAppHandler if the count drops to zero.
 
 }  // namespace gcm