Store BackgroundFetchRequestInfo in a refcounted pointer

content/browser/background_fetch/background_fetch_job_controller_unittest.cc

 // Copyright 2017 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 "content/browser/background_fetch/background_fetch_job_controller.h"
 
 #include <memory>
 #include <string>
 #include <unordered_map>
 
@@ skipping 108 matching lines @@
     // BrowserContext will take care of deallocating it.
     BrowserContext::SetDownloadManagerForTesting(browser_context(),
                                                  download_manager_);
   }
 
   // Creates a new Background Fetch registration, whose id will be stored in
   // the |*registration_id|, and registers it with the DataManager for the
   // included |request_data|. Should be wrapped in ASSERT_NO_FATAL_FAILURE().
   void CreateRegistrationForRequests(
       BackgroundFetchRegistrationId* registration_id,
-      std::vector<BackgroundFetchRequestInfo>* out_initial_requests,
+      std::vector<scoped_refptr<BackgroundFetchRequestInfo>>*
+          out_initial_requests,
       std::map<std::string /* url */, std::string /* method */> request_data) {
     DCHECK(registration_id);
     DCHECK(out_initial_requests);
 
     ASSERT_TRUE(CreateRegistrationId(kExampleTag, registration_id));
 
     std::vector<ServiceWorkerFetchRequest> requests;
     requests.reserve(request_data.size());
 
     for (const auto& pair : request_data) {
@@ skipping 37 matching lines @@
   MockDownloadManagerWithCallback* download_manager_;  // BrowserContext owned
   bool did_complete_job_ = false;
 
   // Closure that will be invoked when the JobController has completed all
   // available jobs. Enables use of a run loop for deterministic waits.
   base::OnceClosure job_completed_closure_;
 
  private:
   void DidCreateRegistration(
       blink::mojom::BackgroundFetchError* out_error,
-      std::vector<BackgroundFetchRequestInfo>* out_initial_requests,
+      std::vector<scoped_refptr<BackgroundFetchRequestInfo>>*
+          out_initial_requests,
       const base::Closure& quit_closure,
       blink::mojom::BackgroundFetchError error,
-      std::vector<BackgroundFetchRequestInfo> initial_requests) {
+      std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests) {
     DCHECK(out_error);
     DCHECK(out_initial_requests);
 
     *out_error = error;
     *out_initial_requests = std::move(initial_requests);
 
     quit_closure.Run();
   }
 
   void DidCompleteJob(BackgroundFetchJobController* controller) {
     DCHECK(controller);
     EXPECT_TRUE(
         controller->state() == BackgroundFetchJobController::State::ABORTED ||
         controller->state() == BackgroundFetchJobController::State::COMPLETED);
 
     did_complete_job_ = true;
 
     if (job_completed_closure_)
       std::move(job_completed_closure_).Run();
   }
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundFetchJobControllerTest);
 };
 
 TEST_F(BackgroundFetchJobControllerTest, SingleRequestJob) {
   BackgroundFetchRegistrationId registration_id;
-  std::vector<BackgroundFetchRequestInfo> initial_requests;
+  std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests;
 
   ASSERT_NO_FATAL_FAILURE(CreateRegistrationForRequests(
       &registration_id, &initial_requests,
       {{"https://example.com/funny_cat.png", "GET"}}));
 
   std::unique_ptr<BackgroundFetchJobController> controller =
       CreateJobController(registration_id);
 
   EXPECT_EQ(controller->state(),
             BackgroundFetchJobController::State::INITIALIZED);
@@ skipping 24 matching lines @@
     run_loop.Run();
   }
 
   EXPECT_EQ(controller->state(),
             BackgroundFetchJobController::State::COMPLETED);
   EXPECT_TRUE(did_complete_job_);
 }
 
 TEST_F(BackgroundFetchJobControllerTest, MultipleRequestJob) {
   BackgroundFetchRegistrationId registration_id;
-  std::vector<BackgroundFetchRequestInfo> initial_requests;
+  std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests;
 
   // This test should always issue more requests than the number of allowed
   // parallel requests. That way we ensure testing the iteration behaviour.
   ASSERT_GT(5u, kMaximumBackgroundFetchParallelRequests);
 
   ASSERT_NO_FATAL_FAILURE(CreateRegistrationForRequests(
       &registration_id, &initial_requests,
       {{"https://example.com/funny_cat.png", "GET"},
        {"https://example.com/scary_cat.png", "GET"},
        {"https://example.com/crazy_cat.png", "GET"},
@@ skipping 24 matching lines @@
     run_loop.Run();
   }
 
   EXPECT_EQ(controller->state(),
             BackgroundFetchJobController::State::COMPLETED);
   EXPECT_TRUE(did_complete_job_);
 }
 
 TEST_F(BackgroundFetchJobControllerTest, AbortJob) {
   BackgroundFetchRegistrationId registration_id;
-  std::vector<BackgroundFetchRequestInfo> initial_requests;
+  std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests;
 
   ASSERT_NO_FATAL_FAILURE(CreateRegistrationForRequests(
       &registration_id, &initial_requests,
       {{"https://example.com/sad_cat.png", "GET"}}));
 
   std::unique_ptr<BackgroundFetchJobController> controller =
       CreateJobController(registration_id);
 
   EXPECT_EQ(controller->state(),
             BackgroundFetchJobController::State::INITIALIZED);
@@ skipping 14 matching lines @@
 
   // TODO(peter): Verify that the issued download items have had their state
   // updated to be cancelled as well.
 
   EXPECT_EQ(controller->state(), BackgroundFetchJobController::State::ABORTED);
   EXPECT_TRUE(did_complete_job_);
 }
 
 }  // namespace
 }  // namespace content