[Offline Pages] Defines longer processing budget for immediate bg loads.

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 104 matching lines @@
 
 }  // namespace
 
 RequestCoordinator::RequestCoordinator(
     std::unique_ptr<OfflinerPolicy> policy,
     std::unique_ptr<OfflinerFactory> factory,
     std::unique_ptr<RequestQueue> queue,
     std::unique_ptr<Scheduler> scheduler,
     net::NetworkQualityEstimator::NetworkQualityProvider*
         network_quality_estimator)
-    : is_busy_(false),
+    : is_low_end_device_(base::SysInfo::IsLowEndDevice()),
+      is_busy_(false),
       is_starting_(false),
       processing_state_(ProcessingWindowState::STOPPED),
       use_test_connection_type_(false),
       test_connection_type_(),
       offliner_(nullptr),
       policy_(std::move(policy)),
       factory_(std::move(factory)),
       queue_(std::move(queue)),
       scheduler_(std::move(scheduler)),
       policy_controller_(new ClientPolicyController()),
@@ skipping 323 matching lines @@
       RequestCoordinator::OfflinerImmediateStartStatus::STATUS_COUNT);
 }
 
 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.
-  // Let the scheduler know we are done processing and failed due to svelte.
-  if (base::SysInfo::IsLowEndDevice()) {
+  if (is_low_end_device_) {
+    // 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) {
     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
     return OfflinerImmediateStartStatus::NOT_ACCEPTED;
 }
 
 void RequestCoordinator::TryNextRequest() {
+  base::TimeDelta processing_time_budget;
+  if (processing_state_ == ProcessingWindowState::SCHEDULED_WINDOW) {
+    processing_time_budget = base::TimeDelta::FromSeconds(
+        policy_->GetProcessingTimeBudgetWhenBackgroundScheduledInSeconds());
+  } else {
+    DCHECK(processing_state_ == ProcessingWindowState::IMMEDIATE_WINDOW);
+    processing_time_budget = base::TimeDelta::FromSeconds(
+        policy_->GetProcessingTimeBudgetForImmediateLoadInSeconds());
+  }
+
   // 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_ >
-      base::TimeDelta::FromSeconds(
-          policy_->GetBackgroundProcessingTimeBudgetSeconds())) {
+  if ((base::Time::Now() - operation_start_time_) > processing_time_budget) {
     is_starting_ = false;
 
     // 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.
@@ skipping 255 matching lines @@
 
 ClientPolicyController* RequestCoordinator::GetPolicyController() {
   return policy_controller_.get();
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages