Request Picker task

components/offline_pages/background/request_queue_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_queue.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/offline_pages/background/request_queue_in_memory_store.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
-using AddRequestResult = RequestQueue::AddRequestResult;
-using GetRequestsResult = RequestQueue::GetRequestsResult;
-using UpdateRequestResult = RequestQueue::UpdateRequestResult;
+using AddRequestResult = QueueResults::AddRequestResult;
+using GetRequestsResult = QueueResults::GetRequestsResult;
+using UpdateRequestResult = QueueResults::UpdateRequestResult;
 
 namespace {
 // Data for request 1.
 const int64_t kRequestId = 42;
 const GURL kUrl("http://example.com");
 const ClientId kClientId("bookmark", "1234");
 // Data for request 2.
 const int64_t kRequestId2 = 77;
 const GURL kUrl2("http://test.com");
 const ClientId kClientId2("bookmark", "567");
@@ skipping 12 matching lines @@
 
   void PumpLoop();
 
   // Callback for adding requests.
   void AddRequestDone(AddRequestResult result, const SavePageRequest& request);
   // Callback for getting requests.
   void GetRequestsDone(GetRequestsResult result,
                        std::vector<std::unique_ptr<SavePageRequest>> requests);
 
   void UpdateRequestDone(UpdateRequestResult result);
-  void UpdateRequestsDone(std::unique_ptr<UpdateRequestsResult> result);
+  void UpdateRequestsDone(
+      std::unique_ptr<QueueResults::UpdateRequestsResult> result);
 
   void ClearResults();
 
   RequestQueue* queue() { return queue_.get(); }
 
   AddRequestResult last_add_result() const { return last_add_result_; }
   SavePageRequest* last_added_request() {
     return last_added_request_.get();
   }
 
   UpdateRequestResult last_update_result() const { return last_update_result_; }
 
   GetRequestsResult last_get_requests_result() const {
     return last_get_requests_result_;
   }
 
   const std::vector<std::unique_ptr<SavePageRequest>>& last_requests() const {
     return last_requests_;
   }
 
-  UpdateRequestsResult* update_requests_result() const {
+  QueueResults::UpdateRequestsResult* update_requests_result() const {
     return update_requests_result_.get();
   }
 
  private:
   AddRequestResult last_add_result_;
   std::unique_ptr<SavePageRequest> last_added_request_;
-  std::unique_ptr<UpdateRequestsResult> update_requests_result_;
+  std::unique_ptr<QueueResults::UpdateRequestsResult> update_requests_result_;
   UpdateRequestResult last_update_result_;
 
   GetRequestsResult last_get_requests_result_;
   std::vector<std::unique_ptr<SavePageRequest>> last_requests_;
 
   std::unique_ptr<RequestQueue> queue_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
 };
 
@@ skipping 27 matching lines @@
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
   last_get_requests_result_ = result;
   last_requests_ = std::move(requests);
 }
 
 void RequestQueueTest::UpdateRequestDone(UpdateRequestResult result) {
   last_update_result_ = result;
 }
 
 void RequestQueueTest::UpdateRequestsDone(
-    std::unique_ptr<UpdateRequestsResult> result) {
+    std::unique_ptr<QueueResults::UpdateRequestsResult> result) {
   update_requests_result_ = std::move(result);
 }
 
 void RequestQueueTest::ClearResults() {
   last_add_result_ = AddRequestResult::STORE_FAILURE;
   last_update_result_ = UpdateRequestResult::STORE_FAILURE;
   last_get_requests_result_ = GetRequestsResult::STORE_FAILURE;
   last_added_request_.reset(nullptr);
   update_requests_result_.reset(nullptr);
   last_requests_.clear();
@@ skipping 337 matching lines @@
   EXPECT_EQ(1UL, update_requests_result()->item_statuses.size());
   EXPECT_EQ(kRequestId, update_requests_result()->item_statuses.at(0).first);
   EXPECT_EQ(ItemActionStatus::SUCCESS,
             update_requests_result()->item_statuses.at(0).second);
   EXPECT_EQ(1UL, update_requests_result()->updated_items.size());
   EXPECT_EQ(SavePageRequest::RequestState::AVAILABLE,
             update_requests_result()->updated_items.at(0).request_state());
 }
 
 }  // namespace offline_pages