Store BackgroundFetchRequestInfo in a refcounted pointer

content/browser/background_fetch/background_fetch_data_manager_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_data_manager.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind_helpers.h"
@@ skipping 18 matching lines @@
             base::MakeUnique<BackgroundFetchDataManager>(browser_context())) {}
   ~BackgroundFetchDataManagerTest() override = default;
 
  protected:
   // Synchronous version of BackgroundFetchDataManager::CreateRegistration().
   void CreateRegistration(
       const BackgroundFetchRegistrationId& registration_id,
       const std::vector<ServiceWorkerFetchRequest>& requests,
       const BackgroundFetchOptions& options,
       blink::mojom::BackgroundFetchError* out_error,
-      std::vector<BackgroundFetchRequestInfo>* out_initial_requests) {
+      std::vector<scoped_refptr<BackgroundFetchRequestInfo>>*
+          out_initial_requests) {
     DCHECK(out_error);
 
     base::RunLoop run_loop;
     background_fetch_data_manager_->CreateRegistration(
         registration_id, requests, options,
         base::BindOnce(&BackgroundFetchDataManagerTest::DidCreateRegistration,
                        base::Unretained(this), run_loop.QuitClosure(),
                        out_error, out_initial_requests));
     run_loop.Run();
   }
 
   // Synchronous version of BackgroundFetchDataManager::DeleteRegistration().
   void DeleteRegistration(const BackgroundFetchRegistrationId& registration_id,
                           blink::mojom::BackgroundFetchError* out_error) {
     DCHECK(out_error);
 
     base::RunLoop run_loop;
     background_fetch_data_manager_->DeleteRegistration(
         registration_id,
         base::BindOnce(&BackgroundFetchDataManagerTest::DidDeleteRegistration,
                        base::Unretained(this), run_loop.QuitClosure(),
                        out_error));
     run_loop.Run();
   }
 
  private:
   void DidCreateRegistration(
       base::Closure quit_closure,
       blink::mojom::BackgroundFetchError* out_error,
-      std::vector<BackgroundFetchRequestInfo>* out_initial_requests,
+      std::vector<scoped_refptr<BackgroundFetchRequestInfo>>*
+          out_initial_requests,
       blink::mojom::BackgroundFetchError error,
-      std::vector<BackgroundFetchRequestInfo> initial_requests) {
+      std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests) {
     *out_error = error;
     *out_initial_requests = std::move(initial_requests);
 
     quit_closure.Run();
   }
 
   void DidDeleteRegistration(base::Closure quit_closure,
                              blink::mojom::BackgroundFetchError* out_error,
                              blink::mojom::BackgroundFetchError error) {
     *out_error = error;
 
     quit_closure.Run();
   }
 
   std::string job_guid_;
   std::unique_ptr<BackgroundFetchDataManager> background_fetch_data_manager_;
 };
 
 TEST_F(BackgroundFetchDataManagerTest, NoDuplicateRegistrations) {
   // Tests that the BackgroundFetchDataManager correctly rejects creating a
   // registration that's already known to the system.
 
   BackgroundFetchRegistrationId registration_id;
   ASSERT_TRUE(CreateRegistrationId(kExampleTag, &registration_id));
 
   std::vector<ServiceWorkerFetchRequest> requests;
   BackgroundFetchOptions options;
 
   blink::mojom::BackgroundFetchError error;
-  std::vector<BackgroundFetchRequestInfo> initial_requests;
+  std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests;
 
   // Deleting the not-yet-created registration should fail.
   ASSERT_NO_FATAL_FAILURE(DeleteRegistration(registration_id, &error));
   EXPECT_EQ(error, blink::mojom::BackgroundFetchError::INVALID_TAG);
 
   // Creating the initial registration should succeed.
   ASSERT_NO_FATAL_FAILURE(CreateRegistration(registration_id, requests, options,
                                              &error, &initial_requests));
   EXPECT_EQ(error, blink::mojom::BackgroundFetchError::NONE);
 
   // Attempting to create it again should yield an error.
   ASSERT_NO_FATAL_FAILURE(CreateRegistration(registration_id, requests, options,
                                              &error, &initial_requests));
   EXPECT_EQ(error, blink::mojom::BackgroundFetchError::DUPLICATED_TAG);
 
   // Deleting the registration should succeed.
   ASSERT_NO_FATAL_FAILURE(DeleteRegistration(registration_id, &error));
   EXPECT_EQ(error, blink::mojom::BackgroundFetchError::NONE);
 
   // And then recreating the registration again should work fine.
   ASSERT_NO_FATAL_FAILURE(CreateRegistration(registration_id, requests, options,
                                              &error, &initial_requests));
   EXPECT_EQ(error, blink::mojom::BackgroundFetchError::NONE);
 }
 
 }  // namespace content