[Background Fetch] Tidy up getting/activating pending requests

content/browser/background_fetch/background_fetch_data_manager.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 <algorithm>
 #include <queue>
 
 #include "base/memory/ptr_util.h"
@@ skipping 36 matching lines @@
       pending_requests_.push(std::move(request));
     }
   }
 
   ~RegistrationData() = default;
 
   // Returns whether there are remaining requests on the request queue.
   bool HasPendingRequests() const { return !pending_requests_.empty(); }
 
   // Consumes a request from the queue that is to be fetched.
-  scoped_refptr<BackgroundFetchRequestInfo> GetPendingRequest() {
+  scoped_refptr<BackgroundFetchRequestInfo> ActivateNextPendingRequest() {
     DCHECK(!pending_requests_.empty());
 
     auto request = pending_requests_.front();
     pending_requests_.pop();
 
     // The |request| is considered to be active now.
     active_requests_.push_back(request);
 
     return request;
   }
@@ skipping 71 matching lines @@
 }
 
 void BackgroundFetchDataManager::CreateRegistration(
     const BackgroundFetchRegistrationId& registration_id,
     const std::vector<ServiceWorkerFetchRequest>& requests,
     const BackgroundFetchOptions& options,
     CreateRegistrationCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (registrations_.find(registration_id) != registrations_.end()) {
-    std::move(callback).Run(
-        blink::mojom::BackgroundFetchError::DUPLICATED_TAG,
-        std::vector<scoped_refptr<BackgroundFetchRequestInfo>>());
+    std::move(callback).Run(blink::mojom::BackgroundFetchError::DUPLICATED_TAG);
     return;
   }
 
-  std::unique_ptr<RegistrationData> registration_data =
-      base::MakeUnique<RegistrationData>(requests, options);
-
-  // Create a vector with the initial requests to feed the Job Controller with.
-  std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests;
-  for (size_t i = 0; i < kMaximumBackgroundFetchParallelRequests; ++i) {
-    if (!registration_data->HasPendingRequests())
-      break;
-
-    initial_requests.push_back(registration_data->GetPendingRequest());
-  }
-
-  // Store the created |registration_data| so that we can easily access it.
-  registrations_.insert(
-      std::make_pair(registration_id, std::move(registration_data)));
+  // Create the |RegistrationData|, and store it for easy access.
+  registrations_.insert(std::make_pair(
+      registration_id, base::MakeUnique<RegistrationData>(requests, options)));
 
   // Inform the |callback| of the newly created registration.
-  std::move(callback).Run(blink::mojom::BackgroundFetchError::NONE,
-                          std::move(initial_requests));
+  std::move(callback).Run(blink::mojom::BackgroundFetchError::NONE);
+}
+
+void BackgroundFetchDataManager::ActivateNextRequest(
+    const BackgroundFetchRegistrationId& registration_id,
+    NextRequestCallback callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  auto iter = registrations_.find(registration_id);
+  DCHECK(iter != registrations_.end());
+
+  RegistrationData* registration_data = iter->second.get();
+
+  scoped_refptr<BackgroundFetchRequestInfo> next_request;
+  if (registration_data->HasPendingRequests())
+    next_request = registration_data->ActivateNextPendingRequest();
+
+  std::move(callback).Run(std::move(next_request));
 }
 
 void BackgroundFetchDataManager::MarkRequestAsStarted(
     const BackgroundFetchRegistrationId& registration_id,
     BackgroundFetchRequestInfo* request,
     const std::string& download_guid) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   auto iter = registrations_.find(registration_id);
   DCHECK(iter != registrations_.end());
 
   RegistrationData* registration_data = iter->second.get();
   registration_data->MarkRequestAsStarted(request, download_guid);
 }
 
-void BackgroundFetchDataManager::MarkRequestAsCompleteAndGetNextRequest(
+void BackgroundFetchDataManager::MarkRequestAsCompleteAndActivateNextRequest(
     const BackgroundFetchRegistrationId& registration_id,
     BackgroundFetchRequestInfo* request,
     NextRequestCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   auto iter = registrations_.find(registration_id);
   DCHECK(iter != registrations_.end());
 
   RegistrationData* registration_data = iter->second.get();
   registration_data->MarkRequestAsComplete(request);
 
-  scoped_refptr<BackgroundFetchRequestInfo> next_request;
-  if (registration_data->HasPendingRequests())
-    next_request = registration_data->GetPendingRequest();
-
-  std::move(callback).Run(std::move(next_request));
+  ActivateNextRequest(registration_id, std::move(callback));
 }
 
 void BackgroundFetchDataManager::GetSettledFetchesForRegistration(
     const BackgroundFetchRegistrationId& registration_id,
     SettledFetchesCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   auto iter = registrations_.find(registration_id);
   DCHECK(iter != registrations_.end());
 
@@ skipping 77 matching lines @@
     std::move(callback).Run(blink::mojom::BackgroundFetchError::INVALID_TAG);
     return;
   }
 
   registrations_.erase(iter);
 
   std::move(callback).Run(blink::mojom::BackgroundFetchError::NONE);
 }
 
 }  // namespace content