Adjust scheduling for non-user requested items

components/offline_pages/background/request_picker.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_picker.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "components/offline_pages/background/save_page_request.h"
 
@@ skipping 16 matching lines @@
       notifier_(notifier),
       fewer_retries_better_(false),
       earlier_requests_better_(false),
       weak_ptr_factory_(this) {}
 
 RequestPicker::~RequestPicker() {}
 
 // Entry point for the async operation to choose the next request.
 void RequestPicker::ChooseNextRequest(
     RequestCoordinator::RequestPickedCallback picked_callback,
-    RequestCoordinator::RequestQueueEmptyCallback empty_callback,
+    RequestCoordinator::RequestNotPickedCallback not_picked_callback,
     DeviceConditions* device_conditions) {
   picked_callback_ = picked_callback;
-  empty_callback_ = empty_callback;
+  not_picked_callback_ = not_picked_callback;
   fewer_retries_better_ = policy_->ShouldPreferUntriedRequests();
   earlier_requests_better_ = policy_->ShouldPreferEarlierRequests();
   current_conditions_.reset(new DeviceConditions(*device_conditions));
   // Get all requests from queue (there is no filtering mechanism).
   queue_->GetRequests(base::Bind(&RequestPicker::GetRequestResultCallback,
                                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 // When we get contents from the queue, use them to pick the next
 // request to operate on (if any).
 void RequestPicker::GetRequestResultCallback(
     RequestQueue::GetRequestsResult,
     const std::vector<SavePageRequest>& requests) {
   // If there is nothing to do, return right away.
   if (requests.size() == 0) {
-    empty_callback_.Run();
+    not_picked_callback_.Run(false);
     return;
   }
 
   // Get the expired requests to be removed from the queue, and the valid ones
   // from which to pick the next request.
   std::vector<SavePageRequest> valid_requests;
   std::vector<SavePageRequest> expired_requests;
   SplitRequests(requests, valid_requests, expired_requests);
   std::vector<int64_t> expired_request_ids;
   for (auto request : expired_requests)
     expired_request_ids.push_back(request.request_id());
 
   queue_->RemoveRequests(expired_request_ids,
                          base::Bind(&RequestPicker::OnRequestExpired,
                                     weak_ptr_factory_.GetWeakPtr()));
 
   // Pick the most deserving request for our conditions.
   const SavePageRequest* picked_request = nullptr;
 
   RequestCompareFunction comparator = nullptr;
 
   // Choose which comparison function to use based on policy.
   if (policy_->RetryCountIsMoreImportantThanRecency())
     comparator = &RequestPicker::RetryCountFirstCompareFunction;
   else
     comparator = &RequestPicker::RecencyFirstCompareFunction;
 
   // Iterate once through the requests, keeping track of best candidate.
+  bool non_user_requested_tasks_remaining = false;
   for (unsigned i = 0; i < valid_requests.size(); ++i) {
+    if (!valid_requests[i].user_requested())
+      non_user_requested_tasks_remaining = true;
     if (!RequestConditionsSatisfied(valid_requests[i]))
       continue;
     if (IsNewRequestBetter(picked_request, &(valid_requests[i]), comparator))
       picked_request = &(valid_requests[i]);
   }
 
   // If we have a best request to try next, get the request coodinator to
   // start it.  Otherwise return that we have no candidates.
   if (picked_request != nullptr) {
     picked_callback_.Run(*picked_request);
   } else {
-    empty_callback_.Run();
+    not_picked_callback_.Run(non_user_requested_tasks_remaining);
   }
 }
 
 // Filter out requests that don't meet the current conditions.  For instance, if
 // this is a predictive request, and we are not on WiFi, it should be ignored
 // this round.
 bool RequestPicker::RequestConditionsSatisfied(const SavePageRequest& request) {
   // If the user did not request the page directly, make sure we are connected
   // to power and have WiFi and sufficient battery remaining before we take this
   // request.
-  // TODO(petewil): We may later want to configure whether to allow 2G for non
-  // user_requested items, add that to policy.
-  if (!request.user_requested()) {
-    if (!current_conditions_->IsPowerConnected())
-      return false;
 
-    if (current_conditions_->GetNetConnectionType() !=
-        net::NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI) {
-      return false;
-    }
+  if (!current_conditions_->IsPowerConnected() &&
+      policy_->PowerRequired(request.user_requested())) {
+    return false;
+  }
 
-    if (current_conditions_->GetBatteryPercentage() <
-        policy_->GetMinimumBatteryPercentageForNonUserRequestOfflining()) {
-      return false;
-    }
+  if (current_conditions_->GetNetConnectionType() !=
+          net::NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI &&
+      policy_->UnmeteredNetworkRequired(request.user_requested())) {
+    return false;
+  }
+
+  if (current_conditions_->GetBatteryPercentage() <
+      policy_->BatteryPercentageRequired(request.user_requested())) {
+    return false;
   }
 
   // If we have already started this page the max number of times, it is not
   // eligible to try again.
   // TODO(petewil): We should have code to remove the page from the
   // queue after the last retry.
   if (request.started_attempt_count() >= policy_->GetMaxStartedTries())
     return false;
 
   // If we have already completed trying this page the max number of times, it
@@ skipping 124 matching lines @@
 // the coordinator.
 void RequestPicker::OnRequestExpired(
     const RequestQueue::UpdateMultipleRequestResults& results,
     const std::vector<SavePageRequest>& requests) {
   for (auto request : requests)
     notifier_->NotifyCompleted(request,
                                RequestCoordinator::SavePageStatus::EXPIRED);
 }
 
 }  // namespace offline_pages