Remove old requests from queue, start new requests if any, add test.

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 50 matching lines @@
 void RequestCoordinator::AddRequestResultCallback(
     RequestQueue::AddRequestResult result,
     const SavePageRequest& request) {
 
   // Inform the scheduler that we have an outstanding task.
   // TODO(petewil): Define proper TriggerConditions and set them.
   Scheduler::TriggerCondition conditions;
   scheduler_->Schedule(conditions);
 }
 
+// Called in response to updating a request in the request queue.
+void RequestCoordinator::UpdateRequestCallback(
+    RequestQueue::UpdateRequestResult result) {}
+
+// Called by the request picker when a request has been picked.
 void RequestCoordinator::RequestPicked(const SavePageRequest& request) {
   Scheduler::TriggerCondition conditions;
 
   // Ensure that the scheduler has actively scheduled a task.
   scheduler_->Schedule(conditions);
 
   // Send the request on to the offliner.
   SendRequestToOffliner(request);
 }
 
 void RequestCoordinator::RequestQueueEmpty() {
-  // TODO(petewil): return to the BackgroundScheduler by calling
-  // ProcessingDoneCallback
+  // Clear the outstanding "safety" task in the scheduler.
+  scheduler_->Unschedule();
+  // Return control to the scheduler when there is no more to do.
+  scheduler_callback_.Run(true);
 }
 
 bool RequestCoordinator::StartProcessing(
     const base::Callback<void(bool)>& callback) {
+  scheduler_callback_ = callback;
   // TODO(petewil): Check existing conditions (should be passed down from
   // BackgroundTask)
 
+  TryNextRequest();
+
+  // TODO(petewil): Should return true if the caller should expect a
+  // callback.  Return false if there is already a request running.
+  // Probably best to do this when I prevent multiple instances from
+  // running at the same time.
+  return true;
+}
+
+void RequestCoordinator::TryNextRequest() {
   // Choose a request to process that meets the available conditions.
   // This is an async call, and returns right away.
   picker_->ChooseNextRequest(
       base::Bind(&RequestCoordinator::RequestPicked,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&RequestCoordinator::RequestQueueEmpty,
                  weak_ptr_factory_.GetWeakPtr()));
-  return false;
 }
 
 void RequestCoordinator::StopProcessing() {
 }
 
 void RequestCoordinator::SendRequestToOffliner(const SavePageRequest& request) {
   // TODO(petewil): Ensure only one offliner at a time is used.
   // TODO(petewil): When we have multiple offliners, we need to pick one.
   Offliner* offliner = factory_->GetOffliner(policy_.get());
   if (!offliner) {
     DVLOG(0) << "Unable to create Offliner. "
              << "Cannot background offline page.";
     return;
   }
 
   // Start the load and save process in the offliner (Async).
   offliner->LoadAndSave(request,
                         base::Bind(&RequestCoordinator::OfflinerDoneCallback,
                                    weak_ptr_factory_.GetWeakPtr()));
 }
 
 void RequestCoordinator::OfflinerDoneCallback(const SavePageRequest& request,
                                               Offliner::RequestStatus status) {
   DVLOG(2) << "offliner finished, saved: "
            << (status == Offliner::RequestStatus::SAVED) << ", "
            << __FUNCTION__;
   last_offlining_status_ = status;
 
-  // TODO(petewil): Check time budget.  Start a request if we have time, return
-  // to the scheduler if we are out of time.
+  // TODO(petewil): If the request succeeded, remove it from the Queue.
+  if (status == Offliner::RequestStatus::SAVED) {
+    queue_->RemoveRequest(request.request_id(),
+                          base::Bind(&RequestCoordinator::UpdateRequestCallback,
+                                     weak_ptr_factory_.GetWeakPtr()));
+  }
 
-  // TODO(petewil): If the request succeeded, remove it from the Queue.
+  // TODO(petewil): Check time budget. Return to the scheduler if we are out.
+
+
+  // Start a request if we have time.
+  TryNextRequest();
+
 }
 
 }  // namespace offline_pages