Adds an observer for the request coordinator.

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"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/offline_pages/background/device_conditions.h"
 #include "components/offline_pages/background/offliner.h"
 #include "components/offline_pages/background/request_coordinator_event_logger.h"
 #include "components/offline_pages/background/request_queue.h"
 #include "components/offline_pages/background/scheduler.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
 
 struct ClientId;
 class OfflinerPolicy;
 class OfflinerFactory;
 class Offliner;
 class RequestPicker;
 class SavePageRequest;
 class Scheduler;
 
 // Coordinates queueing and processing save page later requests.
 class RequestCoordinator : public KeyedService {
  public:
+  // Status to return for failed notifications.
+  enum class SavePageStatus {
+    SUCCESS,
+    PRERENDER_FAILURE,
+    FOREGROUND_CANCELED,
+    SAVE_FAILED,
+    EXPIRED,
+    RETRY_COUNT_EXCEEDED,
+    REMOVED_BY_CLIENT,
+  };
+
+  // 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 void OnAdded(const SavePageRequest& request) = 0;
+    virtual void OnSucceeded(const SavePageRequest& request) = 0;
+    virtual void OnFailed(const SavePageRequest& request,
+                          SavePageStatus status) = 0;
+    virtual void OnChanged(const SavePageRequest& request) = 0;
+    virtual void OnRemoved(const SavePageRequest& request,
+                           SavePageStatus status) = 0;
+    // TODO(petewil): Merge OnSucceeded, OnFailed, and OnRemoved into a single
+    // call.
+  };
+
   // Callback to report when the processing of a triggered task is complete.
   typedef base::Callback<void(const SavePageRequest& request)>
       RequestPickedCallback;
   typedef base::Callback<void()> RequestQueueEmptyCallback;
 
   RequestCoordinator(std::unique_ptr<OfflinerPolicy> policy,
                      std::unique_ptr<OfflinerFactory> factory,
                      std::unique_ptr<RequestQueue> queue,
                      std::unique_ptr<Scheduler> scheduler);
 
@@ skipping 38 matching lines @@
   // is stopped or complete.
   void StopProcessing();
 
   const Scheduler::TriggerConditions GetTriggerConditionsForUserRequest();
 
   // A way for tests to set the callback in use when an operation is over.
   void SetProcessingCallbackForTest(const base::Callback<void(bool)> callback) {
     scheduler_callback_ = callback;
   }
 
+  // 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);
+
   // 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(); }
 
   // Returns the status of the most recent offlining.
   Offliner::RequestStatus last_offlining_status() {
     return last_offlining_status_;
   }
@@ skipping 20 matching lines @@
                                  const std::vector<SavePageRequest>& requests);
 
   // Receives the result of add requests to the request queue.
   void AddRequestResultCallback(RequestQueue::AddRequestResult result,
                                 const SavePageRequest& request);
 
   // Receives the result of update and delete requests to the request queue.
   void UpdateRequestCallback(const ClientId& client_id,
                              RequestQueue::UpdateRequestResult result);
 
-  void UpdateMultipleRequestCallback(RequestQueue::UpdateRequestResult result);
+  void UpdateMultipleRequestsCallback(
+      const RequestQueue::UpdateMultipleRequestResults& result,
+      const std::vector<SavePageRequest>& requests);
 
   void RemoveRequestsCallback(
-      const RequestQueue::UpdateMultipleRequestResults& results);
+      const RequestQueue::UpdateMultipleRequestResults& results,
+      const std::vector<SavePageRequest>& requests);
 
   // Callback from the request picker when it has chosen our next request.
   void RequestPicked(const SavePageRequest& request);
 
   // Callback from the request picker when no more requests are in the queue.
   void RequestQueueEmpty();
 
   void SendRequestToOffliner(const SavePageRequest& request);
 
   // Called by the offliner when an offlining request is completed. (and by
   // tests).
   void OfflinerDoneCallback(const SavePageRequest& request,
                             Offliner::RequestStatus status);
 
   void TryNextRequest();
 
+  void NotifyAdded(const SavePageRequest& request);
+  void NotifySucceeded(const SavePageRequest& request);
+  void NotifyFailed(const SavePageRequest& request, SavePageStatus status);
+  void NotifyChanged(const SavePageRequest& request);
+  void NotifyRemoved(const SavePageRequest& request);
+
   // Returns the appropriate offliner to use, getting a new one from the factory
   // if needed.
   void GetOffliner();
 
   void SetOfflinerTimeoutForTest(const base::TimeDelta& timeout) {
     offliner_timeout_ = timeout;
   }
 
   void SetDeviceConditionsForTest(DeviceConditions& current_conditions) {
     current_conditions_.reset(new DeviceConditions(current_conditions));
   }
 
   friend class RequestCoordinatorTest;
 
   // The offliner can only handle one request at a time - if the offliner is
   // busy, prevent other requests.  This flag marks whether the offliner is in
   // use.
   bool is_busy_;
   // True if the current request has been canceled.
   bool is_canceled_;
   // Unowned pointer to the current offliner, if any.
   Offliner* offliner_;
   base::Time operation_start_time_;
+  // The observers.
+  base::ObserverList<Observer> observers_;
   // Last known conditions for network, battery
   std::unique_ptr<DeviceConditions> current_conditions_;
   // RequestCoordinator takes over ownership of the policy
   std::unique_ptr<OfflinerPolicy> policy_;
   // OfflinerFactory.  Used to create offline pages. Owned.
   std::unique_ptr<OfflinerFactory> factory_;
   // RequestQueue.  Used to store incoming requests. Owned.
   std::unique_ptr<RequestQueue> queue_;
   // Scheduler. Used to request a callback when network is available.  Owned.
   std::unique_ptr<Scheduler> scheduler_;
@@ skipping 13 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_