Request Picker task

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 <set>
 #include <string>
@@ skipping 16 matching lines @@
 #include "net/nqe/network_quality_estimator.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
 
 struct ClientId;
 class OfflinerPolicy;
 class OfflinerFactory;
 class Offliner;
 class RequestPicker;
+class RequestQueue;
 class SavePageRequest;
 class Scheduler;
 class ClientPolicyController;
 
 // Coordinates queueing and processing save page later requests.
 class RequestCoordinator : public KeyedService,
                            public RequestNotifier,
                            public base::SupportsUserData {
  public:
   // 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::BackgroundSavePageResult status) = 0;
     virtual void OnChanged(const SavePageRequest& request) = 0;
   };
 
   enum class RequestAvailability {
     ENABLED_FOR_OFFLINER,
     DISABLED_FOR_OFFLINER,
   };
 
-  // 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;
-
   // Callback specifying which request IDs were actually removed.
   typedef base::Callback<void(const MultipleItemStatuses&)>
       RemoveRequestsCallback;
 
   // Callback that receives the response for GetAllRequests.
   typedef base::Callback<void(std::vector<std::unique_ptr<SavePageRequest>>)>
       GetRequestsCallback;
 
   RequestCoordinator(std::unique_ptr<OfflinerPolicy> policy,
                      std::unique_ptr<OfflinerFactory> factory,
@@ skipping 102 matching lines @@
   // Returns whether processing is starting (before it is decided to actually
   // process a request (is_busy()) at this time or not.
   bool is_starting() { return is_starting_; }
 
   // Tracks whether the last offlining attempt got canceled.  This is reset by
   // the next StartProcessing() call.
   bool is_canceled() {
     return processing_state_ == ProcessingWindowState::STOPPED;
   }
 
-  OfflineEventLogger* GetLogger() {
-    return &event_logger_;
-  }
+  RequestCoordinatorEventLogger* GetLogger() { return &event_logger_; }
 
  private:
   // Immediate start attempt status code for UMA.
   // These values are written to logs. New enum values can be added, but
   // existing enums must never be renumbered or deleted and reused.
   // For any additions, also update corresponding histogram in histograms.xml.
   enum OfflinerImmediateStartStatus {
     // Did start processing request.
     STARTED = 0,
     // Already busy processing a request.
@@ skipping 14 matching lines @@
   enum class ProcessingWindowState {
     STOPPED,
     SCHEDULED_WINDOW,
     IMMEDIATE_WINDOW,
   };
 
   // Receives the results of a get from the request queue, and turns that into
   // SavePageRequest objects for the caller of GetQueuedRequests.
   void GetQueuedRequestsCallback(
       const GetRequestsCallback& callback,
-      RequestQueue::GetRequestsResult result,
+      QueueResults::GetRequestsResult result,
       std::vector<std::unique_ptr<SavePageRequest>> requests);
 
   // Receives the results of a get from the request queue, and turns that into
   // SavePageRequest objects for the caller of GetQueuedRequests.
   void GetRequestsForSchedulingCallback(
-      RequestQueue::GetRequestsResult result,
+      QueueResults::GetRequestsResult result,
       std::vector<std::unique_ptr<SavePageRequest>> requests);
 
   // Receives the result of add requests to the request queue.
-  void AddRequestResultCallback(RequestQueue::AddRequestResult result,
+  void AddRequestResultCallback(QueueResults::AddRequestResult result,
                                 const SavePageRequest& request);
 
   // Receives the result of mark attempt completed requests.
   void MarkAttemptCompletedDoneCallback(
       int64_t request_id,
       const ClientId& client_id,
-      std::unique_ptr<UpdateRequestsResult> result);
+      std::unique_ptr<QueueResults::UpdateRequestsResult> result);
 
   void UpdateMultipleRequestsCallback(
-      std::unique_ptr<UpdateRequestsResult> result);
+      std::unique_ptr<QueueResults::UpdateRequestsResult> result);
 
   void CompletedRequestCallback(const MultipleItemStatuses& status);
 
   void HandleRemovedRequestsAndCallback(
       const RemoveRequestsCallback& callback,
-      BackgroundSavePageResult status,
-      std::unique_ptr<UpdateRequestsResult> result);
+      RequestNotifier::BackgroundSavePageResult status,
+      std::unique_ptr<QueueResults::UpdateRequestsResult> result);
 
-  void HandleRemovedRequests(BackgroundSavePageResult status,
-                             std::unique_ptr<UpdateRequestsResult> result);
+  void HandleRemovedRequests(
+      RequestNotifier::BackgroundSavePageResult status,
+      std::unique_ptr<QueueResults::UpdateRequestsResult> result);
 
   bool StartProcessingInternal(const ProcessingWindowState processing_state,
                                const DeviceConditions& device_conditions,
                                const base::Callback<void(bool)>& callback);
 
   // Start processing now if connected (but with conservative assumption
   // as to other device conditions).
   void StartImmediatelyIfConnected();
 
   OfflinerImmediateStartStatus TryImmediateStart();
@@ skipping 13 matching lines @@
   void HandleWatchdogTimeout();
 
   // Cancels an in progress pre-rendering, and updates state appropriately.
   void StopPrerendering(Offliner::RequestStatus stop_status);
 
   // Marks attempt on the request and sends it to offliner in continuation.
   void SendRequestToOffliner(const SavePageRequest& request);
 
   // Continuation of |SendRequestToOffliner| after the request is marked as
   // started.
-  void StartOffliner(int64_t request_id,
-                     const std::string& client_namespace,
-                     std::unique_ptr<UpdateRequestsResult> update_result);
+  void StartOffliner(
+      int64_t request_id,
+      const std::string& client_namespace,
+      std::unique_ptr<QueueResults::UpdateRequestsResult> update_result);
 
   // Called by the offliner when an offlining request is completed. (and by
   // tests).
   void OfflinerDoneCallback(const SavePageRequest& request,
                             Offliner::RequestStatus status);
 
   void TryNextRequest();
 
   // 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,
                               BackgroundSavePageResult status);
 
   // Completes aborting the request, reports an error if it fails.
-  void MarkAttemptAbortedDone(int64_t request_id,
-                              const ClientId& client_id,
-                              std::unique_ptr<UpdateRequestsResult> result);
+  void MarkAttemptAbortedDone(
+      int64_t request_id,
+      const ClientId& client_id,
+      std::unique_ptr<QueueResults::UpdateRequestsResult> result);
 
   // 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 44 matching lines @@
   std::unique_ptr<Scheduler> scheduler_;
   // Controller of client policies. Owned.
   std::unique_ptr<ClientPolicyController> policy_controller_;
   // Unowned pointer to the Network Quality Estimator.
   net::NetworkQualityEstimator::NetworkQualityProvider*
       network_quality_estimator_;
   // Holds copy of the active request, if any.
   std::unique_ptr<SavePageRequest> active_request_;
   // Status of the most recent offlining.
   Offliner::RequestStatus last_offlining_status_;
-  // Class to choose which request to schedule next
-  std::unique_ptr<RequestPicker> picker_;
   // A set of request_ids that we are holding off until the download manager is
   // done with them.
   std::set<int64_t> disabled_requests_;
   // Calling this returns to the scheduler across the JNI bridge.
   base::Callback<void(bool)> scheduler_callback_;
   // Logger to record events.
   RequestCoordinatorEventLogger event_logger_;
   // Timer to watch for pre-render attempts running too long.
   base::OneShotTimer watchdog_timer_;
   // Callback invoked when an immediate request is done (default empty).
   base::Callback<void(bool)> immediate_schedule_callback_;
   // 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_