Request Picker task

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/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/offliner.h"
 #include "components/offline_pages/background/offliner_factory.h"
 #include "components/offline_pages/background/offliner_policy.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 "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 // put test constants here
@@ skipping 220 matching lines @@
   // Callback function which releases a wait for it.
   void WaitingCallbackFunction(bool result) {
     waiter_.Signal();
   }
 
   net::NetworkChangeNotifier::ConnectionType GetConnectionType() {
     return coordinator()->GetConnectionType();
   }
 
   // Callback for Add requests.
-  void AddRequestDone(RequestQueue::AddRequestResult result,
+  void AddRequestDone(QueueResults::AddRequestResult result,
                       const SavePageRequest& request);
 
   // Callback for getting requests.
-  void GetRequestsDone(RequestQueue::GetRequestsResult result,
+  void GetRequestsDone(QueueResults::GetRequestsResult result,
                        std::vector<std::unique_ptr<SavePageRequest>> requests);
 
   // Callback for removing requests.
   void RemoveRequestsDone(const MultipleItemStatuses& results);
 
   // Callback for getting request statuses.
   void GetQueuedRequestsDone(
       std::vector<std::unique_ptr<SavePageRequest>> requests);
 
   void SetupForOfflinerDoneCallbackTest(
       offline_pages::SavePageRequest* request);
 
   void SendOfflinerDoneCallback(const SavePageRequest& request,
                                 Offliner::RequestStatus status);
 
-  RequestQueue::GetRequestsResult last_get_requests_result() const {
+  QueueResults::GetRequestsResult last_get_requests_result() const {
     return last_get_requests_result_;
   }
 
   const std::vector<std::unique_ptr<SavePageRequest>>& last_requests() const {
     return last_requests_;
   }
 
   const MultipleItemStatuses& last_remove_results() const {
     return last_remove_results_;
   }
@@ skipping 72 matching lines @@
 
   bool OfflinerWasCanceled() const { return offliner_->cancel_called(); }
 
   ObserverStub observer() { return observer_; }
 
   bool immediate_schedule_callback_called() const {
     return immediate_schedule_callback_called_;
   }
 
  private:
-  RequestQueue::GetRequestsResult last_get_requests_result_;
+  QueueResults::GetRequestsResult last_get_requests_result_;
   MultipleItemStatuses last_remove_results_;
   std::vector<std::unique_ptr<SavePageRequest>> last_requests_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<NetworkQualityEstimatorStub> network_quality_estimator_;
   std::unique_ptr<RequestCoordinator> coordinator_;
   OfflinerStub* offliner_;
   base::WaitableEvent waiter_;
   ObserverStub observer_;
   bool immediate_schedule_callback_called_;
 };
 
 RequestCoordinatorTest::RequestCoordinatorTest()
-    : last_get_requests_result_(RequestQueue::GetRequestsResult::STORE_FAILURE),
+    : last_get_requests_result_(QueueResults::GetRequestsResult::STORE_FAILURE),
       task_runner_(new base::TestMockTimeTaskRunner),
       task_runner_handle_(task_runner_),
       offliner_(nullptr),
       waiter_(base::WaitableEvent::ResetPolicy::MANUAL,
               base::WaitableEvent::InitialState::NOT_SIGNALED),
       immediate_schedule_callback_called_(false) {}
 
 RequestCoordinatorTest::~RequestCoordinatorTest() {}
 
 void RequestCoordinatorTest::SetUp() {
   std::unique_ptr<OfflinerPolicy> policy(new OfflinerPolicy());
-  std::unique_ptr<OfflinerFactory> factory(new OfflinerFactoryStub());
+  std::unique_ptr<OfflinerFactory> offliner_factory(new OfflinerFactoryStub());
   // Save the offliner for use by the tests.
-  offliner_ =
-      reinterpret_cast<OfflinerStub*>(factory->GetOffliner(policy.get()));
+  offliner_ = reinterpret_cast<OfflinerStub*>(
+      offliner_factory->GetOffliner(policy.get()));
   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 NetworkQualityEstimatorStub());
   coordinator_.reset(new RequestCoordinator(
-      std::move(policy), std::move(factory), std::move(queue),
+      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));
+  SetEffectiveConnectionTypeForTest(
+      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_OFFLINE);
+  SetNetworkConditionsForTest(
+      net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE);
 }
 
 void RequestCoordinatorTest::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
 void RequestCoordinatorTest::GetRequestsDone(
-    RequestQueue::GetRequestsResult result,
+    QueueResults::GetRequestsResult result,
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
   last_get_requests_result_ = result;
   last_requests_ = std::move(requests);
 }
 
 void RequestCoordinatorTest::RemoveRequestsDone(
     const MultipleItemStatuses& results) {
   last_remove_results_ = results;
   waiter_.Signal();
 }
 
 void RequestCoordinatorTest::GetQueuedRequestsDone(
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
   last_requests_ = std::move(requests);
   waiter_.Signal();
 }
 
 void RequestCoordinatorTest::AddRequestDone(
-    RequestQueue::AddRequestResult result,
+    QueueResults::AddRequestResult result,
     const SavePageRequest& request) {}
 
 void RequestCoordinatorTest::SetupForOfflinerDoneCallbackTest(
     offline_pages::SavePageRequest* request) {
   // Mark request as started and add it to the queue,
   // then wait for callback to finish.
   request->MarkAttemptStarted(base::Time::Now());
   coordinator()->queue()->AddRequest(
       *request, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            base::Unretained(this)));
@@ skipping 941 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