| // Copyright 2018 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/core/prefetch/prefetch_prefs.h" |
| #include "base/time/time.h" |
| #include "components/offline_pages/core/offline_clock.h" |
| #include "components/offline_pages/core/offline_page_feature.h" |
| #include "components/prefs/pref_registry_simple.h" |
| #include "components/prefs/pref_service.h" |
| #include "components/version_info/version_info.h" |
| |
| namespace offline_pages { |
| namespace prefetch_prefs { |
| namespace { |
| // Prefs only accessed in this file |
| const char kLimitlessPrefetchingEnabledTimePref[] = |
| "offline_prefetch.limitless_prefetching_enabled_time"; |
| const char kPrefetchTestingHeaderPref[] = |
| "offline_prefetch.testing_header_value"; |
| const char kEnabledByServer[] = "offline_prefetch.enabled_by_server"; |
| const char kNextForbiddenCheckTimePref[] = "offline_prefetch.next_gpb_check"; |
| const base::TimeDelta kForbiddenCheckDelay = base::Days(7); |
| const char kPrefetchCachedGCMToken[] = "offline_prefetch.gcm_token"; |
| |
| } // namespace |
| |
| const char kUserSettingEnabled[] = "offline_prefetch.enabled"; |
| const char kBackoff[] = "offline_prefetch.backoff"; |
| |
| void RegisterPrefs(PrefRegistrySimple* registry) { |
| registry->RegisterListPref(kBackoff); |
| registry->RegisterBooleanPref(kUserSettingEnabled, true); |
| registry->RegisterTimePref(kLimitlessPrefetchingEnabledTimePref, |
| base::Time()); |
| registry->RegisterStringPref(kPrefetchTestingHeaderPref, std::string()); |
| registry->RegisterBooleanPref(kEnabledByServer, false); |
| registry->RegisterTimePref(kNextForbiddenCheckTimePref, base::Time()); |
| registry->RegisterStringPref(kPrefetchCachedGCMToken, std::string()); |
| } |
| |
| void SetPrefetchingEnabledInSettings(PrefService* prefs, bool enabled) { |
| prefs->SetBoolean(kUserSettingEnabled, enabled); |
| } |
| |
| bool IsPrefetchingEnabledInSettings(PrefService* prefs) { |
| return prefs->GetBoolean(kUserSettingEnabled); |
| } |
| |
| bool IsEnabled(PrefService* prefs) { |
| return IsPrefetchingOfflinePagesEnabled() && |
| prefs->GetBoolean(kUserSettingEnabled) && IsEnabledByServer(prefs); |
| } |
| |
| void SetLimitlessPrefetchingEnabled(PrefService* prefs, bool enabled) { |
| DCHECK(prefs); |
| if (enabled) |
| prefs->SetTime(kLimitlessPrefetchingEnabledTimePref, OfflineTimeNow()); |
| else |
| prefs->SetTime(kLimitlessPrefetchingEnabledTimePref, base::Time()); |
| } |
| |
| bool IsLimitlessPrefetchingEnabled(PrefService* prefs) { |
| base::TimeDelta max_duration; |
| if (version_info::IsOfficialBuild()) |
| max_duration = base::Days(1); |
| else |
| max_duration = base::Days(365); |
| |
| DCHECK(prefs); |
| const base::Time enabled_time = |
| prefs->GetTime(kLimitlessPrefetchingEnabledTimePref); |
| const base::Time now = OfflineTimeNow(); |
| |
| return (now >= enabled_time) && (now < (enabled_time + max_duration)); |
| } |
| |
| void SetPrefetchTestingHeader(PrefService* prefs, const std::string& value) { |
| DCHECK(prefs); |
| prefs->SetString(kPrefetchTestingHeaderPref, value); |
| } |
| |
| std::string GetPrefetchTestingHeader(PrefService* prefs) { |
| DCHECK(prefs); |
| return prefs->GetString(kPrefetchTestingHeaderPref); |
| } |
| |
| bool IsForbiddenCheckDue(PrefService* prefs) { |
| DCHECK(prefs); |
| base::Time checkTime = prefs->GetTime(kNextForbiddenCheckTimePref); |
| return IsPrefetchingOfflinePagesEnabled() && |
| prefs->GetBoolean(kUserSettingEnabled) && !IsEnabledByServer(prefs) && |
| (checkTime < OfflineTimeNow() || // did the delay expire? |
| checkTime > |
| OfflineTimeNow() + |
| kForbiddenCheckDelay); // is the next time unreasonably far |
| // in the future (e.g. clock change)? |
| } |
| |
| bool IsEnabledByServerUnknown(PrefService* prefs) { |
| DCHECK(prefs); |
| return IsForbiddenCheckDue(prefs) && |
| (prefs->GetTime(kNextForbiddenCheckTimePref) == base::Time()); |
| } |
| |
| void SetEnabledByServer(PrefService* prefs, bool enabled) { |
| DCHECK(prefs); |
| prefs->SetBoolean(kEnabledByServer, enabled); |
| if (!enabled) { |
| prefs->SetTime(kNextForbiddenCheckTimePref, |
| OfflineTimeNow() + kForbiddenCheckDelay); |
| } |
| } |
| |
| bool IsEnabledByServer(PrefService* prefs) { |
| DCHECK(prefs); |
| return prefs->GetBoolean(kEnabledByServer); |
| } |
| |
| void ResetForbiddenStateForTesting(PrefService* prefs) { |
| DCHECK(prefs); |
| SetEnabledByServer(prefs, false); |
| prefs->SetTime(kNextForbiddenCheckTimePref, base::Time()); |
| } |
| |
| void SetCachedPrefetchGCMToken(PrefService* prefs, const std::string& value) { |
| DCHECK(prefs); |
| prefs->SetString(kPrefetchCachedGCMToken, value); |
| } |
| |
| std::string GetCachedPrefetchGCMToken(PrefService* prefs) { |
| DCHECK(prefs); |
| return prefs->GetString(kPrefetchCachedGCMToken); |
| } |
| |
| } // namespace prefetch_prefs |
| } // namespace offline_pages |