Changes to fit better with the needs of the download manager.

components/offline_pages/background/request_coordinator.cc

 // Copyright 2016 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 "components/offline_pages/background/request_coordinator.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 72 matching lines @@
   // Build a SavePageRequest.
   offline_pages::SavePageRequest request(
       id++, url, client_id, base::Time::Now(), user_requested);
 
   // Put the request on the request queue.
   queue_->AddRequest(request,
                      base::Bind(&RequestCoordinator::AddRequestResultCallback,
                                 weak_ptr_factory_.GetWeakPtr()));
   return true;
 }
-void RequestCoordinator::GetQueuedRequests(
-    const std::string& client_namespace,
-    const QueuedRequestCallback& callback) {
+void RequestCoordinator::GetAllRequests(const GetRequestsCallback& callback) {
   // Get all matching requests from the request queue, send them to our
   // callback.  We bind the namespace and callback to the front of the callback
   // param set.
   queue_->GetRequests(base::Bind(&RequestCoordinator::GetQueuedRequestsCallback,
-                                 weak_ptr_factory_.GetWeakPtr(),
-                                 client_namespace, callback));
+                                 weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
-// For each request matching the client_namespace, return the ClientId.
 void RequestCoordinator::GetQueuedRequestsCallback(
-    const std::string& client_namespace,
-    const QueuedRequestCallback& callback,
+    const GetRequestsCallback& callback,
     RequestQueue::GetRequestsResult result,
     const std::vector<SavePageRequest>& requests) {
-  std::vector<ClientId> client_ids;
-
-  for (const auto& request : requests) {
-    if (client_namespace == request.client_id().name_space)
-      client_ids.push_back(request.client_id());
-  }
-
-  callback.Run(client_ids);
+  callback.Run(requests);
 }
 
 void RequestCoordinator::RemoveRequests(
-    const std::vector<ClientId>& client_ids) {
-  queue_->RemoveRequestsByClientId(
-      client_ids, base::Bind(&RequestCoordinator::UpdateMultipleRequestCallback,
-                             weak_ptr_factory_.GetWeakPtr()));
+    const std::vector<int64_t>& request_ids) {
+  queue_->RemoveRequests(request_ids,
+                         base::Bind(&RequestCoordinator::RemoveRequestsCallback,
+                                    weak_ptr_factory_.GetWeakPtr()));
 }
 
 void RequestCoordinator::AddRequestResultCallback(
     RequestQueue::AddRequestResult result,
     const SavePageRequest& request) {
 
   // Inform the scheduler that we have an outstanding task..
   scheduler_->Schedule(GetTriggerConditionsForUserRequest());
 }
 
@@ skipping 14 matching lines @@
 void RequestCoordinator::UpdateMultipleRequestCallback(
     RequestQueue::UpdateRequestResult result) {
   // If the request succeeded, nothing to do.  If it failed, we can't really do
   // much, so just log it.
   if (result != RequestQueue::UpdateRequestResult::SUCCESS) {
     DVLOG(1) << "Failed to update request attempt details. "
              << static_cast<int>(result);
   }
 }
 
+void RequestCoordinator::RemoveRequestsCallback(
+    const RequestQueue::UpdateMultipleRequestResults& results) {
+  // TODO(petewil): Today the RemoveRequests API does not come with a callback.
+  // Should we add one?  Perhaps the notifications from the observer will be
+  // sufficient.
+}
+
 void RequestCoordinator::StopProcessing() {
   is_canceled_ = true;
   if (offliner_ && is_busy_) {
     // TODO(dougarnett): Find current request and mark attempt aborted.
     offliner_->Cancel();
   }
 
   // Stopping offliner means it will not call callback.
   last_offlining_status_ =
       Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED;
@@ skipping 134 matching lines @@
                                      updated_request.client_id()));
 
   } else if (status == Offliner::RequestStatus::SAVED ||
              request.completed_attempt_count() + 1 >=
                  policy_->GetMaxCompletedTries()) {
     // Remove the request from the queue if it either succeeded or exceeded the
     // max number of retries.  The +1 represents the request that just
     // completed. Since we call MarkAttemptCompleted within the if branches,
     // the completed_attempt_count has not yet been updated when we are checking
     // the if condition.
-    queue_->RemoveRequest(
-        request.request_id(),
-        base::Bind(&RequestCoordinator::UpdateRequestCallback,
-                   weak_ptr_factory_.GetWeakPtr(), request.client_id()));
+    std::vector<int64_t> remove_requests;
+    remove_requests.push_back(request.request_id());
+    queue_->RemoveRequests(
+        remove_requests, base::Bind(&RequestCoordinator::RemoveRequestsCallback,
+                                    weak_ptr_factory_.GetWeakPtr()));
   } else {
     // If we failed, but are not over the limit, update the request in the
     // queue.
     SavePageRequest updated_request(request);
     updated_request.MarkAttemptCompleted();
     queue_->UpdateRequest(updated_request,
                           base::Bind(&RequestCoordinator::UpdateRequestCallback,
                                      weak_ptr_factory_.GetWeakPtr(),
                                      updated_request.client_id()));
   }
@@ skipping 31 matching lines @@
   return trigger_conditions;
 }
 
 void RequestCoordinator::GetOffliner() {
   if (!offliner_) {
     offliner_ = factory_->GetOffliner(policy_.get());
   }
 }
 
 }  // namespace offline_pages