API changes to support suspending requests

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 87 matching lines @@
       offliner_timeout_(base::TimeDelta::FromSeconds(
           policy_->GetSinglePageTimeLimitInSeconds())),
       weak_ptr_factory_(this) {
   DCHECK(policy_ != nullptr);
   picker_.reset(
       new RequestPicker(queue_.get(), policy_.get(), this, &event_logger_));
 }
 
 RequestCoordinator::~RequestCoordinator() {}
 
-bool RequestCoordinator::SavePageLater(
-    const GURL& url, const ClientId& client_id, bool user_requested) {
+int64_t RequestCoordinator::SavePageLater(const GURL& url,
+                                          const ClientId& client_id,
+                                          bool user_requested,
+                                          RequestAvailability availability) {
   DVLOG(2) << "URL is " << url << " " << __func__;
 
   if (!OfflinePageModel::CanSaveURL(url)) {
     DVLOG(1) << "Not able to save page for requested url: " << url;
-    return false;
+    return 0L;
   }
 
   int64_t id = GenerateOfflineId();
 

[Dmitry Titov, 2016/10/05 22:28:19]

Lets add "DCHECK(id > 0);" here, just to be sure that GenerateOfflineId() still
conforms to this assumption.

[Pete Williamson, 2016/10/05 22:57:46]

Added DCHECK(id != 0) instead, since we use an int instead of a uint.

   // 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;
+  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.
   queue_->GetRequests(base::Bind(&RequestCoordinator::GetQueuedRequestsCallback,
                                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void RequestCoordinator::GetQueuedRequestsCallback(
@@ skipping 418 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::MakeAvailableToOffliner(int64_t 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));
 }
 
 void RequestCoordinator::AddObserver(Observer* observer) {
   DCHECK(observer);
@@ skipping 21 matching lines @@
   if (!offliner_) {
     offliner_ = factory_->GetOffliner(policy_.get());
   }
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages