Move all components/offline_pages/ files into component/offline_pages/core

components/offline_pages/background/offliner_policy.h

Index: components/offline_pages/background/offliner_policy.h
diff --git a/components/offline_pages/background/offliner_policy.h b/components/offline_pages/background/offliner_policy.h
deleted file mode 100644
index 7ffd45496a4704ca45ed28ea028837245029e612..0000000000000000000000000000000000000000
--- a/components/offline_pages/background/offliner_policy.h
+++ /dev/null
@@ -1,151 +0,0 @@
-// 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 {
-// The max number of started tries is to guard against pages that make the
-// prerenderer crash.  It should be greater than or equal to the max number of
-// completed tries.
-const int kMaxStartedTries = 5;
-// The number of max completed tries is based on Gin2G-poor testing showing that
-// we often need about 4 tries with a 2 minute window, or 3 retries with a 3
-// minute window. Also, we count one try now for foreground/disabled requests.
-const int kMaxCompletedTries = 3;
-// By the time we get to a week, the user has forgotten asking for a page.
-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_(true),
-        prefer_earlier_requests_(true),
-        retry_count_is_more_important_than_recency_(true),
-        max_started_tries_(kMaxStartedTries),
-        max_completed_tries_(kMaxCompletedTries),
-        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_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_; }
-
-  // Returns true if retry count is considered more important than recency in
-  // picking which request to try next.
-  bool RetryCountIsMoreImportantThanRecency() const {
-    return retry_count_is_more_important_than_recency_;
-  }
-
-  // The max number of times we will start a request.  Not all started attempts
-  // will complete.  This may be caused by prerenderer issues or chromium being
-  // swapped out of memory.
-  int GetMaxStartedTries() const { return max_started_tries_; }
-
-  // The max number of times we will retry a request when the attempt
-  // completed, but failed.
-  int GetMaxCompletedTries() const { return max_completed_tries_; }
-
-  bool PowerRequired(bool user_requested) const {
-    return (!user_requested);
-  }
-
-  bool UnmeteredNetworkRequired(bool user_requested) const {
-    return !(user_requested);
-  }
-
-  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
-  // return to the scheduler.
-  // 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_scheduled_processing_time_budget_;
-};
-}  // namespace offline_pages
-
-
-#endif  // COMPONENTS_OFFLINE_PAGES_BACKGROUND_OFFLINER_POLICY_H_