Implement disabled list

components/offline_pages/background/request_picker_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_picker.h"
 
 #include "base/bind.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
@@ skipping 137 matching lines @@
 void RequestPickerTest::RequestNotPicked(
     const bool non_user_requested_tasks_remaining) {
   request_queue_not_picked_called_ = true;
 }
 
 // Test helper to queue the two given requests and then pick one of them per
 // configured policy.
 void RequestPickerTest::QueueRequestsAndChooseOne(
     const SavePageRequest& request1, const SavePageRequest& request2) {
   DeviceConditions conditions;
+  std::set<int64_t> disabled_requests;
   // Add test requests on the Queue.
   queue_->AddRequest(request1, base::Bind(&RequestPickerTest::AddRequestDone,
                                           base::Unretained(this)));
   queue_->AddRequest(request2, base::Bind(&RequestPickerTest::AddRequestDone,
                                           base::Unretained(this)));
 
   // Pump the loop to give the async queue the opportunity to do the adds.
   PumpLoop();
 
   // Call the method under test.
   picker_->ChooseNextRequest(
       base::Bind(&RequestPickerTest::RequestPicked, base::Unretained(this)),
       base::Bind(&RequestPickerTest::RequestNotPicked, base::Unretained(this)),
-      &conditions);
+      &conditions, &disabled_requests);
 
   // Pump the loop again to give the async queue the opportunity to return
   // results from the Get operation, and for the picker to call the "picked"
   // callback.
   PumpLoop();
 }
 
 TEST_F(RequestPickerTest, PickFromEmptyQueue) {
   DeviceConditions conditions;
+  std::set<int64_t> disabled_requests;
   picker_->ChooseNextRequest(
       base::Bind(&RequestPickerTest::RequestPicked, base::Unretained(this)),
       base::Bind(&RequestPickerTest::RequestNotPicked, base::Unretained(this)),
-      &conditions);
+      &conditions, &disabled_requests);
 
   // Pump the loop again to give the async queue the opportunity to return
   // results from the Get operation, and for the picker to call the "QueueEmpty"
   // callback.
   PumpLoop();
 
   EXPECT_TRUE(request_queue_not_picked_called_);
 }
 
 TEST_F(RequestPickerTest, ChooseRequestWithHigherRetryCount) {
@@ skipping 170 matching lines @@
 
   // With default policy settings, we should choose the earlier request.
   // However, we will make the earlier reqeust exceed the limit.
   request1.set_completed_attempt_count(policy_->GetMaxCompletedTries());
 
   QueueRequestsAndChooseOne(request1, request2);
 
   EXPECT_EQ(kRequestId2, last_picked_->request_id());
   EXPECT_FALSE(request_queue_not_picked_called_);
 }
+
+
+TEST_F(RequestPickerTest, ChooseRequestThatIsNotDisabled) {
+  policy_.reset(new OfflinerPolicy(kPreferUntried, kPreferEarlier,
+                                   kPreferRetryCount, kMaxStartedTries,
+                                   kMaxCompletedTries + 1));
+  picker_.reset(new RequestPicker(queue_.get(), policy_.get(), notifier_.get(),
+                                  &event_logger_));
+
+  base::Time creation_time = base::Time::Now();
+  SavePageRequest request1(
+      kRequestId1, kUrl1, kClientId1, creation_time, kUserRequested);
+  SavePageRequest request2(
+      kRequestId2, kUrl2, kClientId2, creation_time, kUserRequested);
+  request2.set_completed_attempt_count(kAttemptCount);
+
+  // put request 2 on disabled list, ensure request1 picked instead,
+  // even though policy would prefer 2.
+  std::set<int64_t> disabled_requests {kRequestId2};
+  DeviceConditions conditions;
+
+  // Add test requests on the Queue.
+  queue_->AddRequest(request1, base::Bind(&RequestPickerTest::AddRequestDone,
+                                          base::Unretained(this)));
+  queue_->AddRequest(request2, base::Bind(&RequestPickerTest::AddRequestDone,
+                                          base::Unretained(this)));
+
+  // Pump the loop to give the async queue the opportunity to do the adds.
+  PumpLoop();
+
+  // Call the method under test.
+  picker_->ChooseNextRequest(
+      base::Bind(&RequestPickerTest::RequestPicked, base::Unretained(this)),
+      base::Bind(&RequestPickerTest::RequestNotPicked, base::Unretained(this)),
+      &conditions, &disabled_requests);
+
+  // Pump the loop again to give the async queue the opportunity to return
+  // results from the Get operation, and for the picker to call the "picked"
+  // callback.
+  PumpLoop();
+
+  EXPECT_EQ(kRequestId1, last_picked_->request_id());
+  EXPECT_FALSE(request_queue_not_picked_called_);
+}
 }  // namespace offline_pages