Use a vector of smart pointers for callback return type.

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 194 matching lines @@
   void WaitingCallbackFunction(bool result) {
     waiter_.Signal();
   }
 
   // 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);
+                       std::vector<std::unique_ptr<SavePageRequest>> requests);
 
   // Callback for removing requests.
   void RemoveRequestsDone(
       const RequestQueue::UpdateMultipleRequestResults& results);
 
   // Callback for getting request statuses.
-  void GetQueuedRequestsDone(const std::vector<SavePageRequest>& requests);
+  void GetQueuedRequestsDone(
+      std::vector<std::unique_ptr<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 {
+  const std::vector<std::unique_ptr<SavePageRequest>>& last_requests() const {
     return last_requests_;
   }
 
   const RequestQueue::UpdateMultipleRequestResults& last_remove_results()
       const {
     return last_remove_results_;
   }
 
   void EnableOfflinerCallback(bool enable) {
     offliner_->enable_callback(enable);
@@ skipping 18 matching lines @@
   Offliner::RequestStatus last_offlining_status() const {
     return coordinator_->last_offlining_status_;
   }
 
   bool OfflinerWasCanceled() const { return offliner_->cancel_called(); }
 
   ObserverStub observer() { return observer_; }
 
  private:
   RequestQueue::GetRequestsResult last_get_requests_result_;
-  std::vector<SavePageRequest> last_requests_;
   RequestQueue::UpdateMultipleRequestResults 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<RequestCoordinator> coordinator_;
   OfflinerStub* offliner_;
   base::WaitableEvent waiter_;
   ObserverStub observer_;
 };
 
 RequestCoordinatorTest::RequestCoordinatorTest()
     : last_get_requests_result_(RequestQueue::GetRequestsResult::STORE_FAILURE),
@@ skipping 20 matching lines @@
       std::move(scheduler_stub)));
   coordinator_->AddObserver(&observer_);
 }
 
 void RequestCoordinatorTest::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
 void RequestCoordinatorTest::GetRequestsDone(
     RequestQueue::GetRequestsResult result,
-    const std::vector<SavePageRequest>& requests) {
+    std::vector<std::unique_ptr<SavePageRequest>> requests) {
   last_get_requests_result_ = result;
-  last_requests_ = requests;
+  last_requests_ = std::move(requests);
 }
 
 void RequestCoordinatorTest::RemoveRequestsDone(
     const RequestQueue::UpdateMultipleRequestResults& results) {
   last_remove_results_ = results;
   waiter_.Signal();
 }
 
 void RequestCoordinatorTest::GetQueuedRequestsDone(
-    const std::vector<SavePageRequest>& requests) {
-  last_requests_ = requests;
+    std::vector<std::unique_ptr<SavePageRequest>> requests) {
+  last_requests_ = std::move(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 40 matching lines @@
   // Expect that a request got placed on the queue.
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
 
   // Wait for callbacks to finish, both request queue and offliner.
   PumpLoop();
 
   // Check the request queue is as expected.
   EXPECT_EQ(1UL, last_requests().size());
-  EXPECT_EQ(kUrl1, last_requests()[0].url());
-  EXPECT_EQ(kClientId1, last_requests()[0].client_id());
+  EXPECT_EQ(kUrl1, last_requests().at(0)->url());
+  EXPECT_EQ(kClientId1, last_requests().at(0)->client_id());
 
   // Expect that the scheduler got notified.
   SchedulerStub* scheduler_stub = reinterpret_cast<SchedulerStub*>(
       coordinator()->scheduler());
   EXPECT_TRUE(scheduler_stub->schedule_called());
   EXPECT_EQ(coordinator()
                 ->GetTriggerConditionsForUserRequest()
                 .minimum_battery_percentage,
             scheduler_stub->conditions()->minimum_battery_percentage);
 
@@ skipping 138 matching lines @@
   PumpLoop();
 
   // Verify the request is not removed from the queue, and wait for callbacks.
   coordinator()->queue()->GetRequests(base::Bind(
       &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // Request no longer in the queue (for single attempt policy).
   EXPECT_EQ(1UL, last_requests().size());
   // Verify foreground cancel not counted as an attempt after all.
-  const SavePageRequest& found_request = last_requests().front();
-  EXPECT_EQ(0L, found_request.completed_attempt_count());
+  EXPECT_EQ(0L, last_requests().at(0)->completed_attempt_count());
 }
 
 // This tests a StopProcessing call before we have actually started the
 // prerenderer.
 TEST_F(RequestCoordinatorTest, StartProcessingThenStopProcessingImmediately) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(
       kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request,
@@ skipping 209 matching lines @@
   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_requests().size());
-  EXPECT_EQ(kRequestId1, last_requests().at(0).request_id());
-  EXPECT_EQ(kRequestId2, last_requests().at(1).request_id());
+  EXPECT_EQ(kRequestId1, last_requests().at(0)->request_id());
+  EXPECT_EQ(kRequestId2, last_requests().at(1)->request_id());
 }
 
 TEST_F(RequestCoordinatorTest, PauseAndResumeObserver) {
   // Add a request to the queue.
   offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
                                           base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            base::Unretained(this)));
   PumpLoop();
@@ skipping 39 matching lines @@
   PumpLoop();
 
   EXPECT_TRUE(observer().completed_called());
   EXPECT_EQ(RequestCoordinator::SavePageStatus::REMOVED,
             observer().last_status());
   EXPECT_EQ(1UL, last_remove_results().size());
   EXPECT_EQ(kRequestId1, std::get<0>(last_remove_results().at(0)));
 }
 
 }  // namespace offline_pages