Changes to fit better with the needs of the download manager.

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 144 matching lines @@
 
   // Callback for Add requests.
   void AddRequestDone(RequestQueue::AddRequestResult result,
                       const SavePageRequest& request);
 
   // Callback for getting requests.
   void GetRequestsDone(RequestQueue::GetRequestsResult result,
                        const std::vector<SavePageRequest>& requests);
 
   // Callback for getting request statuses.
-  void GetQueuedRequestsDone(const std::vector<ClientId>& client_ids);
+  void GetQueuedRequestsDone(const std::vector<SavePageRequest>& requests);
 
   void SendOfflinerDoneCallback(const SavePageRequest& request,
                                 Offliner::RequestStatus status);
 
   RequestQueue::GetRequestsResult last_get_requests_result() const {
     return last_get_requests_result_;
   }
 
   const std::vector<SavePageRequest>& last_requests() const {
     return last_requests_;
   }
 
-  const std::vector<ClientId>& last_client_ids() const {
-    return last_client_ids_;
-  }
-
   void EnableOfflinerCallback(bool enable) {
     offliner_->enable_callback(enable);
   }
 
   void SetOfflinerTimeoutForTest(const base::TimeDelta& timeout) {
     coordinator_->SetOfflinerTimeoutForTest(timeout);
   }
 
   void SetDeviceConditionsForTest(DeviceConditions device_conditions) {
     coordinator_->SetDeviceConditionsForTest(device_conditions);
   }
 
   void WaitForCallback() {
     waiter_.Wait();
   }
 
   void AdvanceClockBy(base::TimeDelta delta) {
     task_runner_->FastForwardBy(delta);
   }
 
   Offliner::RequestStatus last_offlining_status() const {
     return coordinator_->last_offlining_status_;
   }
 
   bool OfflinerWasCanceled() const { return offliner_->cancel_called(); }
 
  private:
   RequestQueue::GetRequestsResult last_get_requests_result_;
   std::vector<SavePageRequest> last_requests_;
-  std::vector<ClientId> last_client_ids_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<RequestCoordinator> coordinator_;
   OfflinerStub* offliner_;
   base::WaitableEvent waiter_;
 };
 
 RequestCoordinatorTest::RequestCoordinatorTest()
     : last_get_requests_result_(RequestQueue::GetRequestsResult::STORE_FAILURE),
       task_runner_(new base::TestMockTimeTaskRunner),
@@ skipping 24 matching lines @@
 }
 
 void RequestCoordinatorTest::GetRequestsDone(
     RequestQueue::GetRequestsResult result,
     const std::vector<SavePageRequest>& requests) {
   last_get_requests_result_ = result;
   last_requests_ = requests;
 }
 
 void RequestCoordinatorTest::GetQueuedRequestsDone(
-    const std::vector<ClientId>& client_ids) {
-  last_client_ids_ = client_ids;
+    const std::vector<SavePageRequest>& requests) {
+  last_requests_ = requests;
   waiter_.Signal();
 }
 
 void RequestCoordinatorTest::AddRequestDone(
     RequestQueue::AddRequestResult result,
     const SavePageRequest& request) {}
 
 void RequestCoordinatorTest::SendOfflinerDoneCallback(
     const SavePageRequest& request, Offliner::RequestStatus status) {
   // Using the fact that the test class is a friend, call to the callback
@@ skipping 353 matching lines @@
   // Verify the request gets removed from the queue, and wait for callbacks.
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // We should find one request in the queue.
   EXPECT_EQ(1UL, last_requests().size());
 }
 
-TEST_F(RequestCoordinatorTest, GetQueuedRequests) {
+TEST_F(RequestCoordinatorTest, GetAllRequests) {
   // Add two requests to the queue.
   offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
                                           base::Time::Now(), kUserRequested);
   offline_pages::SavePageRequest request2(kRequestId1 + 1, kUrl2, kClientId2,
                                           base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            base::Unretained(this)));
   coordinator()->queue()->AddRequest(
       request2, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            base::Unretained(this)));
   PumpLoop();
 
   // Start the async status fetching.
-  coordinator()->GetQueuedRequests(
-      kClientNamespace,
-      base::Bind(&RequestCoordinatorTest::GetQueuedRequestsDone,
-                 base::Unretained(this)));
+  coordinator()->GetAllRequests(base::Bind(
+      &RequestCoordinatorTest::GetQueuedRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // Wait for async get to finish.
   WaitForCallback();
   PumpLoop();
 
   // Check that the statuses found in the callback match what we expect.
-  EXPECT_EQ(2UL, last_client_ids().size());
-  EXPECT_EQ(kId1, last_client_ids().at(0).id);
-  EXPECT_EQ(kId2, last_client_ids().at(1).id);
+  EXPECT_EQ(2UL, last_requests().size());
+  EXPECT_EQ(kRequestId1, last_requests().at(0).request_id());
+  EXPECT_EQ(kRequestId2, last_requests().at(1).request_id());
 }
 
 }  // namespace offline_pages