Set up a backup schedule request if we have deferred requests.

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 10 matching lines @@
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_model.h"
 
 namespace offline_pages {
 
 namespace {
 const bool kUserRequest = true;
 const int kMinDurationSeconds = 1;
 const int kMaxDurationSeconds = 7 * 24 * 60 * 60;  // 7 days
 const int kDurationBuckets = 50;
+const int kDisabledTaskRecheckSeconds = 5;
 
 // TODO(dougarnett): Move to util location and share with model impl.
 std::string AddHistogramSuffix(const ClientId& client_id,
                                const char* histogram_name) {
   if (client_id.name_space.empty()) {
     NOTREACHED();
     return histogram_name;
   }
   std::string adjusted_histogram_name(histogram_name);
   adjusted_histogram_name += "." + client_id.name_space;
@@ skipping 452 matching lines @@
   }
 }
 
 void RequestCoordinator::RequestNotPicked(
     bool non_user_requested_tasks_remaining) {
   is_starting_ = false;
 
   // Clear the outstanding "safety" task in the scheduler.
   scheduler_->Unschedule();
 
-  if (non_user_requested_tasks_remaining)
+  // If disabled tasks remain, post a new safety task for 5 sec from now.
+  if (disabled_requests_.size() > 0) {
+    scheduler_->BackupSchedule(GetTriggerConditions(kUserRequest),
+                               kDisabledTaskRecheckSeconds);
+  } else if (non_user_requested_tasks_remaining) {
+    // If we don't have any of those, check for non-user-requested tasks.
     scheduler_->Schedule(GetTriggerConditions(!kUserRequest));
+  }
+
   // Let the scheduler know we are done processing.
   scheduler_callback_.Run(true);
 }
 
 void RequestCoordinator::SendRequestToOffliner(const SavePageRequest& request) {
   // Check that offlining didn't get cancelled while performing some async
   // steps.
   if (is_stopped_)
     return;
 
@@ skipping 102 matching lines @@
       break;
     default:
       // Make explicit choice about new status codes that actually reach here.
       // Their default is no further processing in this service window.
       NOTREACHED();
   }
 }
 
 void RequestCoordinator::EnableForOffliner(int64_t request_id) {
     disabled_requests_.erase(request_id);
+    // If we are not busy, start processing right away.
+    StartProcessingIfConnected();
 }
 
-void RequestCoordinator::MarkRequestCompleted(int64_t request_id) {}
+void RequestCoordinator::MarkRequestCompleted(int64_t request_id) {
+  // TODO: Remove the request, but send out SUCCEEDED instead of removed.
+}
 
 const Scheduler::TriggerConditions RequestCoordinator::GetTriggerConditions(
     const bool user_requested) {
   return Scheduler::TriggerConditions(
       policy_->PowerRequired(user_requested),
       policy_->BatteryPercentageRequired(user_requested),
       policy_->UnmeteredNetworkRequired(user_requested));
 }
 
 void RequestCoordinator::AddObserver(Observer* observer) {
@@ skipping 26 matching lines @@
 
 ClientPolicyController* RequestCoordinator::GetPolicyController() {
   return policy_controller_.get();
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages