Split the RequestPicker task into two separate tasks.

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 <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_info.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/offline_pages/background/device_conditions.h"
 #include "components/offline_pages/background/network_quality_provider_stub.h"
 #include "components/offline_pages/background/offliner.h"
 #include "components/offline_pages/background/offliner_factory.h"
 #include "components/offline_pages/background/offliner_factory_stub.h"
 #include "components/offline_pages/background/offliner_policy.h"
 #include "components/offline_pages/background/offliner_stub.h"
-#include "components/offline_pages/background/pick_request_task_factory.h"
 #include "components/offline_pages/background/request_queue.h"
 #include "components/offline_pages/background/request_queue_in_memory_store.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/background/scheduler.h"
 #include "components/offline_pages/background/scheduler_stub.h"
 #include "components/offline_pages/offline_page_feature.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
@@ skipping 178 matching lines @@
 
   void ScheduleForTest() { coordinator_->ScheduleAsNeeded(); }
 
   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);
+    coordinator_->RequestNotPicked(non_user_requested_tasks_remaining, false);
   }
 
   void SetDeviceConditionsForTest(DeviceConditions device_conditions) {
     coordinator_->SetDeviceConditionsForTest(device_conditions);
   }
 
   void WaitForCallback() {
     waiter_.Wait();
   }
 
@@ skipping 73 matching lines @@
   std::unique_ptr<RequestQueueInMemoryStore>
       store(new RequestQueueInMemoryStore());
   std::unique_ptr<RequestQueue> queue(new RequestQueue(std::move(store)));
   std::unique_ptr<Scheduler> scheduler_stub(new SchedulerStub());
   network_quality_estimator_.reset(new NetworkQualityProviderStub());
   coordinator_.reset(new RequestCoordinator(
       std::move(policy), std::move(offliner_factory), std::move(queue),
       std::move(scheduler_stub), network_quality_estimator_.get()));
   coordinator_->AddObserver(&observer_);
   SetNetworkConnected(true);
-  std::unique_ptr<PickRequestTaskFactory> picker_factory(
-      new PickRequestTaskFactory(
-          coordinator_->policy(),
-          static_cast<RequestNotifier*>(coordinator_.get()),
-          coordinator_->GetLogger()));
-  coordinator_->queue()->SetPickerFactory(std::move(picker_factory));
   immediate_callback_ =
       base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
                  base::Unretained(this));
   // Override the normal immediate callback with a wait releasing callback.
   waiting_callback_ = base::Bind(
       &RequestCoordinatorTest::WaitingCallbackFunction, base::Unretained(this));
   SetDeviceConditionsForTest(device_conditions_);
   EnableOfflinerCallback(true);
 }
 
@@ skipping 974 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