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

components/offline_pages/background/offliner_policy.h

 // 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.
 
 #ifndef COMPONENTS_OFFLINE_PAGES_BACKGROUND_OFFLINER_POLICY_H_
 #define COMPONENTS_OFFLINE_PAGES_BACKGROUND_OFFLINER_POLICY_H_
 
 namespace {
 const int kMaxStartedTries = 4;
 const int kMaxCompletedTries = 1;
-const int kDefaultBackgroundProcessingTimeBudgetSeconds = 170;
-const int kSinglePageTimeLimitWhenBackgroundScheduledSeconds = 120;
-const int kSinglePageTimeLimitForImmediateLoadSeconds = 300;
 const int kRequestExpirationTimeInSeconds = 60 * 60 * 24 * 7;
+
+// Scheduled background processing time limits.
+const int kDozeModeBackgroundServiceWindowSeconds = 60 * 3;
+const int kDefaultBackgroundProcessingTimeBudgetSeconds =
+    kDozeModeBackgroundServiceWindowSeconds - 10;
+const int kSinglePageTimeLimitWhenBackgroundScheduledSeconds =
+    kDozeModeBackgroundServiceWindowSeconds - 10;
+
+// Immediate processing time limits.
+// Note: experiments on GIN-2g-poor show many page requests took 3 or 4
+// attempts in background scheduled mode with timeout of 2 minutes. So for
+// immediate processing mode, give page requests 4 times that limit (8 min).
+// Then budget up to 5 of those requests in processing window.
+const int kSinglePageTimeLimitForImmediateLoadSeconds = 60 * 8;
+const int kImmediateLoadProcessingTimeBudgetSeconds =
+    kSinglePageTimeLimitForImmediateLoadSeconds * 5;
 }  // namespace
 
 namespace offline_pages {
 
 // Policy for the Background Offlining system.  Some policy will belong to the
 // RequestCoordinator, some to the RequestQueue, and some to the Offliner.
 class OfflinerPolicy {
  public:
   OfflinerPolicy()
       : prefer_untried_requests_(false),
         prefer_earlier_requests_(true),
         retry_count_is_more_important_than_recency_(false),
         max_started_tries_(kMaxStartedTries),
         max_completed_tries_(kMaxCompletedTries),
-        background_processing_time_budget_(
+        background_scheduled_processing_time_budget_(
             kDefaultBackgroundProcessingTimeBudgetSeconds) {}
 
   // Constructor for unit tests.
   OfflinerPolicy(bool prefer_untried,
                  bool prefer_earlier,
                  bool prefer_retry_count,
                  int max_started_tries,
                  int max_completed_tries,
                  int background_processing_time_budget)
       : prefer_untried_requests_(prefer_untried),
         prefer_earlier_requests_(prefer_earlier),
         retry_count_is_more_important_than_recency_(prefer_retry_count),
         max_started_tries_(max_started_tries),
         max_completed_tries_(max_completed_tries),
-        background_processing_time_budget_(background_processing_time_budget) {}
+        background_scheduled_processing_time_budget_(
+            background_processing_time_budget) {}
 
   // TODO(petewil): Numbers here are chosen arbitrarily, do the proper studies
   // to get good policy numbers. Eventually this should get data from a finch
   // experiment.
 
   // Returns true if we should prefer retrying lesser tried requests.
   bool ShouldPreferUntriedRequests() const { return prefer_untried_requests_; }
 
   // Returns true if we should prefer older requests of equal number of tries.
   bool ShouldPreferEarlierRequests() const { return prefer_earlier_requests_; }
@@ skipping 23 matching lines @@
 
   int BatteryPercentageRequired(bool user_requested) const {
     if (user_requested)
       return 0;
     // This is so low because we require the device to be plugged in and
     // charging.  If we decide to allow non-user requested pages when not
     // plugged in, we should raise this somewhat higher.
     return 25;
   }
 
-  // How many seconds to keep trying new pages for, before we give up,  and
+  // How many seconds to keep trying new pages for, before we give up, and
   // return to the scheduler.
-  int GetBackgroundProcessingTimeBudgetSeconds() const {
-    return background_processing_time_budget_;
+  // TODO(dougarnett): Consider parameterizing these time limit/budget
+  // calls with processing mode.
+  int GetProcessingTimeBudgetWhenBackgroundScheduledInSeconds() const {
+    return background_scheduled_processing_time_budget_;
+  }
+
+  // How many seconds to keep trying new pages for, before we give up, when
+  // processing started immediately (without scheduler).
+  int GetProcessingTimeBudgetForImmediateLoadInSeconds() const {
+    return kImmediateLoadProcessingTimeBudgetSeconds;
   }
 
   // How long do we allow a page to load before giving up on it when
   // background loading was scheduled.
   int GetSinglePageTimeLimitWhenBackgroundScheduledInSeconds() const {
     return kSinglePageTimeLimitWhenBackgroundScheduledSeconds;
   }
 
   // How long do we allow a page to load before giving up on it when
   // immediately background loading.
   int GetSinglePageTimeLimitForImmediateLoadInSeconds() const {
     return kSinglePageTimeLimitForImmediateLoadSeconds;
   }
 
   // How long we allow requests to remain in the system before giving up.
   int GetRequestExpirationTimeInSeconds() const {
     return kRequestExpirationTimeInSeconds;
   }
 
  private:
   bool prefer_untried_requests_;
   bool prefer_earlier_requests_;
   bool retry_count_is_more_important_than_recency_;
   int max_started_tries_;
   int max_completed_tries_;
-  int background_processing_time_budget_;
+  int background_scheduled_processing_time_budget_;
 };
 }  // namespace offline_pages
 
 
 #endif  // COMPONENTS_OFFLINE_PAGES_BACKGROUND_OFFLINER_POLICY_H_