Rename an Enum to a slightly better name.

components/offline_pages/background/request_coordinator.h

 // 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.
 
 #ifndef COMPONENTS_OFFLINE_PAGES_BACKGROUND_REQUEST_COORDINATOR_H_
 #define COMPONENTS_OFFLINE_PAGES_BACKGROUND_REQUEST_COORDINATOR_H_
 
 #include <memory>
 
 #include "base/callback.h"
@@ skipping 30 matching lines @@
 
   // Nested observer class.  To make sure that no events are missed, the client
   // code should first register for notifications, then |GetAllRequests|, and
   // ignore all events before the return from |GetAllRequests|, and consume
   // events after the return callback from |GetAllRequests|.
   class Observer {
    public:
     virtual ~Observer() = default;
 
     virtual void OnAdded(const SavePageRequest& request) = 0;
-    virtual void OnCompleted(const SavePageRequest& request,
-                             RequestNotifier::SavePageStatus status) = 0;
+    virtual void OnCompleted(
+        const SavePageRequest& request,
+        RequestNotifier::BackgroundSavePageResult status) = 0;
     virtual void OnChanged(const SavePageRequest& request) = 0;
   };
 
   // Callback to report when a request was available.
   typedef base::Callback<void(const SavePageRequest& request)>
       RequestPickedCallback;
   // Callback to report when no request was available.
   typedef base::Callback<void(bool)> RequestNotPickedCallback;
 
   RequestCoordinator(std::unique_ptr<OfflinerPolicy> policy,
@@ skipping 59 matching lines @@
   // Observers implementing the RequestCoordinator::Observer interface can
   // register here to get notifications of changes to request state.  This
   // pointer is not owned, and it is the callers responsibility to remove the
   // observer before the observer is deleted.
   void AddObserver(RequestCoordinator::Observer* observer);
 
   void RemoveObserver(RequestCoordinator::Observer* observer);
 
   // Implement RequestNotifier
   void NotifyAdded(const SavePageRequest& request) override;
-  void NotifyCompleted(const SavePageRequest& request,
-                       RequestNotifier::SavePageStatus status) override;
+  void NotifyCompleted(
+      const SavePageRequest& request,
+      RequestNotifier::BackgroundSavePageResult status) override;
   void NotifyChanged(const SavePageRequest& request) override;
 
   // Returns the request queue used for requests.  Coordinator keeps ownership.
   RequestQueue* queue() { return queue_.get(); }
 
   // Return an unowned pointer to the Scheduler.
   Scheduler* scheduler() { return scheduler_.get(); }
 
   OfflinerPolicy* policy() { return policy_.get(); }
 
@@ skipping 36 matching lines @@
   // Receives the result of update and delete requests to the request queue.
   void UpdateRequestCallback(const ClientId& client_id,
                              RequestQueue::UpdateRequestResult result);
 
   void UpdateMultipleRequestsCallback(
       const RequestQueue::UpdateMultipleRequestResults& result,
       const std::vector<SavePageRequest>& requests);
 
   void HandleRemovedRequestsAndCallback(
       const RemoveRequestsCallback& callback,
-      SavePageStatus status,
+      BackgroundSavePageResult status,
       const RequestQueue::UpdateMultipleRequestResults& results,
       const std::vector<SavePageRequest>& requests);
 
   void HandleRemovedRequests(
-      SavePageStatus status,
+      BackgroundSavePageResult status,
       const RequestQueue::UpdateMultipleRequestResults& results,
       const std::vector<SavePageRequest>& requests);
 
   // Start processing now if connected (but with conservative assumption
   // as to other device conditions).
   void StartProcessingIfConnected();
 
   // Check the request queue, and schedule a task corresponding
   // to the least restrictive type of request in the queue.
   void ScheduleAsNeeded();
@@ skipping 21 matching lines @@
   // If there is an active request in the list, cancel that request.
   bool CancelActiveRequestIfItMatches(const std::vector<int64_t>& request_ids);
 
   // Records an aborted attempt for the request and update it in the queue
   // (possibly removing it). Returns the updated copy.
   void AbortRequestAttempt(SavePageRequest* request);
 
   // Remove the attempted request from the queue with status to pass through to
   // any observers and UMA histogram.
   void RemoveAttemptedRequest(const SavePageRequest& request,
-                              SavePageStatus status);
+                              BackgroundSavePageResult status);
 
   // Returns the appropriate offliner to use, getting a new one from the factory
   // if needed.
   void GetOffliner();
 
   // Method to wrap calls to getting the connection type so it can be
   // changed for tests.
   net::NetworkChangeNotifier::ConnectionType GetConnectionType();
 
   void SetNetworkConditionsForTest(
@@ skipping 53 matching lines @@
   base::TimeDelta offliner_timeout_;
   // Allows us to pass a weak pointer to callbacks.
   base::WeakPtrFactory<RequestCoordinator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestCoordinator);
 };
 
 }  // namespace offline_pages
 
 #endif  // COMPONENTS_OFFLINE_PAGES_BACKGROUND_REQUEST_COORDINATOR_H_