[Offline Pages] Define separate watchdog timeout for concurrent bg loads

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 <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/supports_user_data.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"
@@ skipping 14 matching lines @@
 class RequestPicker;
 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(
@@ skipping 116 matching lines @@
     return is_busy_;
   }
 
   // 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 is_stopped_;
+    return processing_state_ == ProcessingWindowState::STOPPED;
   }
 
   OfflineEventLogger* 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.
     BUSY = 1,
     // The Offliner did not accept processing the request.
     NOT_ACCEPTED = 2,
     // No current network connection.
     NO_CONNECTION = 3,
     // Weak network connection (worse than 2G speed)
     // according to network quality estimator.
     WEAK_CONNECTION = 4,
     // Did not start because this is svelte device.
     NOT_STARTED_ON_SVELTE = 5,
     // NOTE: insert new values above this line and update histogram enum too.
     STATUS_COUNT = 6,
   };
 
+  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,
       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(
@@ skipping 14 matching lines @@
   void CompletedRequestCallback(const MultipleItemStatuses& status);
 
   void HandleRemovedRequestsAndCallback(
       const RemoveRequestsCallback& callback,
       BackgroundSavePageResult status,
       std::unique_ptr<UpdateRequestsResult> result);
 
   void HandleRemovedRequests(BackgroundSavePageResult status,
                              std::unique_ptr<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 StartProcessingIfConnected();
+  void StartImmediatelyIfConnected();
 
   OfflinerImmediateStartStatus TryImmediateStart();
 
   // Check the request queue, and schedule a task corresponding
   // to the least restrictive type of request in the queue.
   void ScheduleAsNeeded();
 
   // Callback from the request picker when it has chosen our next request.
   void RequestPicked(const SavePageRequest& request);
 
@@ skipping 35 matching lines @@
   // Method to wrap calls to getting the connection type so it can be
   // changed for tests.
   net::NetworkChangeNotifier::ConnectionType GetConnectionType();
 
   void SetNetworkConditionsForTest(
       net::NetworkChangeNotifier::ConnectionType connection) {
     use_test_connection_type_ = true;
     test_connection_type_ = connection;
   }
 
-  void SetOfflinerTimeoutForTest(const base::TimeDelta& timeout) {
-    offliner_timeout_ = timeout;
-  }
-
-  void SetDeviceConditionsForTest(DeviceConditions& current_conditions) {
+  void SetDeviceConditionsForTest(const DeviceConditions& current_conditions) {
     current_conditions_.reset(new DeviceConditions(current_conditions));
   }
 
   // KeyedService implementation:
   void Shutdown() override;
 
   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_;
   // There is more than one path to start processing so this flag is used
   // to avoid race conditions before is_busy_ is established.
   bool is_starting_;
-  // True if the current processing window has been canceled.
-  bool is_stopped_;
+  // Identifies the type of current processing window or if processing stopped.
+  ProcessingWindowState processing_state_;
   // True if we should use the test connection type instead of the actual type.
   bool use_test_connection_type_;
   // For use by tests, a fake network connection type
   net::NetworkChangeNotifier::ConnectionType test_connection_type_;
   // 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
@@ skipping 19 matching lines @@
   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_;
-  // How long to wait for an offliner request before giving up.
-  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_