[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> PopNextPendingRequest() {
     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;
   }
 
   // Marks the |request| as having started with the given |download_guid|.
   // Persistent storage needs to store the association so we can resume fetches
   // after a browser restart, here we just verify that the |request| is active.
   void MarkRequestAsStarted(BackgroundFetchRequestInfo* request,
                             const std::string& download_guid) {
     const auto iter = std::find_if(
         active_requests_.begin(), active_requests_.end(),
         [&request](scoped_refptr<BackgroundFetchRequestInfo> active_request) {
           return active_request->request_index() == request->request_index();
         });
 
     // The |request| must have been consumed from this RegistrationData.
     DCHECK(iter != active_requests_.end());
   }
 
   // Marks the |request| as having completed. Verifies that the |request| is
   // currently active and moves it to the |completed_requests_| vector.
-  void MarkRequestAsComplete(BackgroundFetchRequestInfo* request) {
+  bool MarkRequestAsComplete(BackgroundFetchRequestInfo* request) {
     const auto iter = std::find_if(
         active_requests_.begin(), active_requests_.end(),
         [&request](scoped_refptr<BackgroundFetchRequestInfo> active_request) {
           return active_request->request_index() == request->request_index();
         });
 
     // The |request| must have been consumed from this RegistrationData.
     DCHECK(iter != active_requests_.end());
 
     completed_requests_.push_back(*iter);
     active_requests_.erase(iter);
+
+    bool has_pending_or_active_requests =
+        !pending_requests_.empty() || !active_requests_.empty();
+    return has_pending_or_active_requests;
   }
 
   // Returns the vector with all completed requests part of this registration.
   const std::vector<scoped_refptr<BackgroundFetchRequestInfo>>&
   GetCompletedRequests() const {
     return completed_requests_;
   }
 
  private:
   BackgroundFetchOptions options_;
@@ skipping 31 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::PopNextRequest(
+    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->PopNextPendingRequest();
+
+  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::MarkRequestAsComplete(
     const BackgroundFetchRegistrationId& registration_id,
     BackgroundFetchRequestInfo* request,
-    NextRequestCallback callback) {
+    MarkedCompleteCallback 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);
+  bool has_pending_or_active_requests =
+      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));
+  std::move(callback).Run(has_pending_or_active_requests);
 }
 
 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