Implement disabled list

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 106 matching lines @@
     DVLOG(1) << "Not able to save page for requested url: " << url;
     return 0L;
   }
 
   int64_t id = GenerateOfflineId();
 
   // Build a SavePageRequest.
   offline_pages::SavePageRequest request(id, url, client_id, base::Time::Now(),
                                          user_requested);
 
+  // If the download manager is not done with the request, put it on the
+  // disabled list.
+  if (availability == RequestAvailability::DISABLED_FOR_OFFLINER)
+    disabled_requests_.insert(id);
+
   // Put the request on the request queue.
   queue_->AddRequest(request,
                      base::Bind(&RequestCoordinator::AddRequestResultCallback,
                                 weak_ptr_factory_.GetWeakPtr()));
   return id;
 }
 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.
@@ skipping 289 matching lines @@
 
     return;
   }
 
   // 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::RequestNotPicked,
                                         weak_ptr_factory_.GetWeakPtr()),
-                             current_conditions_.get());
+                             current_conditions_.get(),
+                             disabled_requests_);
 }
 
 // Called by the request picker when a request has been picked.
 void RequestCoordinator::RequestPicked(const SavePageRequest& request) {
   is_starting_ = false;
 
   // Make sure we were not stopped while picking.
   if (!is_stopped_) {
     // Send the request on to the offliner.
     SendRequestToOffliner(request);
@@ skipping 121 matching lines @@
     case Offliner::RequestStatus::PRERENDERING_FAILED:
       // No further processing in this service window.
       break;
     default:
       // Make explicit choice about new status codes that actually reach here.
       // Their default is no further processing in this service window.
       NOTREACHED();
   }
 }
 
-void RequestCoordinator::EnableForOffliner(int64_t request_id) {}
+void RequestCoordinator::EnableForOffliner(int64_t request_id) {
+    disabled_requests_.erase(request_id);
+}
 
 void RequestCoordinator::MarkRequestCompleted(int64_t request_id) {}
 
 const Scheduler::TriggerConditions RequestCoordinator::GetTriggerConditions(
     const bool user_requested) {
   return Scheduler::TriggerConditions(
       policy_->PowerRequired(user_requested),
       policy_->BatteryPercentageRequired(user_requested),
       policy_->UnmeteredNetworkRequired(user_requested));
 }
@@ skipping 28 matching lines @@
 
 ClientPolicyController* RequestCoordinator::GetPolicyController() {
   return policy_controller_.get();
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages