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

components/offline_pages/background/request_coordinator_unittest.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 <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 33 matching lines @@
 const int kBatteryPercentageHigh = 75;
 const bool kPowerRequired = true;
 const bool kUserRequested = true;
 const int kAttemptCount = 1;
 }  // namespace
 
 class SchedulerStub : public Scheduler {
  public:
   SchedulerStub()
       : schedule_called_(false),
+        backup_schedule_called_(false),
         unschedule_called_(false),
+        schedule_delay_(0L),
         conditions_(false, 0, false) {}
 
   void Schedule(const TriggerConditions& trigger_conditions) override {
     schedule_called_ = true;
     conditions_ = trigger_conditions;
   }
 
+  void BackupSchedule(const TriggerConditions& trigger_conditions,
+                      long delay_in_seconds) override {
+    backup_schedule_called_ = true;
+    schedule_delay_ = delay_in_seconds;
+    conditions_ = trigger_conditions;
+  }
+
+
   // Unschedules the currently scheduled task, if any.
   void Unschedule() override {
     unschedule_called_ = true;
   }
 
   bool schedule_called() const { return schedule_called_; }
 
+  bool backup_schedule_called() const { return backup_schedule_called_;}
+
   bool unschedule_called() const { return unschedule_called_; }
 
   TriggerConditions const* conditions() const { return &conditions_; }
 
  private:
   bool schedule_called_;
+  bool backup_schedule_called_;
   bool unschedule_called_;
+  long schedule_delay_;
   TriggerConditions conditions_;
 };
 
 class OfflinerStub : public Offliner {
  public:
   OfflinerStub()
       : request_(kRequestId1, kUrl1, kClientId1, base::Time::Now(),
                  kUserRequested),
         disable_loading_(false),
         enable_callback_(false),
@@ skipping 189 matching lines @@
       net::NetworkChangeNotifier::ConnectionType connection) {
     coordinator()->SetNetworkConditionsForTest(connection);
   }
 
   void SetEffectiveConnectionTypeForTest(net::EffectiveConnectionType type) {
     network_quality_estimator_->SetEffectiveConnectionTypeForTest(type);
   }
 
   void ScheduleForTest() { coordinator_->ScheduleAsNeeded(); }
 
-  void CallRequestNotPicked(bool non_user_requested_tasks_remaining) {
+  void CallRequestNotPicked(bool non_user_requested_tasks_remaining,
+                            bool disabled_tasks_remaining) {
+    if (disabled_tasks_remaining)
+      coordinator_->disabled_requests_.insert(kRequestId1);
+    else
+      coordinator_->disabled_requests_.clear();
+
     coordinator_->RequestNotPicked(non_user_requested_tasks_remaining);
   }
 
   void SetOfflinerTimeoutForTest(const base::TimeDelta& timeout) {
     coordinator_->SetOfflinerTimeoutForTest(timeout);
   }
 
   void SetDeviceConditionsForTest(DeviceConditions device_conditions) {
     coordinator_->SetDeviceConditionsForTest(device_conditions);
   }
@@ skipping 384 matching lines @@
   // Request still in the queue.
   EXPECT_EQ(1UL, last_requests().size());
   // Verify prerendering cancel not counted as an attempt after all.
   const std::unique_ptr<SavePageRequest>& found_request =
       last_requests().front();
   EXPECT_EQ(0L, found_request->completed_attempt_count());
 }
 
 // If one item completes, and there are no more user requeted items left,
 // we should make a scheduler entry for a non-user requested item.
+TEST_F(RequestCoordinatorTest, RequestNotPickedDisabledItemsRemain) {
+  // Call start processing just to set up a scheduler callback.
+  DeviceConditions device_conditions(false, 75,
+                                     net::NetworkChangeNotifier::CONNECTION_3G);
+  base::Callback<void(bool)> callback = base::Bind(
+      &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
+  coordinator()->StartProcessing(device_conditions, callback);
+  EXPECT_TRUE(is_starting());
+
+  // Call RequestNotPicked, simulating a request on the disabled list.
+  CallRequestNotPicked(false, true);
+  PumpLoop();
+
+  EXPECT_FALSE(is_starting());
+
+  // The scheduler should have been called to schedule the disabled task for
+  // 5 minutes from now.
+  SchedulerStub* scheduler_stub =
+      reinterpret_cast<SchedulerStub*>(coordinator()->scheduler());
+  EXPECT_TRUE(scheduler_stub->backup_schedule_called());
+  EXPECT_TRUE(scheduler_stub->unschedule_called());
+}
+
+// If one item completes, and there are no more user requeted items left,
+// we should make a scheduler entry for a non-user requested item.
 TEST_F(RequestCoordinatorTest, RequestNotPickedNonUserRequestedItemsRemain) {
   // Call start processing just to set up a scheduler callback.
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback = base::Bind(
       &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
   coordinator()->StartProcessing(device_conditions, callback);
   EXPECT_TRUE(is_starting());
 
   // Call RequestNotPicked, and make sure we pick schedule a task for non user
-  // requested conditions.
-  CallRequestNotPicked(true);
+  // requested conditions, with no tasks on the disabled list.
+  CallRequestNotPicked(true, false);
   PumpLoop();
 
   EXPECT_FALSE(is_starting());
 
   // The scheduler should have been called to schedule the non-user requested
   // task.
   SchedulerStub* scheduler_stub =
       reinterpret_cast<SchedulerStub*>(coordinator()->scheduler());
   EXPECT_TRUE(scheduler_stub->schedule_called());
   EXPECT_TRUE(scheduler_stub->unschedule_called());
@@ skipping 443 matching lines @@
   // Now whether processing triggered immediately depends on whether test
   // is run on svelte device or not.
   if (base::SysInfo::IsLowEndDevice()) {
     EXPECT_FALSE(is_busy());
   } else {
     EXPECT_TRUE(is_busy());
   }
 }
 
 }  // namespace offline_pages