Add the ability to cancel prerender reqeusts and tests

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 13 matching lines @@
     false /* require_power_connected */,
     50 /* minimum_battery_percentage */,
     false /* require_unmetered_network */);
 }  // namespace
 
 RequestCoordinator::RequestCoordinator(std::unique_ptr<OfflinerPolicy> policy,
                                        std::unique_ptr<OfflinerFactory> factory,
                                        std::unique_ptr<RequestQueue> queue,
                                        std::unique_ptr<Scheduler> scheduler)
     : is_busy_(false),
+      is_canceled_(false),
+      offliner_(nullptr),
       policy_(std::move(policy)),
       factory_(std::move(factory)),
       queue_(std::move(queue)),
       scheduler_(std::move(scheduler)),
       last_offlining_status_(Offliner::RequestStatus::UNKNOWN),
       weak_ptr_factory_(this) {
   DCHECK(policy_ != nullptr);
   picker_.reset(new RequestPicker(queue_.get()));
 }
 
@@ skipping 44 matching lines @@
   scheduler_callback_.Run(true);
 }
 
 // Returns true if the caller should expect a callback, false otherwise. For
 // instance, this would return false if a request is already in progress.
 bool RequestCoordinator::StartProcessing(
     const DeviceConditions& device_conditions,
     const base::Callback<void(bool)>& callback) {
   if (is_busy_) return false;
 
+  is_canceled_ = false;
   scheduler_callback_ = callback;
   // TODO(petewil): Check existing conditions (should be passed down from
   // BackgroundTask)
 
   TryNextRequest();
 
   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()));
 }
 
 void RequestCoordinator::StopProcessing() {
+  is_canceled_ = true;
+  if (offliner_ && is_busy_)
+    offliner_->Cancel();
 }
 
 Scheduler::TriggerConditions const&
 RequestCoordinator::GetTriggerConditionsForUserRequest() {
   return kUserRequestTriggerConditions;
 }
 
 void RequestCoordinator::SendRequestToOffliner(const SavePageRequest& request) {
-  // TODO(petewil): When we have multiple offliners, we need to pick one.
-  Offliner* offliner = factory_->GetOffliner(policy_.get());
-  if (!offliner) {
+  // Check that offlining didn't get cancelled while performing some async
+  // steps.
+  if (is_canceled_)
+    return;
+
+  GetOffliner();
+  if (!offliner_) {
     DVLOG(0) << "Unable to create Offliner. "
              << "Cannot background offline page.";
     return;
   }
 
   DCHECK(!is_busy_);
   is_busy_ = true;
 
   // Start the load and save process in the offliner (Async).
-  offliner->LoadAndSave(request,
-                        base::Bind(&RequestCoordinator::OfflinerDoneCallback,
-                                   weak_ptr_factory_.GetWeakPtr()));
+  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__;
+           << (status == Offliner::RequestStatus::SAVED) << ", status: "
+           << (int) status << ", " << __FUNCTION__;
   last_offlining_status_ = status;
 
   is_busy_ = false;
 
   // If the request succeeded, remove it from the Queue and maybe schedule
   // another one.
   if (status == Offliner::RequestStatus::SAVED) {
     queue_->RemoveRequest(request.request_id(),
                           base::Bind(&RequestCoordinator::UpdateRequestCallback,
                                      weak_ptr_factory_.GetWeakPtr()));
 
     // TODO(petewil): Check time budget. Return to the scheduler if we are out.
 
     // Start another request if we have time.
     TryNextRequest();
   }
 }
 
+void RequestCoordinator::GetOffliner() {
+    if (!offliner_) {
+      offliner_ = factory_->GetOffliner(policy_.get());
+    }
+}
+
 }  // namespace offline_pages