Adjust scheduling for non-user requested items

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"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/time/time.h"
 #include "components/offline_pages/background/offliner_factory.h"
 #include "components/offline_pages/background/offliner_policy.h"
 #include "components/offline_pages/background/request_picker.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_model.h"
 
 namespace offline_pages {
 
 namespace {
+const bool kUserRequest = true;
 
 // Records the final request status UMA for an offlining request. This should
 // only be called once per Offliner::LoadAndSave request.
 void RecordOfflinerResultUMA(const ClientId& client_id,
                              Offliner::RequestStatus request_status) {
   // TODO(dougarnett): Consider exposing AddHistogramSuffix from
   // offline_page_model_impl.cc as visible utility method.
   std::string histogram_name("OfflinePages.Background.OfflinerRequestStatus");
   if (!client_id.name_space.empty()) {
     histogram_name += "." + client_id.name_space;
@@ skipping 99 matching lines @@
 
   if (active_request_) {
     RecordOfflinerResultUMA(active_request_->client_id(),
                             last_offlining_status_);
     is_busy_ = false;
     active_request_.reset();
   }
 
 }
 
+void RequestCoordinator::GetRequestsForSchedulingCallback(
+    RequestQueue::GetRequestsResult result,
+    const std::vector<SavePageRequest>& requests) {
+  bool user_requested = false;
+
+  // Examine all requests, if we find a user requested one, we will use the less
+  // restrictive conditions for user_requested requests.  Otherwise we will use
+  // the more restrictive non-user-requested conditions.
+  for (const SavePageRequest& request : requests) {
+    if (request.user_requested()) {
+      user_requested = true;
+      break;
+    }
+  }
+
+  // In the get callback, determine the least restrictive, and call
+  // GetTriggerConditions based on that.
+  scheduler_->Schedule(GetTriggerConditions(user_requested));
+}
+
 bool RequestCoordinator::CancelActiveRequestIfItMatches(
     const std::vector<int64_t>& request_ids) {
   // If we have a request in progress and need to cancel it, call the
   // pre-renderer to cancel.  TODO Make sure we remove any page created by the
   // prerenderer if it doesn't get the cancel in time.
   if (active_request_ != nullptr) {
     if (request_ids.end() != std::find(request_ids.begin(), request_ids.end(),
                                        active_request_->request_id())) {
       StopPrerendering();
       return true;
@@ skipping 27 matching lines @@
   if (canceled)
     TryNextRequest();
 }
 
 void RequestCoordinator::ResumeRequests(
     const std::vector<int64_t>& request_ids) {
   queue_->ChangeRequestsState(
       request_ids, SavePageRequest::RequestState::AVAILABLE,
       base::Bind(&RequestCoordinator::UpdateMultipleRequestsCallback,
                  weak_ptr_factory_.GetWeakPtr()));
-  scheduler_->Schedule(GetTriggerConditionsForUserRequest());
+  // Schedule a task, in case there is not one scheduled.
+  ScheduleAsNeeded();
 }
 
 net::NetworkChangeNotifier::ConnectionType
 RequestCoordinator::GetConnectionType() {
   // If we have a connection type set for test, use that.
   if (use_test_connection_type_)
     return test_connection_type_;
 
   return net::NetworkChangeNotifier::GetConnectionType();
 }
 
 void RequestCoordinator::AddRequestResultCallback(
     RequestQueue::AddRequestResult result,
     const SavePageRequest& request) {
   NotifyAdded(request);
-  // Inform the scheduler that we have an outstanding task..
-  scheduler_->Schedule(GetTriggerConditionsForUserRequest());
+  // Inform the scheduler that we have an outstanding task.
+  scheduler_->Schedule(GetTriggerConditions(kUserRequest));
 
   if (request.user_requested())
     StartProcessingIfConnected();
 }
 
 // Called in response to updating a request in the request queue.
 void RequestCoordinator::UpdateRequestCallback(
     const ClientId& client_id,
     RequestQueue::UpdateRequestResult result) {
   // If the request succeeded, nothing to do.  If it failed, we can't really do
@@ skipping 42 matching lines @@
 }
 
 void RequestCoordinator::HandleRemovedRequests(
     SavePageStatus status,
     const RequestQueue::UpdateMultipleRequestResults& results,
     const std::vector<SavePageRequest>& requests) {
   for (SavePageRequest request : requests)
     NotifyCompleted(request, status);
 }
 
+void RequestCoordinator::ScheduleAsNeeded() {
+  // Get all requests from queue (there is no filtering mechanism).
+  queue_->GetRequests(
+      base::Bind(&RequestCoordinator::GetRequestsForSchedulingCallback,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
 void RequestCoordinator::StopProcessing() {
   is_stopped_ = true;
   StopPrerendering();
 
   // Let the scheduler know we are done processing.
   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.
@@ skipping 40 matching lines @@
       base::TimeDelta::FromSeconds(
           policy_->GetBackgroundProcessingTimeBudgetSeconds())) {
     // Let the scheduler know we are done processing.
     scheduler_callback_.Run(true);
 
     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::RequestQueueEmpty,
-                 weak_ptr_factory_.GetWeakPtr()),
-      current_conditions_.get());
+  picker_->ChooseNextRequest(base::Bind(&RequestCoordinator::RequestPicked,
+                                        weak_ptr_factory_.GetWeakPtr()),
+                             base::Bind(&RequestCoordinator::RequestNotPicked,
+                                        weak_ptr_factory_.GetWeakPtr()),
+                             current_conditions_.get());
 }
 
 // Called by the request picker when a request has been picked.
 void RequestCoordinator::RequestPicked(const SavePageRequest& request) {
   // Send the request on to the offliner.
   SendRequestToOffliner(request);
 }
 
-void RequestCoordinator::RequestQueueEmpty() {
+void RequestCoordinator::RequestNotPicked(
+    bool non_user_requested_tasks_remaining) {
   // Clear the outstanding "safety" task in the scheduler.
   scheduler_->Unschedule();
+
+  if (non_user_requested_tasks_remaining)
+    scheduler_->Schedule(GetTriggerConditions(!kUserRequest));
   // Let the scheduler know we are done processing.
   scheduler_callback_.Run(true);
 }
 
 void RequestCoordinator::SendRequestToOffliner(const SavePageRequest& request) {
   // Check that offlining didn't get cancelled while performing some async
   // steps.
   if (is_stopped_)
     return;
 
@@ skipping 114 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.
       DCHECK(false);
   }
 }
 
-const Scheduler::TriggerConditions
-RequestCoordinator::GetTriggerConditionsForUserRequest() {
-  Scheduler::TriggerConditions trigger_conditions(
-      policy_->PowerRequiredForUserRequestedPage(),
-      policy_->BatteryPercentageRequiredForUserRequestedPage(),
-      policy_->UnmeteredNetworkRequiredForUserRequestedPage());
-  return trigger_conditions;
+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);
   observers_.AddObserver(observer);
 }
 
 void RequestCoordinator::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 11 matching lines @@
   FOR_EACH_OBSERVER(Observer, observers_, OnChanged(request));
 }
 
 void RequestCoordinator::GetOffliner() {
   if (!offliner_) {
     offliner_ = factory_->GetOffliner(policy_.get());
   }
 }
 
 }  // namespace offline_pages