Rename an Enum to a slightly better name.

components/offline_pages/background/request_coordinator.cc

 // Copyright 2016 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 "components/offline_pages/background/request_coordinator.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 31 matching lines @@
       histogram_name, 1,
       static_cast<int>(Offliner::RequestStatus::STATUS_COUNT),
       static_cast<int>(Offliner::RequestStatus::STATUS_COUNT) + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(static_cast<int>(request_status));
 }
 
 // Records the number of started attempts for completed requests (whether
 // successful or not).
 void RecordAttemptCount(const SavePageRequest& request,
-                        RequestNotifier::SavePageStatus status) {
-  if (status == RequestNotifier::SavePageStatus::SUCCESS) {
+                        RequestNotifier::BackgroundSavePageResult status) {
+  if (status == RequestNotifier::BackgroundSavePageResult::SUCCESS) {
     // TODO(dougarnett): Also record UMA for completed attempts here.
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "OfflinePages.Background.RequestSuccess.StartedAttemptCount",
         request.started_attempt_count(), 1, 10, 11);
   } else {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "OfflinePages.Background.RequestFailure.StartedAttemptCount",
         request.started_attempt_count(), 1, 10, 11);
   }
 }
@@ skipping 122 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 void RequestCoordinator::AbortRequestAttempt(SavePageRequest* request) {
   request->MarkAttemptAborted();
   if (request->started_attempt_count() >= policy_->GetMaxStartedTries()) {
-    RemoveAttemptedRequest(*request, SavePageStatus::START_COUNT_EXCEEDED);
+    RemoveAttemptedRequest(*request,
+                           BackgroundSavePageResult::START_COUNT_EXCEEDED);
   } else {
     queue_->UpdateRequest(
         *request,
         base::Bind(&RequestCoordinator::UpdateRequestCallback,
                    weak_ptr_factory_.GetWeakPtr(), request->client_id()));
   }
 }
 
-void RequestCoordinator::RemoveAttemptedRequest(const SavePageRequest& request,
-                                                SavePageStatus status) {
+void RequestCoordinator::RemoveAttemptedRequest(
+    const SavePageRequest& request, BackgroundSavePageResult status) {
   std::vector<int64_t> remove_requests;
   remove_requests.push_back(request.request_id());
   queue_->RemoveRequests(remove_requests,
                          base::Bind(&RequestCoordinator::HandleRemovedRequests,
                                     weak_ptr_factory_.GetWeakPtr(), status));
   RecordAttemptCount(request, status);
 }
 
 void RequestCoordinator::RemoveRequests(
     const std::vector<int64_t>& request_ids,
     const RemoveRequestsCallback& callback) {
   bool canceled = CancelActiveRequestIfItMatches(request_ids);
   queue_->RemoveRequests(
       request_ids,
       base::Bind(&RequestCoordinator::HandleRemovedRequestsAndCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback,
-                 SavePageStatus::REMOVED));
+                 BackgroundSavePageResult::REMOVED));
   if (canceled)
     TryNextRequest();
 }
 
 void RequestCoordinator::PauseRequests(
     const std::vector<int64_t>& request_ids) {
   bool canceled = CancelActiveRequestIfItMatches(request_ids);
   queue_->ChangeRequestsState(
       request_ids, SavePageRequest::RequestState::PAUSED,
       base::Bind(&RequestCoordinator::UpdateMultipleRequestsCallback,
@@ skipping 68 matching lines @@
       }
     }
   }
 
   if (available_user_request)
     StartProcessingIfConnected();
 }
 
 void RequestCoordinator::HandleRemovedRequestsAndCallback(
     const RemoveRequestsCallback& callback,
-    SavePageStatus status,
+    BackgroundSavePageResult status,
     const RequestQueue::UpdateMultipleRequestResults& results,
     const std::vector<SavePageRequest>& requests) {
   callback.Run(results);
   HandleRemovedRequests(status, results, requests);
 }
 
 void RequestCoordinator::HandleRemovedRequests(
-    SavePageStatus status,
+    BackgroundSavePageResult status,
     const RequestQueue::UpdateMultipleRequestResults& results,
     const std::vector<SavePageRequest>& requests) {
   for (SavePageRequest request : requests)
     NotifyCompleted(request, status);
 }
 
 void RequestCoordinator::ScheduleAsNeeded() {
   // Get all requests from queue (there is no filtering mechanism).
   queue_->GetRequests(
       base::Bind(&RequestCoordinator::GetRequestsForSchedulingCallback,
@@ skipping 141 matching lines @@
   is_busy_ = false;
   active_request_.reset(nullptr);
 
   if (status == Offliner::RequestStatus::FOREGROUND_CANCELED ||
       status == Offliner::RequestStatus::PRERENDERING_CANCELED) {
     // Update the request for the canceled attempt.
     // TODO(dougarnett): See if we can conclusively identify other attempt
     // aborted cases to treat this way (eg, for Render Process Killed).
     SavePageRequest updated_request(request);
     AbortRequestAttempt(&updated_request);
-    SavePageStatus notify_status =
+    BackgroundSavePageResult notify_status =
         (status == Offliner::RequestStatus::FOREGROUND_CANCELED)
-            ? SavePageStatus::FOREGROUND_CANCELED
-            : SavePageStatus::PRERENDER_CANCELED;
+            ? BackgroundSavePageResult::FOREGROUND_CANCELED
+            : BackgroundSavePageResult::PRERENDER_CANCELED;
     NotifyCompleted(updated_request, notify_status);
   } else if (status == Offliner::RequestStatus::SAVED) {
     // Remove the request from the queue if it succeeded.
-    RemoveAttemptedRequest(request, SavePageStatus::SUCCESS);
+    RemoveAttemptedRequest(request, BackgroundSavePageResult::SUCCESS);
   } else if (request.completed_attempt_count() + 1 >=
              policy_->GetMaxCompletedTries()) {
     // Remove from the request queue if we exceeded max retries. The +1
     // represents the request that just completed. Since we call
     // MarkAttemptCompleted within the if branches, the completed_attempt_count
     // has not yet been updated when we are checking the if condition.
-    RemoveAttemptedRequest(request, SavePageStatus::RETRY_COUNT_EXCEEDED);
+    RemoveAttemptedRequest(request,
+                           BackgroundSavePageResult::RETRY_COUNT_EXCEEDED);
   } else {
     // If we failed, but are not over the limit, update the request in the
     // queue.
     SavePageRequest updated_request(request);
     updated_request.MarkAttemptCompleted();
     queue_->UpdateRequest(updated_request,
                           base::Bind(&RequestCoordinator::UpdateRequestCallback,
                                      weak_ptr_factory_.GetWeakPtr(),
                                      updated_request.client_id()));
     NotifyChanged(updated_request);
@@ skipping 38 matching lines @@
 
 void RequestCoordinator::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void RequestCoordinator::NotifyAdded(const SavePageRequest& request) {
   FOR_EACH_OBSERVER(Observer, observers_, OnAdded(request));
 }
 
 void RequestCoordinator::NotifyCompleted(const SavePageRequest& request,
-                                         SavePageStatus status) {
+                                         BackgroundSavePageResult status) {
   FOR_EACH_OBSERVER(Observer, observers_, OnCompleted(request, status));
 }
 
 void RequestCoordinator::NotifyChanged(const SavePageRequest& request) {
   FOR_EACH_OBSERVER(Observer, observers_, OnChanged(request));
 }
 
 void RequestCoordinator::GetOffliner() {
   if (!offliner_) {
     offliner_ = factory_->GetOffliner(policy_.get());
   }
 }
 
 }  // namespace offline_pages