Request Picker task

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 <limits>
 #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/sys_info.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/client_policy_controller.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;
 const int kMinDurationSeconds = 1;
@@ skipping 109 matching lines @@
 // are similar.
 int64_t GenerateOfflineId() {
   return base::RandGenerator(std::numeric_limits<int64_t>::max()) + 1;
 }
 
 // In case we start processing from SavePageLater, we need a callback, but there
 // is nothing for it to do.
 void EmptySchedulerCallback(bool started) {}
 
 // Returns whether |result| is a successful result for a single request.
-bool IsSingleSuccessResult(const UpdateRequestsResult* result) {
+bool IsSingleSuccessResult(const QueueResults::UpdateRequestsResult* result) {
   return result->store_state == StoreState::LOADED &&
          result->item_statuses.size() == 1 &&
          result->item_statuses.at(0).second == ItemActionStatus::SUCCESS;
 }
 
 }  // namespace
 
 RequestCoordinator::RequestCoordinator(
     std::unique_ptr<OfflinerPolicy> policy,
     std::unique_ptr<OfflinerFactory> factory,
@@ skipping 13 matching lines @@
       queue_(std::move(queue)),
       scheduler_(std::move(scheduler)),
       policy_controller_(new ClientPolicyController()),
       network_quality_estimator_(network_quality_estimator),
       active_request_(nullptr),
       last_offlining_status_(Offliner::RequestStatus::UNKNOWN),
       scheduler_callback_(base::Bind(&EmptySchedulerCallback)),
       immediate_schedule_callback_(base::Bind(&EmptySchedulerCallback)),
       weak_ptr_factory_(this) {
   DCHECK(policy_ != nullptr);
-  picker_.reset(
-      new RequestPicker(queue_.get(), policy_.get(), this, &event_logger_));
+  std::unique_ptr<PickRequestTaskBuilder> builder(
+      new PickRequestTaskBuilder(policy_.get(), this, &event_logger_));
+  queue_->SetPickerBuilder(builder);
 }
 
 RequestCoordinator::~RequestCoordinator() {}
 
 int64_t RequestCoordinator::SavePageLater(const GURL& url,
                                           const ClientId& client_id,
                                           bool user_requested,
                                           RequestAvailability availability) {
   DVLOG(2) << "URL is " << url << " " << __func__;
 
@@ skipping 29 matching lines @@
 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(
     const GetRequestsCallback& callback,
-    RequestQueue::GetRequestsResult result,
+    QueueResults::GetRequestsResult result,
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
   callback.Run(std::move(requests));
 }
 
 void RequestCoordinator::StopPrerendering(Offliner::RequestStatus stop_status) {
   if (offliner_ && is_busy_) {
     DCHECK(active_request_.get());
     offliner_->Cancel();
 
     // If we timed out, let the offliner done callback handle it.
@@ skipping 15 matching lines @@
                                        active_request_->request_id());
     RecordOfflinerResultUMA(active_request_->client_id(),
                             active_request_->creation_time(),
                             last_offlining_status_);
     is_busy_ = false;
     active_request_.reset();
   }
 }
 
 void RequestCoordinator::GetRequestsForSchedulingCallback(
-    RequestQueue::GetRequestsResult result,
+    QueueResults::GetRequestsResult result,
     std::vector<std::unique_ptr<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 auto& request : requests) {
     if (request->user_requested()) {
       user_requested = true;
       break;
@@ skipping 17 matching lines @@
       active_request_.reset(nullptr);
       return true;
     }
   }
 
   return false;
 }
 
 void RequestCoordinator::AbortRequestAttempt(SavePageRequest* request) {
   if (request->started_attempt_count() >= policy_->GetMaxStartedTries()) {
-    const BackgroundSavePageResult result(
-        BackgroundSavePageResult::START_COUNT_EXCEEDED);
+    const RequestNotifier::BackgroundSavePageResult result(
+        RequestNotifier::BackgroundSavePageResult::START_COUNT_EXCEEDED);
     event_logger_.RecordDroppedSavePageRequest(request->client_id().name_space,
                                                result, request->request_id());
     RemoveAttemptedRequest(*request, result);
   } else {
     queue_->MarkAttemptAborted(
         request->request_id(),
         base::Bind(&RequestCoordinator::MarkAttemptAbortedDone,
                    weak_ptr_factory_.GetWeakPtr(), request->request_id(),
                    request->client_id()));
   }
 }
 
 void RequestCoordinator::RemoveAttemptedRequest(
     const SavePageRequest& request,
-    BackgroundSavePageResult result) {
+    RequestNotifier::BackgroundSavePageResult result) {
   std::vector<int64_t> remove_requests;
   remove_requests.push_back(request.request_id());
   queue_->RemoveRequests(remove_requests,
                          base::Bind(&RequestCoordinator::HandleRemovedRequests,
                                     weak_ptr_factory_.GetWeakPtr(), result));
   RecordAttemptCount(request, result);
 }
 
 void RequestCoordinator::MarkAttemptAbortedDone(
     int64_t request_id,
     const ClientId& client_id,
-    std::unique_ptr<UpdateRequestsResult> result) {
+    std::unique_ptr<QueueResults::UpdateRequestsResult> result) {
   // If the request succeeded, nothing to do.  If it failed, we can't really do
   // much, so just log it.
   if (!IsSingleSuccessResult(result.get())) {
     DVLOG(1) << "Failed to mark request aborted: " << request_id;
-    RequestQueue::UpdateRequestResult request_result =
+    QueueResults::UpdateRequestResult request_result =
         result->store_state != StoreState::LOADED
-            ? RequestQueue::UpdateRequestResult::STORE_FAILURE
-            : RequestQueue::UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
+            ? QueueResults::UpdateRequestResult::STORE_FAILURE
+            : QueueResults::UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
     event_logger_.RecordUpdateRequestFailed(client_id.name_space,
                                             request_result);
   }
 }
 
 void RequestCoordinator::RemoveRequests(
     const std::vector<int64_t>& request_ids,
     const RemoveRequestsCallback& callback) {
   bool canceled = CancelActiveRequestIfItMatches(request_ids);
   queue_->RemoveRequests(
       request_ids,
       base::Bind(&RequestCoordinator::HandleRemovedRequestsAndCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback,
-                 BackgroundSavePageResult::REMOVED));
+                 RequestNotifier::BackgroundSavePageResult::REMOVED));
 
   // Record the network quality when this request is made.
   if (network_quality_estimator_) {
     UMA_HISTOGRAM_ENUMERATION(
         "OfflinePages.Background.EffectiveConnectionType.RemoveRequests",
         network_quality_estimator_->GetEffectiveConnectionType(),
         net::EFFECTIVE_CONNECTION_TYPE_LAST);
   }
 
   if (canceled)
