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"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "components/offline_pages/background/offliner_factory.h"
 #include "components/offline_pages/background/offliner_policy.h"
 #include "components/offline_pages/background/request_picker.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/client_policy_controller.h"
 #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 kDisabledTaskRecheckSeconds = 5 * 60;

[Dmitry Titov, 2016/10/10 17:29:45]

I think this needs to be a much shorter interval. Here is the logic:
- these tasks will be there only while disabled_requests_ is not empty, if it
becomes empty we'll clear them right away.
- that list will only be non-empty while Chrome is running and actively
snapshotting page(s) in tabs
- it's good for user if we keep download 'running' even if they switch to other
app.

So lets say we have this period to be 5 seconds. While Chrome is running,
responding to a once-in-5-seconds task is very cheap. Once Chrome is evicted
from RAM, the next wake up will be the last of those, and it'll run background
loader 'in parallel' with whatever activity is there - same as it may do in 5
minutes, but with better match of user expectations.

WDYT?

[Pete Williamson, 2016/10/10 19:45:17]

Done.

 
 // Records the final request status UMA for an offlining request. This should
 // only be called once per Offliner::LoadAndSave request.
 void RecordOfflinerResultUMA(const ClientId& client_id,
                              Offliner::RequestStatus request_status) {
   // TODO(dougarnett): Consider exposing AddHistogramSuffix from
   // offline_page_model_impl.cc as visible utility method.
   std::string histogram_name("OfflinePages.Background.OfflinerRequestStatus");
   if (!client_id.name_space.empty()) {
     histogram_name += "." + client_id.name_space;
@@ skipping 415 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 min 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 101 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