[Background Fetch] Tidy up getting/activating pending requests

content/browser/background_fetch/background_fetch_context.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_context.h"
 
 #include "base/memory/ptr_util.h"
 #include "content/browser/background_fetch/background_fetch_data_manager.h"
 #include "content/browser/background_fetch/background_fetch_event_dispatcher.h"
 #include "content/browser/background_fetch/background_fetch_job_controller.h"
@@ skipping 58 matching lines @@
       registration_id, requests, options,
       base::BindOnce(&BackgroundFetchContext::DidCreateRegistration,
                      weak_factory_.GetWeakPtr(), registration_id, options,
                      std::move(callback)));
 }
 
 void BackgroundFetchContext::DidCreateRegistration(
     const BackgroundFetchRegistrationId& registration_id,
     const BackgroundFetchOptions& options,
     blink::mojom::BackgroundFetchService::FetchCallback callback,
-    blink::mojom::BackgroundFetchError error,
-    std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests) {
+    blink::mojom::BackgroundFetchError error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   RecordRegistrationCreatedError(error);
   if (error != blink::mojom::BackgroundFetchError::NONE) {
     std::move(callback).Run(error, base::nullopt /* registration */);
     return;
   }
 
   // Create the BackgroundFetchJobController, which will do the actual fetching.
-  CreateController(registration_id, options, std::move(initial_requests));
+  CreateController(registration_id, options);
 
   // Create the BackgroundFetchRegistration the renderer process will receive,
   // which enables it to resolve the promise telling the developer it worked.
   BackgroundFetchRegistration registration;
   registration.tag = registration_id.tag();
   registration.icons = options.icons;
   registration.title = options.title;
   registration.total_download_size = options.total_download_size;
 
   std::move(callback).Run(blink::mojom::BackgroundFetchError::NONE,
@@ skipping 34 matching lines @@
   if (controller->state() == BackgroundFetchJobController::State::ABORTED ||
       controller->state() == BackgroundFetchJobController::State::COMPLETED) {
     return nullptr;
   }
 
   return controller;
 }
 
 void BackgroundFetchContext::CreateController(
     const BackgroundFetchRegistrationId& registration_id,
-    const BackgroundFetchOptions& options,
-    std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests) {
+    const BackgroundFetchOptions& options) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("background_fetch_context", R"(
         semantics {
           sender: "Background Fetch API"
           description:
             "The Background Fetch API enables developers to upload or download "
             "files on behalf of the user. Such fetches will yield a user "
             "visible notification to inform the user of the operation, through "
@@ skipping 19 matching lines @@
       base::MakeUnique<BackgroundFetchJobController>(
           registration_id, options, data_manager_.get(), browser_context_,
           request_context_getter_,
           base::BindOnce(&BackgroundFetchContext::DidCompleteJob,
                          weak_factory_.GetWeakPtr()),
           traffic_annotation);
 
   // TODO(peter): We should actually be able to use Background Fetch in layout
   // tests. That requires a download manager and a request context.
   if (request_context_getter_) {
-    // Start fetching the |initial_requests| immediately. At some point in the
+    // Start fetching the first few requests immediately. At some point in the
     // future we may want a more elaborate scheduling mechanism here.
-    controller->Start(std::move(initial_requests));
+    controller->Start();
   }
 
   active_fetches_.insert(
       std::make_pair(registration_id, std::move(controller)));
 }
 
 void BackgroundFetchContext::DidCompleteJob(
     BackgroundFetchJobController* controller) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 63 matching lines @@
 
   // Delete all persistent information associated with the |registration_id|.
   data_manager_->DeleteRegistration(
       registration_id, base::BindOnce(&RecordRegistrationDeletedError));
 
   // Delete the local state associated with the |registration_id|.
   active_fetches_.erase(registration_id);
 }
 
 }  // namespace content