@@ skipping 42 matching lines @@
 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,
+    QueueResults::AddRequestResult result,
     const SavePageRequest& request) {
   NotifyAdded(request);
   // Inform the scheduler that we have an outstanding task.
   scheduler_->Schedule(GetTriggerConditions(kUserRequest));
 
   if (request.user_requested())
     StartImmediatelyIfConnected();
 }
 
 void RequestCoordinator::MarkAttemptCompletedDoneCallback(
     int64_t request_id,
     const ClientId& client_id,
-    std::unique_ptr<UpdateRequestsResult> result) {
+    std::unique_ptr<QueueResults::UpdateRequestsResult> result) {
   if (IsSingleSuccessResult(result.get())) {
     NotifyChanged(result->updated_items.at(0));
   } else {
     DVLOG(1) << "Failed to mark request completed " << request_id;
-    RequestQueue::UpdateRequestResult request_result =
+    QueueResults::UpdateRequestResult request_result =
         result->store_state != StoreState::LOADED
-            ? RequestQueue::UpdateRequestResult::STORE_FAILURE
-            : RequestQueue::UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
+            ? QueueResults::UpdateRequestResult::STORE_FAILURE
+            : QueueResults::UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
     event_logger_.RecordUpdateRequestFailed(client_id.name_space,
                                             request_result);
   }
 }
 
 void RequestCoordinator::UpdateMultipleRequestsCallback(
-    std::unique_ptr<UpdateRequestsResult> result) {
+    std::unique_ptr<QueueResults::UpdateRequestsResult> result) {
   for (const auto& request : result->updated_items)
     NotifyChanged(request);
 
   bool available_user_request = false;
   for (const auto& request : result->updated_items) {
     if (!available_user_request && request.user_requested() &&
         request.request_state() == SavePageRequest::RequestState::AVAILABLE) {
       available_user_request = true;
     }
   }
 
   if (available_user_request)
     StartImmediatelyIfConnected();
 }
 
 // When we successfully remove a request that completed successfully, move on to
 // the next request.
 void RequestCoordinator::CompletedRequestCallback(
     const MultipleItemStatuses& status) {
   TryNextRequest();
 }
 
 void RequestCoordinator::HandleRemovedRequestsAndCallback(
     const RemoveRequestsCallback& callback,
-    BackgroundSavePageResult status,
-    std::unique_ptr<UpdateRequestsResult> result) {
+    RequestNotifier::BackgroundSavePageResult status,
+    std::unique_ptr<QueueResults::UpdateRequestsResult> result) {
   // TODO(dougarnett): Define status code for user/api cancel and use here
   // to determine whether to record cancel time UMA.
   for (const auto& request : result->updated_items)
     RecordCancelTimeUMA(request);
   callback.Run(result->item_statuses);
   HandleRemovedRequests(status, std::move(result));
 }
 
 void RequestCoordinator::HandleRemovedRequests(
-    BackgroundSavePageResult status,
-    std::unique_ptr<UpdateRequestsResult> result) {
+    RequestNotifier::BackgroundSavePageResult status,
+    std::unique_ptr<QueueResults::UpdateRequestsResult> result) {
   for (const auto& request : result->updated_items)
     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(
     Offliner::RequestStatus stop_status) {
   processing_state_ = ProcessingWindowState::STOPPED;
   StopPrerendering(stop_status);
 
   // Let the scheduler know we are done processing.
   scheduler_callback_.Run(true);
 }
 
 void RequestCoordinator::HandleWatchdogTimeout() {
   StopProcessing(Offliner::REQUEST_COORDINATOR_TIMED_OUT);
 }
 
 // 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) {
+  DVLOG(2) << "Scheduled " << __func__;
   return StartProcessingInternal(ProcessingWindowState::SCHEDULED_WINDOW,
                                  device_conditions, callback);
 }
 
 bool RequestCoordinator::StartProcessingInternal(
     const ProcessingWindowState processing_state,
     const DeviceConditions& device_conditions,
     const base::Callback<void(bool)>& callback) {
   current_conditions_.reset(new DeviceConditions(device_conditions));
   if (is_starting_ || is_busy_)
@@ skipping 13 matching lines @@
 
 void RequestCoordinator::StartImmediatelyIfConnected() {
   OfflinerImmediateStartStatus immediate_start_status = TryImmediateStart();
   UMA_HISTOGRAM_ENUMERATION(
       "OfflinePages.Background.ImmediateStartStatus", immediate_start_status,
       RequestCoordinator::OfflinerImmediateStartStatus::STATUS_COUNT);
 }
 
 RequestCoordinator::OfflinerImmediateStartStatus
 RequestCoordinator::TryImmediateStart() {
+  DVLOG(2) << "Immediate " << __func__;
   // Make sure not already busy processing.
   if (is_busy_)
     return OfflinerImmediateStartStatus::BUSY;
 
   // Make sure we are not on svelte device to start immediately.
   if (is_low_end_device_) {
     DVLOG(2) << "low end device, returning";
     // Let the scheduler know we are done processing and failed due to svelte.
     immediate_schedule_callback_.Run(false);
     return OfflinerImmediateStartStatus::NOT_STARTED_ON_SVELTE;
@@ skipping 34 matching lines @@
     is_starting_ = false;
 
     // Let the scheduler know we are done processing.
     // TODO: Make sure the scheduler callback is valid before running it.
     scheduler_callback_.Run(true);
     DVLOG(2) << " out of time, giving up. " << __func__;
 
     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(),
-                             disabled_requests_);
+  // Ask request queue to make a new PickRequestTask object, then put it on the
+  // task queue.
+  queue_->PickNextRequest(base::Bind(&RequestCoordinator::RequestPicked,
+                                     weak_ptr_factory_.GetWeakPtr()),
+                          base::Bind(&RequestCoordinator::RequestNotPicked,
+                                     weak_ptr_factory_.GetWeakPtr()),
+                          current_conditions_.get(), disabled_requests_);
+  // TODO(petewil): Verify current_conditions has a good value on all calling
+  // paths.  It is really more of a "last known conditions" than "current
+  // conditions".  Consider having a call to Java to check the current
+  // conditions.
 }
 
 // Called by the request picker when a request has been picked.
 void RequestCoordinator::RequestPicked(const SavePageRequest& request) {
   DVLOG(2) << request.url() << " " << __func__;
   is_starting_ = false;
 
   // Make sure we were not stopped while picking.
   if (processing_state_ != ProcessingWindowState::STOPPED) {
     // Send the request on to the offliner.
@@ skipping 47 matching lines @@
   queue_->MarkAttemptStarted(
       request.request_id(),
       base::Bind(&RequestCoordinator::StartOffliner,
                  weak_ptr_factory_.GetWeakPtr(), request.request_id(),
                  request.client_id().name_space));
 }
 
 void RequestCoordinator::StartOffliner(
     int64_t request_id,
     const std::string& client_namespace,
-    std::unique_ptr<UpdateRequestsResult> update_result) {
+    std::unique_ptr<QueueResults::UpdateRequestsResult> update_result) {
   if (update_result->store_state != StoreState::LOADED ||
       update_result->item_statuses.size() != 1 ||
       update_result->item_statuses.at(0).first != request_id ||
       update_result->item_statuses.at(0).second != ItemActionStatus::SUCCESS) {
     is_busy_ = false;
     // TODO(fgorski): what is the best result? Do we create a new status?
     StopProcessing(Offliner::PRERENDERING_NOT_STARTED);
     DVLOG(1) << "Failed to mark attempt started: " << request_id;
-    RequestQueue::UpdateRequestResult request_result =
+    QueueResults::UpdateRequestResult request_result =
         update_result->store_state != StoreState::LOADED
-            ? RequestQueue::UpdateRequestResult::STORE_FAILURE
-            : RequestQueue::UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
+            ? QueueResults::UpdateRequestResult::STORE_FAILURE
+            : QueueResults::UpdateRequestResult::REQUEST_DOES_NOT_EXIST;
     event_logger_.RecordUpdateRequestFailed(client_namespace, request_result);
     return;
   }
 
   // TODO(fgorski): Switch to request_id only, so that this value is not written
   // back to the store.
   active_request_.reset(
       new SavePageRequest(update_result->updated_items.at(0)));
 
   // Start the load and save process in the offliner (Async).
@@ skipping 41 matching lines @@
   if (status == Offliner::RequestStatus::FOREGROUND_CANCELED ||
       status == Offliner::RequestStatus::PRERENDERING_CANCELED) {
     // Update the request for the canceled attempt.
     // TODO(dougarnett): See if we can conclusively identify other attempt
     // aborted cases to treat this way (eg, for Render Process Killed).
     SavePageRequest updated_request(request);
     AbortRequestAttempt(&updated_request);
     NotifyChanged(updated_request);
   } else if (status == Offliner::RequestStatus::SAVED) {
     // Remove the request from the queue if it succeeded.
-    RemoveAttemptedRequest(request, BackgroundSavePageResult::SUCCESS);
+    RemoveAttemptedRequest(request,
+                           RequestNotifier::BackgroundSavePageResult::SUCCESS);
   } else if (status == Offliner::RequestStatus::PRERENDERING_FAILED_NO_RETRY) {
-    RemoveAttemptedRequest(request,
-                           BackgroundSavePageResult::PRERENDER_FAILURE);
+    RemoveAttemptedRequest(
+        request, RequestNotifier::BackgroundSavePageResult::PRERENDER_FAILURE);
   } else if (request.completed_attempt_count() + 1 >=
              policy_->GetMaxCompletedTries()) {
     // Remove from the request queue if we exceeded max retries. The +1
     // represents the request that just completed. Since we call
     // MarkAttemptCompleted within the if branches, the completed_attempt_count
     // has not yet been updated when we are checking the if condition.
-    const BackgroundSavePageResult result(
-        BackgroundSavePageResult::RETRY_COUNT_EXCEEDED);
+    const RequestNotifier::BackgroundSavePageResult result(
+        RequestNotifier::BackgroundSavePageResult::RETRY_COUNT_EXCEEDED);
     event_logger_.RecordDroppedSavePageRequest(request.client_id().name_space,
                                                result, request.request_id());
     RemoveAttemptedRequest(request, result);
   } else {
     // If we failed, but are not over the limit, update the request in the
     // queue.
     queue_->MarkAttemptCompleted(
         request.request_id(),
         base::Bind(&RequestCoordinator::MarkAttemptCompletedDoneCallback,
                    weak_ptr_factory_.GetWeakPtr(), request.request_id(),
@@ skipping 37 matching lines @@
 
 void RequestCoordinator::MarkRequestCompleted(int64_t request_id) {
   // Since the recent tab helper might call multiple times, ignore subsequent
   // calls for a particular request_id.
   if (disabled_requests_.find(request_id) == disabled_requests_.end())
     return;
   disabled_requests_.erase(request_id);
 
   // Remove the request, but send out SUCCEEDED instead of removed.
   std::vector<int64_t> request_ids { request_id };
-    queue_->RemoveRequests(
+  queue_->RemoveRequests(
       request_ids,
       base::Bind(&RequestCoordinator::HandleRemovedRequestsAndCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Bind(&RequestCoordinator::CompletedRequestCallback,
                             weak_ptr_factory_.GetWeakPtr()),
-                 BackgroundSavePageResult::SUCCESS));
+                 RequestNotifier::BackgroundSavePageResult::SUCCESS));
 }
 
 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);
 }
 
 void RequestCoordinator::NotifyAdded(const SavePageRequest& request) {
   for (Observer& observer : observers_)
     observer.OnAdded(request);
 }
 
-void RequestCoordinator::NotifyCompleted(const SavePageRequest& request,
-                                         BackgroundSavePageResult status) {
+void RequestCoordinator::NotifyCompleted(
+    const SavePageRequest& request,
+    RequestNotifier::BackgroundSavePageResult status) {
   for (Observer& observer : observers_)
     observer.OnCompleted(request, status);
 }
 
 void RequestCoordinator::NotifyChanged(const SavePageRequest& request) {
   for (Observer& observer : observers_)
     observer.OnChanged(request);
 }
 
 void RequestCoordinator::GetOffliner() {
   if (!offliner_) {
     offliner_ = factory_->GetOffliner(policy_.get());
   }
 }
 
 ClientPolicyController* RequestCoordinator::GetPolicyController() {
   return policy_controller_.get();
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages