Tune web page background fetching

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 <string>
 #include <utility>
 #include <vector>
@@ skipping 193 matching lines @@
     const GetRequestsCallback& callback,
     RequestQueue::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.
+    if (stop_status == Offliner::RequestStatus::REQUEST_COORDINATOR_TIMED_OUT) {

[dougarnett, 2016/10/26 23:23:26]

It would be good to break this change out into a separate CL and check with
evaluation pass. We might decide to only apply to IMMEDIATE_WINDOW initially or
add some retry support in order to keep success rate acceptable.

[Pete Williamson, 2016/10/28 00:39:44]

Done.  I think we should check it in anyway, since we now have an 8 minute
timeout, but I will put it in a separate changelist as you requested.

+      return;
+    }
+
+    // Otherwise, this attempt never really had a chance to run, mark it
+    // aborted.
     AbortRequestAttempt(active_request_.get());
   }
 
   // Stopping offliner means it will not call callback so set last status.
   last_offlining_status_ = stop_status;
 
   if (active_request_) {
     event_logger_.RecordOfflinerResult(active_request_->client_id().name_space,
                                        last_offlining_status_,
                                        active_request_->request_id());
@@ skipping 256 matching lines @@
 }
 
 RequestCoordinator::OfflinerImmediateStartStatus
 RequestCoordinator::TryImmediateStart() {
   // 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;
   }
 
-  // Make sure we have reasonable network quality (or at least a connection).
-  if (network_quality_estimator_) {
-    // TODO(dougarnett): Add UMA for quality type experienced.
-    net::EffectiveConnectionType quality =
-        network_quality_estimator_->GetEffectiveConnectionType();
-    if (quality < net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_2G)
-      return OfflinerImmediateStartStatus::WEAK_CONNECTION;
-  } else if (GetConnectionType() ==
-             net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE) {
+  if (GetConnectionType() ==
+             net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE)
     return OfflinerImmediateStartStatus::NO_CONNECTION;
-  }
 
   // Start processing with manufactured conservative battery conditions
   // (i.e., assume no battery).
   // TODO(dougarnett): Obtain actual battery conditions (from Android/Java).
 
   DeviceConditions device_conditions(false, 0, GetConnectionType());
   if (StartProcessingInternal(ProcessingWindowState::IMMEDIATE_WINDOW,
                               device_conditions, immediate_schedule_callback_))
     return OfflinerImmediateStartStatus::STARTED;
   else
@@ skipping 14 matching lines @@
   // If there is no time left in the budget, return to the scheduler.
   // We do not remove the pending task that was set up earlier in case
   // we run out of time, so the background scheduler will return to us
   // at the next opportunity to run background tasks.
   if ((base::Time::Now() - operation_start_time_) > processing_time_budget) {
     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_);
 }
 
 // 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.
     SendRequestToOffliner(request);
   }
 }
 
 void RequestCoordinator::RequestNotPicked(
     bool non_user_requested_tasks_remaining) {
+  DVLOG(2) << __func__;
   is_starting_ = false;
 
   // Clear the outstanding "safety" task in the scheduler.
   scheduler_->Unschedule();
 
   // If disabled tasks remain, post a new safety task for 5 sec from now.
   if (disabled_requests_.size() > 0) {
     scheduler_->BackupSchedule(GetTriggerConditions(kUserRequest),
                                kDisabledTaskRecheckSeconds);
   } else if (non_user_requested_tasks_remaining) {
@@ skipping 232 matching lines @@
 
 ClientPolicyController* RequestCoordinator::GetPolicyController() {
   return policy_controller_.get();
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages