Skip to content

GitLab

T
tangled
Commit c84819af authored by Sebastien Marchand's avatar Sebastien Marchand Committed by Commit Bot
Browse files
Options

Switch tab_manager_features to the FeatureParams API 

This is a cleanup that replaces the really long feature parameters names
used in tab_manager_features.h/cc by several FeatureParam objects.


Bug: 844426
Change-Id: Ia37d00d2de3f0ff756fa365108bbcab4a91d184c
Reviewed-on: https://chromium-review.googlesource.com/1195852Reviewed-by: default avatarChris Hamilton <chrisha@chromium.org>
Reviewed-by: default avatarAlexei Svitkine <asvitkine@chromium.org>
Reviewed-by: default avatarFrançois Doray <fdoray@chromium.org>
Commit-Queue: Sébastien Marchand <sebmarchand@chromium.org>
Cr-Commit-Position: refs/heads/master@{#591360}
parent b074c3fe
Hide whitespace changes
Inline Side-by-side
Showing with 390 additions and 468 deletions
chrome/browser/about_flags.cc
View file @ c84819af
......@@ -1218,13 +1218,13 @@ const FeatureEntry::FeatureVariation
#if !defined(OS_ANDROID)
const FeatureEntry::FeatureParam kProactiveTabFreezeAndDiscard_FreezeOnly[] = {
{resource_coordinator::
kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardParam,
{resource_coordinator::ProactiveTabFreezeAndDiscardParams::
kShouldProactivelyDiscard.name,
"false"}};
const FeatureEntry::FeatureParam
kProactiveTabFreezeAndDiscard_FreezeAndDiscard[] = {
{resource_coordinator::
kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardParam,
{resource_coordinator::ProactiveTabFreezeAndDiscardParams::
kShouldProactivelyDiscard.name,
"true"}};
const FeatureEntry::FeatureVariation kProactiveTabFreezeAndDiscardVariations[] =
{{"Freeze only", kProactiveTabFreezeAndDiscard_FreezeOnly,
......@@ -4235,7 +4235,7 @@ const FeatureEntry kFeatureEntries[] = {
FEATURE_WITH_PARAMS_VALUE_TYPE(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscardVariations,
resource_coordinator::kProactiveTabFreezeAndDiscardFeatureName)},
features::kProactiveTabFreezeAndDiscard.name)},
{"site-characteristics-database",
flag_descriptions::kSiteCharacteristicsDatabaseName,
flag_descriptions::kSiteCharacteristicsDatabaseDescription, kOsDesktop,
......
chrome/browser/resource_coordinator/tab_manager_features.cc
View file @ c84819af
......@@ -30,8 +30,7 @@ const base::Feature kInfiniteSessionRestore{"InfiniteSessionRestore",
// Enables proactive tab freezing and discarding.
const base::Feature kProactiveTabFreezeAndDiscard{
resource_coordinator::kProactiveTabFreezeAndDiscardFeatureName,
base::FEATURE_DISABLED_BY_DEFAULT};
"ProactiveTabFreezeAndDiscard", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the site characteristics database.
const base::Feature kSiteCharacteristicsDatabase{
......@@ -65,10 +64,8 @@ namespace {
int GetModerateThresholdTabCountBasedOnSystemMemory(
ProactiveTabFreezeAndDiscardParams* params,
int memory_in_gb) {
int moderate_loaded_tab_count_per_gb = base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamParam,
kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamDefault);
int moderate_loaded_tab_count_per_gb =
ProactiveTabFreezeAndDiscardParams::kModerateLoadedTabsPerGbRam.Get();
int moderate_level = moderate_loaded_tab_count_per_gb * memory_in_gb;
......@@ -81,146 +78,63 @@ int GetModerateThresholdTabCountBasedOnSystemMemory(
} // namespace
const char kProactiveTabFreezeAndDiscardFeatureName[] =
"ProactiveTabFreezeAndDiscard";
// Field-trial parameter names for proactive tab discarding.
const char kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardParam[] =
"ShouldProactivelyDiscard";
const char kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeParam[] =
"ShouldPeriodicallyUnfreeze";
const char
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceParam
[] = "ShouldProtectTabsSharingBrowsingInstance";
const char kProactiveTabFreezeAndDiscard_LowLoadedTabCountParam[] =
"LowLoadedTabCount";
const char kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamParam[] =
"ModerateLoadedTabsPerGbRam";
const char kProactiveTabFreezeAndDiscard_HighLoadedTabCountParam[] =
"HighLoadedTabCount";
const char kProactiveTabFreezeAndDiscard_LowOccludedTimeoutParam[] =
"LowOccludedTimeoutSeconds";
const char kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutParam[] =
"ModerateOccludedTimeoutSeconds";
const char kProactiveTabFreezeAndDiscard_HighOccludedTimeoutParam[] =
"HighOccludedTimeoutSeconds";
const char kProactiveTabFreezeAndDiscard_FreezeTimeoutParam[] = "FreezeTimeout";
const char kProactiveTabFreezeAndDiscard_UnfreezeTimeoutParam[] =
"UnfreezeTimeout";
const char kProactiveTabFreezeAndDiscard_RefreezeTimeoutParam[] =
"RefreezeTimeout";
// Field-trial parameter names for the site characteristics database.
const char kSiteCharacteristicsDb_FaviconUpdateObservationWindow[] =
"FaviconUpdateObservationWindow";
const char kSiteCharacteristicsDb_TitleUpdateObservationWindow[] =
"TitleUpdateObservationWindow";
const char kSiteCharacteristicsDb_AudioUsageObservationWindow[] =
"AudioUsageObservationWindow";
const char kSiteCharacteristicsDb_NotificationsUsageObservationWindow[] =
"NotificationsUsageObservationWindow";
const char kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod[] =
"TitleOrFaviconChangeGracePeriod";
const char kSiteCharacteristicsDb_AudioUsageGracePeriod[] =
"AudioUsageGracePeriod";
const char kInfiniteSessionRestore_MinSimultaneousTabLoads[] =
"MinSimultaneousTabLoads";
const char kInfiniteSessionRestore_MaxSimultaneousTabLoads[] =
"MaxSimultaneousTabLoads";
const char kInfiniteSessionRestore_CoresPerSimultaneousTabLoad[] =
"CoresPerSimultaneousTabLoad";
const char kInfiniteSessionRestore_MinTabsToRestore[] = "MinTabsToRestore";
const char kInfiniteSessionRestore_MaxTabsToRestore[] = "MaxTabsToRestore";
const char kInfiniteSessionRestore_MbFreeMemoryPerTabToRestore[] =
"MbFreeMemoryPerTabToRestore";
const char kInfiniteSessionRestore_MaxTimeSinceLastUseToRestore[] =
"MaxTimeSinceLastUseToRestore";
const char kInfiniteSessionRestore_MinSiteEngagementToRestore[] =
"MinSiteEngagementToRestore";
// Default values for ProactiveTabFreezeAndDiscardParams.
const bool kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardDefault =
false;
const bool kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeDefault =
false;
const bool
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceDefault =
true;
// 50% of people cap out at 4 tabs, so for them proactive discarding won't even
// be invoked. See Tabs.MaxTabsInADay.
// TODO(chrisha): This should eventually be informed by the number of tabs
// typically used over a given time horizon (metric being developed).
const uint32_t kProactiveTabFreezeAndDiscard_LowLoadedTabCountDefault = 4;
// Testing in the lab shows that 2GB devices suffer beyond 6 tabs, and 4GB
// devices suffer beyond about 12 tabs. As a very simple first step, we'll aim
// at allowing 3 tabs per GB of RAM on a system before proactive discarding
// kicks in. This is a system resource dependent max, which is combined with the
// DefaultMaxLoadedTabCount to determine the max on a system.
const uint32_t kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamDefault =
3;
// 99.9% of people cap out with fewer than this number, so only 0.1% of the
// population should ever encounter proactive discarding based on this cap.
const uint32_t kProactiveTabFreezeAndDiscard_HighLoadedTabCountDefault = 100;
// Current discarding uses 10 minutes as a minimum cap. This uses exponentially
// increasing timeouts beyond that.
const base::TimeDelta kProactiveTabFreezeAndDiscard_LowOccludedTimeoutDefault =
base::TimeDelta::FromHours(6);
const base::TimeDelta
kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutDefault =
base::TimeDelta::FromHours(1);
const base::TimeDelta kProactiveTabFreezeAndDiscard_HighOccludedTimeoutDefault =
base::TimeDelta::FromMinutes(10);
const base::TimeDelta kProactiveTabFreezeAndDiscard_FreezeTimeoutDefault =
base::TimeDelta::FromMinutes(10);
const base::TimeDelta kProactiveTabFreezeAndDiscard_UnfreezeTimeoutDefault =
base::TimeDelta::FromMinutes(15);
const base::TimeDelta kProactiveTabFreezeAndDiscard_RefreezeTimeoutDefault =
base::TimeDelta::FromSeconds(10);
// Default values for SiteCharacteristicsDatabaseParams.
//
// Observations windows have a default value of 2 hours, 95% of backgrounded
// tabs don't use any of these features in this time window.
const base::TimeDelta
kSiteCharacteristicsDb_FaviconUpdateObservationWindow_Default =
base::TimeDelta::FromHours(2);
const base::TimeDelta
kSiteCharacteristicsDb_TitleUpdateObservationWindow_Default =
base::TimeDelta::FromHours(2);
const base::TimeDelta
kSiteCharacteristicsDb_AudioUsageObservationWindow_Default =
base::TimeDelta::FromHours(2);
const base::TimeDelta
kSiteCharacteristicsDb_NotificationsUsageObservationWindow_Default =
base::TimeDelta::FromHours(2);
// TODO(sebmarchand): Get some real-world data and choose an appropriate value
// here.
const base::TimeDelta
kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod_Default =
base::TimeDelta::FromSeconds(20);
const base::TimeDelta kSiteCharacteristicsDb_AudioUsageGracePeriod_Default =
base::TimeDelta::FromSeconds(10);
// Default values for infinite session restore feature. Many of these are taken
// from thin air, but others are motivated by existing metrics.
const uint32_t kInfiniteSessionRestore_MinSimultaneousTabLoadsDefault = 1;
const uint32_t kInfiniteSessionRestore_MaxSimultaneousTabLoadsDefault = 4;
const uint32_t kInfiniteSessionRestore_CoresPerSimultaneousTabLoadDefault = 2;
const uint32_t kInfiniteSessionRestore_MinTabsToRestoreDefault = 4;
const uint32_t kInfiniteSessionRestore_MaxTabsToRestoreDefault = 20;
// This is the 75th percentile of Memory.Renderer.PrivateMemoryFootprint.
const uint32_t kInfiniteSessionRestore_MbFreeMemoryPerTabToRestoreDefault = 150;
// This is the 75th percentile of SessionRestore.RestoredTab.TimeSinceActive.
const base::TimeDelta
kInfiniteSessionRestore_MaxTimeSinceLastUseToRestoreDefault =
base::TimeDelta::FromHours(6);
// Taken from an informal survey of Googlers on min engagement of things they
// think *must* load. Note that about 25% of session-restore tabs fall above
// this threshold (see SessionRestore.RestoredTab.SiteEngagementScore).
const uint32_t kInfiniteSessionRestore_MinSiteEngagementToRestoreDefault = 15;
// Instantiate the feature parameters for proactive tab discarding.
constexpr base::FeatureParam<bool>
ProactiveTabFreezeAndDiscardParams::kShouldProactivelyDiscard;
constexpr base::FeatureParam<bool>
ProactiveTabFreezeAndDiscardParams::kShouldPeriodicallyUnfreeze;
constexpr base::FeatureParam<bool> ProactiveTabFreezeAndDiscardParams::
kShouldProtectTabsSharingBrowsingInstance;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kLowLoadedTabCount;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kModerateLoadedTabsPerGbRam;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kHighLoadedTabCount;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kLowOccludedTimeout;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kModerateOccludedTimeout;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kHighOccludedTimeout;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kFreezeTimeout;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kUnfreezeTimeout;
constexpr base::FeatureParam<int>
ProactiveTabFreezeAndDiscardParams::kRefreezeTimeout;
// Instantiate the feature parameters for the site characteristics database.
constexpr base::FeatureParam<int>
SiteCharacteristicsDatabaseParams::kFaviconUpdateObservationWindow;
constexpr base::FeatureParam<int>
SiteCharacteristicsDatabaseParams::kTitleUpdateObservationWindow;
constexpr base::FeatureParam<int>
SiteCharacteristicsDatabaseParams::kAudioUsageObservationWindow;
constexpr base::FeatureParam<int>
SiteCharacteristicsDatabaseParams::kNotificationsUsageObservationWindow;
constexpr base::FeatureParam<int>
SiteCharacteristicsDatabaseParams::kTitleOrFaviconChangeGracePeriod;
constexpr base::FeatureParam<int>
SiteCharacteristicsDatabaseParams::kAudioUsageGracePeriod;
// Instantiate the feature parameters for infinite session restore.
constexpr base::FeatureParam<int>
InfiniteSessionRestoreParams::kMinSimultaneousTabLoads;
constexpr base::FeatureParam<int>
InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads;
constexpr base::FeatureParam<int>
InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad;
constexpr base::FeatureParam<int>
InfiniteSessionRestoreParams::kMinTabsToRestore;
constexpr base::FeatureParam<int>
InfiniteSessionRestoreParams::kMaxTabsToRestore;
constexpr base::FeatureParam<int>
InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore;
constexpr base::FeatureParam<int>
InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore;
constexpr base::FeatureParam<int>
InfiniteSessionRestoreParams::kMinSiteEngagementToRestore;
ProactiveTabFreezeAndDiscardParams::ProactiveTabFreezeAndDiscardParams() =
default;
......@@ -240,74 +154,44 @@ ProactiveTabFreezeAndDiscardParams GetProactiveTabFreezeAndDiscardParams(
int memory_in_gb) {
ProactiveTabFreezeAndDiscardParams params = {};
params.should_proactively_discard = base::GetFieldTrialParamByFeatureAsBool(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardParam,
kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardDefault);
params.should_proactively_discard =
ProactiveTabFreezeAndDiscardParams::kShouldProactivelyDiscard.Get();
params.should_periodically_unfreeze = base::GetFieldTrialParamByFeatureAsBool(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeParam,
kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeDefault);
params.should_periodically_unfreeze =
ProactiveTabFreezeAndDiscardParams::kShouldPeriodicallyUnfreeze.Get();
params.should_protect_tabs_sharing_browsing_instance =
base::GetFieldTrialParamByFeatureAsBool(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceParam,
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceDefault);
ProactiveTabFreezeAndDiscardParams::
kShouldProtectTabsSharingBrowsingInstance.Get();
params.low_loaded_tab_count = base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_LowLoadedTabCountParam,
kProactiveTabFreezeAndDiscard_LowLoadedTabCountDefault);
params.low_loaded_tab_count =
ProactiveTabFreezeAndDiscardParams::kLowLoadedTabCount.Get();
params.high_loaded_tab_count = base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_HighLoadedTabCountParam,
kProactiveTabFreezeAndDiscard_HighLoadedTabCountDefault);
params.high_loaded_tab_count =
ProactiveTabFreezeAndDiscardParams::kHighLoadedTabCount.Get();
// |moderate_loaded_tab_count| determined after |high_loaded_tab_count| so it
// can be enforced that it is lower than |high_loaded_tab_count|.
params.moderate_loaded_tab_count =
GetModerateThresholdTabCountBasedOnSystemMemory(&params, memory_in_gb);
params.low_occluded_timeout =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_LowOccludedTimeoutParam,
kProactiveTabFreezeAndDiscard_LowOccludedTimeoutDefault.InSeconds()));
params.moderate_occluded_timeout =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutParam,
kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutDefault
.InSeconds()));
params.high_occluded_timeout =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_HighOccludedTimeoutParam,
kProactiveTabFreezeAndDiscard_HighOccludedTimeoutDefault
.InSeconds()));
params.freeze_timeout =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_FreezeTimeoutParam,
kProactiveTabFreezeAndDiscard_FreezeTimeoutDefault.InSeconds()));
params.unfreeze_timeout =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_UnfreezeTimeoutParam,
kProactiveTabFreezeAndDiscard_UnfreezeTimeoutDefault.InSeconds()));
params.refreeze_timeout =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kProactiveTabFreezeAndDiscard,
kProactiveTabFreezeAndDiscard_RefreezeTimeoutParam,
kProactiveTabFreezeAndDiscard_RefreezeTimeoutDefault.InSeconds()));
params.low_occluded_timeout = base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kLowOccludedTimeout.Get());
params.moderate_occluded_timeout = base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kModerateOccludedTimeout.Get());
params.high_occluded_timeout = base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kHighOccludedTimeout.Get());
params.freeze_timeout = base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kFreezeTimeout.Get());
params.unfreeze_timeout = base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kUnfreezeTimeout.Get());
params.refreeze_timeout = base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kRefreezeTimeout.Get());
return params;
}
......@@ -339,46 +223,25 @@ base::TimeDelta GetTabLoadTimeout(const base::TimeDelta& default_timeout) {
SiteCharacteristicsDatabaseParams GetSiteCharacteristicsDatabaseParams() {
SiteCharacteristicsDatabaseParams params = {};
params.favicon_update_observation_window =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kSiteCharacteristicsDatabase,
kSiteCharacteristicsDb_FaviconUpdateObservationWindow,
kSiteCharacteristicsDb_FaviconUpdateObservationWindow_Default
.InSeconds()));
params.title_update_observation_window =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kSiteCharacteristicsDatabase,
kSiteCharacteristicsDb_TitleUpdateObservationWindow,
kSiteCharacteristicsDb_TitleUpdateObservationWindow_Default
.InSeconds()));
params.audio_usage_observation_window =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kSiteCharacteristicsDatabase,
kSiteCharacteristicsDb_AudioUsageObservationWindow,
kSiteCharacteristicsDb_AudioUsageObservationWindow_Default
.InSeconds()));
params.notifications_usage_observation_window =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kSiteCharacteristicsDatabase,
kSiteCharacteristicsDb_NotificationsUsageObservationWindow,
kSiteCharacteristicsDb_NotificationsUsageObservationWindow_Default
.InSeconds()));
params.title_or_favicon_change_grace_period =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kSiteCharacteristicsDatabase,
kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod,
kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod_Default
.InSeconds()));
params.audio_usage_grace_period =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kSiteCharacteristicsDatabase,
kSiteCharacteristicsDb_AudioUsageGracePeriod,
kSiteCharacteristicsDb_AudioUsageGracePeriod_Default.InSeconds()));
params.favicon_update_observation_window = base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kFaviconUpdateObservationWindow.Get());
params.title_update_observation_window = base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kTitleUpdateObservationWindow.Get());
params.audio_usage_observation_window = base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kAudioUsageObservationWindow.Get());
params.notifications_usage_observation_window = base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kNotificationsUsageObservationWindow
.Get());
params.title_or_favicon_change_grace_period = base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kTitleOrFaviconChangeGracePeriod
.Get());
params.audio_usage_grace_period = base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kAudioUsageGracePeriod.Get());
return params;
}
......@@ -393,43 +256,22 @@ GetStaticSiteCharacteristicsDatabaseParams() {
InfiniteSessionRestoreParams GetInfiniteSessionRestoreParams() {
InfiniteSessionRestoreParams params = {};
params.min_simultaneous_tab_loads = base::GetFieldTrialParamByFeatureAsInt(
features::kInfiniteSessionRestore,
kInfiniteSessionRestore_MinSimultaneousTabLoads,
kInfiniteSessionRestore_MinSimultaneousTabLoadsDefault);
params.max_simultaneous_tab_loads = base::GetFieldTrialParamByFeatureAsInt(
features::kInfiniteSessionRestore,
kInfiniteSessionRestore_MaxSimultaneousTabLoads,
kInfiniteSessionRestore_MaxSimultaneousTabLoadsDefault);
params.min_simultaneous_tab_loads =
InfiniteSessionRestoreParams::kMinSimultaneousTabLoads.Get();
params.max_simultaneous_tab_loads =
InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads.Get();
params.cores_per_simultaneous_tab_load =
base::GetFieldTrialParamByFeatureAsInt(
features::kInfiniteSessionRestore,
kInfiniteSessionRestore_CoresPerSimultaneousTabLoad,
kInfiniteSessionRestore_CoresPerSimultaneousTabLoadDefault);
params.min_tabs_to_restore = base::GetFieldTrialParamByFeatureAsInt(
features::kInfiniteSessionRestore,
kInfiniteSessionRestore_MinTabsToRestore,
kInfiniteSessionRestore_MinTabsToRestoreDefault);
params.max_tabs_to_restore = base::GetFieldTrialParamByFeatureAsInt(
features::kInfiniteSessionRestore,
kInfiniteSessionRestore_MaxTabsToRestore,
kInfiniteSessionRestore_MaxTabsToRestoreDefault);
InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad.Get();
params.min_tabs_to_restore =
InfiniteSessionRestoreParams::kMinTabsToRestore.Get();
params.max_tabs_to_restore =
InfiniteSessionRestoreParams::kMaxTabsToRestore.Get();
params.mb_free_memory_per_tab_to_restore =
base::GetFieldTrialParamByFeatureAsInt(
features::kInfiniteSessionRestore,
kInfiniteSessionRestore_MbFreeMemoryPerTabToRestore,
kInfiniteSessionRestore_MbFreeMemoryPerTabToRestoreDefault);
params.max_time_since_last_use_to_restore =
base::TimeDelta::FromSeconds(base::GetFieldTrialParamByFeatureAsInt(
features::kInfiniteSessionRestore,
kInfiniteSessionRestore_MaxTimeSinceLastUseToRestore,
kInfiniteSessionRestore_MaxTimeSinceLastUseToRestoreDefault
.InSeconds()));
InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore.Get();
params.max_time_since_last_use_to_restore = base::TimeDelta::FromSeconds(
InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore.Get());
params.min_site_engagement_to_restore =
base::GetFieldTrialParamByFeatureAsInt(
features::kInfiniteSessionRestore,
kInfiniteSessionRestore_MinSiteEngagementToRestore,
kInfiniteSessionRestore_MinSiteEngagementToRestoreDefault);
InfiniteSessionRestoreParams::kMinSiteEngagementToRestore.Get();
return params;
}
......
chrome/browser/resource_coordinator/tab_manager_features.h
View file @ c84819af
......@@ -6,6 +6,7 @@
#define CHROME_BROWSER_RESOURCE_COORDINATOR_TAB_MANAGER_FEATURES_H_
#include "base/feature_list.h"
#include "base/metrics/field_trial_params.h"
#include "base/no_destructor.h"
#include "base/sys_info.h"
#include "base/time/time.h"
......@@ -24,101 +25,6 @@ extern const base::Feature kTabRanker;
namespace resource_coordinator {
// The name of the ProactiveTabFreezeAndDiscard feature.
extern const char kProactiveTabFreezeAndDiscardFeatureName[];
// Variations parameter names related to proactive discarding.
// See ProactiveTabFreezeAndDiscardsParams for details.
//
// TODO(sebmarchand): Use the base::FeatureParam API here.
extern const char kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardParam[];
extern const char
kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeParam[];
extern const char
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceParam
[];
extern const char kProactiveTabFreezeAndDiscard_LowLoadedTabCountParam[];
extern const char
kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamParam[];
extern const char kProactiveTabFreezeAndDiscard_HighLoadedTabCountParam[];
extern const char kProactiveTabFreezeAndDiscard_LowOccludedTimeoutParam[];
extern const char kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutParam[];
extern const char kProactiveTabFreezeAndDiscard_HighOccludedTimeoutParam[];
extern const char kProactiveTabFreezeAndDiscard_FreezeTimeoutParam[];
extern const char kProactiveTabFreezeAndDiscard_UnfreezeTimeoutParam[];
extern const char kProactiveTabFreezeAndDiscard_RefreezeTimeoutParam[];
// Variations parameter names related to the site characteristics database.
// See ProactiveTabFreezeAndDiscardsParams for details.
extern const char kSiteCharacteristicsDb_FaviconUpdateObservationWindow[];
extern const char kSiteCharacteristicsDb_TitleUpdateObservationWindow[];
extern const char kSiteCharacteristicsDb_AudioUsageObservationWindow[];
extern const char kSiteCharacteristicsDb_NotificationsUsageObservationWindow[];
extern const char kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod[];
extern const char kSiteCharacteristicsDb_AudioUsageGracePeriod[];
// Variation parameter names related to infinite session restore.
extern const char kInfiniteSessionRestore_MinSimultaneousTabLoads[];
extern const char kInfiniteSessionRestore_MaxSimultaneousTabLoads[];
extern const char kInfiniteSessionRestore_CoresPerSimultaneousTabLoad[];
extern const char kInfiniteSessionRestore_MinTabsToRestore[];
extern const char kInfiniteSessionRestore_MaxTabsToRestore[];
extern const char kInfiniteSessionRestore_MbFreeMemoryPerTabToRestore[];
// This is expressed in seconds.
extern const char kInfiniteSessionRestore_MaxTimeSinceLastUseToRestore[];
extern const char kInfiniteSessionRestore_MinSiteEngagementToRestore[];
// Default values of parameters related to the site characteristics database.
// See ProactiveTabFreezeAndDiscardsParams for details.
extern const bool kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardDefault;
extern const bool
kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeDefault;
extern const bool
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceDefault;
extern const uint32_t kProactiveTabFreezeAndDiscard_LowLoadedTabCountDefault;
extern const uint32_t
kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamDefault;
extern const uint32_t kProactiveTabFreezeAndDiscard_HighLoadedTabCountDefault;
extern const base::TimeDelta
kProactiveTabFreezeAndDiscard_LowOccludedTimeoutDefault;
extern const base::TimeDelta
kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutDefault;
extern const base::TimeDelta
kProactiveTabFreezeAndDiscard_HighOccludedTimeoutDefault;
extern const base::TimeDelta kProactiveTabFreezeAndDiscard_FreezeTimeoutDefault;
extern const base::TimeDelta
kProactiveTabFreezeAndDiscard_UnfreezeTimeoutDefault;
extern const base::TimeDelta
kProactiveTabFreezeAndDiscard_RefreezeTimeoutDefault;
// Default values of parameters related to the site characteristics database.
// See SiteCharacteristicsDatabaseParams for details.
extern const base::TimeDelta
kSiteCharacteristicsDb_FaviconUpdateObservationWindow_Default;
extern const base::TimeDelta
kSiteCharacteristicsDb_TitleUpdateObservationWindow_Default;
extern const base::TimeDelta
kSiteCharacteristicsDb_AudioUsageObservationWindow_Default;
extern const base::TimeDelta
kSiteCharacteristicsDb_NotificationsUsageObservationWindow_Default;
extern const base::TimeDelta
kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod_Default;
extern const base::TimeDelta
kSiteCharacteristicsDb_AudioUsageGracePeriod_Default;
// Default values for infinite session restore feature.
extern const uint32_t kInfiniteSessionRestore_MinSimultaneousTabLoadsDefault;
extern const uint32_t kInfiniteSessionRestore_MaxSimultaneousTabLoadsDefault;
extern const uint32_t
kInfiniteSessionRestore_CoresPerSimultaneousTabLoadDefault;
extern const uint32_t kInfiniteSessionRestore_MinTabsToRestoreDefault;
extern const uint32_t kInfiniteSessionRestore_MaxTabsToRestoreDefault;
extern const uint32_t
kInfiniteSessionRestore_MbFreeMemoryPerTabToRestoreDefault;
extern const base::TimeDelta
kInfiniteSessionRestore_MaxTimeSinceLastUseToRestoreDefault;
extern const uint32_t kInfiniteSessionRestore_MinSiteEngagementToRestoreDefault;
// Parameters used by the proactive tab discarding feature.
//
// Proactive discarding has 5 key parameters:
......@@ -159,6 +65,59 @@ struct ProactiveTabFreezeAndDiscardParams {
ProactiveTabFreezeAndDiscardParams(
const ProactiveTabFreezeAndDiscardParams& rhs);
// Static definition of the different parameters that can be used by this
// feature.
static constexpr base::FeatureParam<bool> kShouldProactivelyDiscard{
&features::kProactiveTabFreezeAndDiscard, "ShouldProactivelyDiscard",
false};
static constexpr base::FeatureParam<bool> kShouldPeriodicallyUnfreeze{
&features::kProactiveTabFreezeAndDiscard, "ShouldPeriodicallyUnfreeze",
false};
static constexpr base::FeatureParam<bool>
kShouldProtectTabsSharingBrowsingInstance{
&features::kProactiveTabFreezeAndDiscard,
"ShouldProtectTabsSharingBrowsingInstance", true};
// 50% of people cap out at 4 tabs, so for them proactive discarding won't
// even be invoked. See Tabs.MaxTabsInADay.
// TODO(chrisha): This should eventually be informed by the number of tabs
// typically used over a given time horizon (metric being developed).
static constexpr base::FeatureParam<int> kLowLoadedTabCount{
&features::kProactiveTabFreezeAndDiscard, "LowLoadedTabCount", 4};
// Testing in the lab shows that 2GB devices suffer beyond 6 tabs, and 4GB
// devices suffer beyond about 12 tabs. As a very simple first step, we'll aim
// at allowing 3 tabs per GB of RAM on a system before proactive discarding
// kicks in. This is a system resource dependent max, which is combined with
// the DefaultMaxLoadedTabCount to determine the max on a system.
static constexpr base::FeatureParam<int> kModerateLoadedTabsPerGbRam{
&features::kProactiveTabFreezeAndDiscard, "ModerateLoadedTabsPerGbRam",
3};
// 99.9% of people cap out with fewer than this number, so only 0.1% of the
// population should ever encounter proactive discarding based on this cap.
static constexpr base::FeatureParam<int> kHighLoadedTabCount{
&features::kProactiveTabFreezeAndDiscard, "HighLoadedTabCount", 100};
// Current discarding uses 10 minutes as a minimum cap. This uses
// exponentially increasing timeouts beyond that.
static constexpr base::FeatureParam<int> kLowOccludedTimeout{
&features::kProactiveTabFreezeAndDiscard, "LowOccludedTimeoutSeconds",
base::TimeDelta::FromHours(6).InSeconds()};
static constexpr base::FeatureParam<int> kModerateOccludedTimeout{
&features::kProactiveTabFreezeAndDiscard,
"ModerateOccludedTimeoutSeconds",
base::TimeDelta::FromHours(1).InSeconds()};
static constexpr base::FeatureParam<int> kHighOccludedTimeout{
&features::kProactiveTabFreezeAndDiscard, "HighOccludedTimeoutSeconds",
static_cast<int>(base::TimeDelta::FromMinutes(10).InSeconds())};
static constexpr base::FeatureParam<int> kFreezeTimeout{
&features::kProactiveTabFreezeAndDiscard, "FreezeTimeout",
base::TimeDelta::FromMinutes(10).InSeconds()};
static constexpr base::FeatureParam<int> kUnfreezeTimeout{
&features::kProactiveTabFreezeAndDiscard, "UnfreezeTimeout",
base::TimeDelta::FromMinutes(15).InSeconds()};
static constexpr base::FeatureParam<int> kRefreezeTimeout{
&features::kProactiveTabFreezeAndDiscard, "RefreezeTimeout",
base::TimeDelta::FromMinutes(10).InSeconds()};
// Whether tabs should be proactively discarded. When the
// |kProactiveTabFreezeAndDiscard| feature is enabled and this is false, only
// proactive tab freezing happens.
......@@ -214,6 +173,31 @@ struct SiteCharacteristicsDatabaseParams {
SiteCharacteristicsDatabaseParams(
const SiteCharacteristicsDatabaseParams& rhs);
// Static definition of the different parameters that can be used by this
// feature.
// Observations windows have a default value of 2 hours, 95% of backgrounded
// tabs don't use any of these features in this time window.
static constexpr base::FeatureParam<int> kFaviconUpdateObservationWindow{
&features::kSiteCharacteristicsDatabase, "FaviconUpdateObservationWindow",
base::TimeDelta::FromHours(2).InSeconds()};
static constexpr base::FeatureParam<int> kTitleUpdateObservationWindow{
&features::kSiteCharacteristicsDatabase, "TitleUpdateObservationWindow",
base::TimeDelta::FromHours(2).InSeconds()};
static constexpr base::FeatureParam<int> kAudioUsageObservationWindow{
&features::kSiteCharacteristicsDatabase, "AudioUsageObservationWindow",
base::TimeDelta::FromHours(2).InSeconds()};
static constexpr base::FeatureParam<int> kNotificationsUsageObservationWindow{
&features::kSiteCharacteristicsDatabase,
"NotificationsUsageObservationWindow",
base::TimeDelta::FromHours(2).InSeconds()};
static constexpr base::FeatureParam<int> kTitleOrFaviconChangeGracePeriod{
&features::kSiteCharacteristicsDatabase,
"TitleOrFaviconChangeGracePeriod", 20 /* 20 seconds */};
static constexpr base::FeatureParam<int> kAudioUsageGracePeriod{
&features::kSiteCharacteristicsDatabase, "AudioUsageGracePeriod",
10 /* 10 seconds */};
// Minimum observation window before considering that this website doesn't
// update its favicon while in background.
base::TimeDelta favicon_update_observation_window;
......@@ -243,6 +227,32 @@ struct InfiniteSessionRestoreParams {
InfiniteSessionRestoreParams();
InfiniteSessionRestoreParams(const InfiniteSessionRestoreParams& rhs);
// Static definition of the different parameters that can be used by this
// feature.
static constexpr base::FeatureParam<int> kMinSimultaneousTabLoads{
&features::kInfiniteSessionRestore, "MinSimultaneousTabLoads", 1};
static constexpr base::FeatureParam<int> kMaxSimultaneousTabLoads{
&features::kInfiniteSessionRestore, "MaxSimultaneousTabLoads", 4};
static constexpr base::FeatureParam<int> kCoresPerSimultaneousTabLoad{
&features::kInfiniteSessionRestore, "CoresPerSimultaneousTabLoad", 2};
static constexpr base::FeatureParam<int> kMinTabsToRestore{
&features::kInfiniteSessionRestore, "MinTabsToRestore", 4};
static constexpr base::FeatureParam<int> kMaxTabsToRestore{
&features::kInfiniteSessionRestore, "MaxTabsToRestore", 20};
// This is the 75th percentile of Memory.Renderer.PrivateMemoryFootprint.
static constexpr base::FeatureParam<int> kMbFreeMemoryPerTabToRestore{
&features::kInfiniteSessionRestore, "MbFreeMemoryPerTabToRestore", 150};
// This is the 75th percentile of SessionRestore.RestoredTab.TimeSinceActive.
static constexpr base::FeatureParam<int> kMaxTimeSinceLastUseToRestore{
&features::kInfiniteSessionRestore, "MaxTimeSinceLastUseToRestore",
base::TimeDelta::FromHours(6).InSeconds()};
// Taken from an informal survey of Googlers on min engagement of things they
// think *must* load. Note that about 25% of session-restore tabs fall above
// this threshold (see SessionRestore.RestoredTab.SiteEngagementScore).
static constexpr base::FeatureParam<int> kMinSiteEngagementToRestore{
&features::kInfiniteSessionRestore, "MinSiteEngagementToRestore", 15};
// Parameters directly retrieved from the experiment configuration.
// The minimum number of tabs to ever load simultaneously. This can be
......
chrome/browser/resource_coordinator/tab_manager_features_unittest.cc
View file @ c84819af
......@@ -137,41 +137,73 @@ class TabManagerFeaturesTest : public testing::Test {
void ExpectDefaultProactiveTabFreezeAndDiscardParams() {
int memory_in_gb = 4;
ExpectProactiveTabFreezeAndDiscardParams(
kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardDefault,
kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeDefault,
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceDefault,
kProactiveTabFreezeAndDiscard_LowLoadedTabCountDefault,
kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamDefault *
ProactiveTabFreezeAndDiscardParams::kShouldProactivelyDiscard
.default_value,
ProactiveTabFreezeAndDiscardParams::kShouldPeriodicallyUnfreeze
.default_value,
ProactiveTabFreezeAndDiscardParams::
kShouldProtectTabsSharingBrowsingInstance.default_value,
ProactiveTabFreezeAndDiscardParams::kLowLoadedTabCount.default_value,
ProactiveTabFreezeAndDiscardParams::kModerateLoadedTabsPerGbRam
.default_value *
memory_in_gb,
kProactiveTabFreezeAndDiscard_HighLoadedTabCountDefault, memory_in_gb,
kProactiveTabFreezeAndDiscard_LowOccludedTimeoutDefault,
kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutDefault,
kProactiveTabFreezeAndDiscard_HighOccludedTimeoutDefault,
kProactiveTabFreezeAndDiscard_FreezeTimeoutDefault,
kProactiveTabFreezeAndDiscard_UnfreezeTimeoutDefault,
kProactiveTabFreezeAndDiscard_RefreezeTimeoutDefault);
ProactiveTabFreezeAndDiscardParams::kHighLoadedTabCount.default_value,
memory_in_gb,
base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kLowOccludedTimeout
.default_value),
base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kModerateOccludedTimeout
.default_value),
base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kHighOccludedTimeout
.default_value),
base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kFreezeTimeout.default_value),
base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kUnfreezeTimeout.default_value),
base::TimeDelta::FromSeconds(
ProactiveTabFreezeAndDiscardParams::kRefreezeTimeout
.default_value));
}
void ExpectDefaultSiteCharacteristicsDatabaseParams() {
ExpectSiteCharacteristicsDatabaseParams(
kSiteCharacteristicsDb_FaviconUpdateObservationWindow_Default,
kSiteCharacteristicsDb_TitleUpdateObservationWindow_Default,
kSiteCharacteristicsDb_AudioUsageObservationWindow_Default,
kSiteCharacteristicsDb_NotificationsUsageObservationWindow_Default,
kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod_Default,
kSiteCharacteristicsDb_AudioUsageGracePeriod_Default);
base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kFaviconUpdateObservationWindow
.default_value),
base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kTitleUpdateObservationWindow
.default_value),
base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kAudioUsageObservationWindow
.default_value),
base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::
kNotificationsUsageObservationWindow.default_value),
base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kTitleOrFaviconChangeGracePeriod
.default_value),
base::TimeDelta::FromSeconds(
SiteCharacteristicsDatabaseParams::kAudioUsageGracePeriod
.default_value));
}
void ExpectDefaultInfiniteSessionRestoreParams() {
ExpectInfiniteSessionRestoreParams(
kInfiniteSessionRestore_MinSimultaneousTabLoadsDefault,
kInfiniteSessionRestore_MaxSimultaneousTabLoadsDefault,
kInfiniteSessionRestore_CoresPerSimultaneousTabLoadDefault,
kInfiniteSessionRestore_MinTabsToRestoreDefault,
kInfiniteSessionRestore_MaxTabsToRestoreDefault,
kInfiniteSessionRestore_MbFreeMemoryPerTabToRestoreDefault,
kInfiniteSessionRestore_MaxTimeSinceLastUseToRestoreDefault,
kInfiniteSessionRestore_MinSiteEngagementToRestoreDefault);
InfiniteSessionRestoreParams::kMinSimultaneousTabLoads.default_value,
InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads.default_value,
InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad
.default_value,
InfiniteSessionRestoreParams::kMinTabsToRestore.default_value,
InfiniteSessionRestoreParams::kMaxTabsToRestore.default_value,
InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore
.default_value,
base::TimeDelta::FromSeconds(
InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore
.default_value),
InfiniteSessionRestoreParams::kMinSiteEngagementToRestore
.default_value);
}
private:
......@@ -195,43 +227,49 @@ TEST_F(TabManagerFeaturesTest,
TEST_F(TabManagerFeaturesTest,
GetProactiveTabFreezeAndDiscardParamsInvalidGoesToDefault) {
SetParam(kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardParam, "blah");
SetParam(kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeParam,
SetParam(ProactiveTabFreezeAndDiscardParams::kShouldProactivelyDiscard.name,
"blah");
SetParam(
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceParam,
"bleh");
SetParam(kProactiveTabFreezeAndDiscard_LowLoadedTabCountParam, "ab");
SetParam(kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamParam,
SetParam(ProactiveTabFreezeAndDiscardParams::kShouldPeriodicallyUnfreeze.name,
"blah");
SetParam(ProactiveTabFreezeAndDiscardParams::
kShouldProtectTabsSharingBrowsingInstance.name,
"bleh");
SetParam(ProactiveTabFreezeAndDiscardParams::kLowLoadedTabCount.name, "ab");
SetParam(ProactiveTabFreezeAndDiscardParams::kModerateLoadedTabsPerGbRam.name,
"27.8");
SetParam(kProactiveTabFreezeAndDiscard_HighLoadedTabCountParam, "4e8");
SetParam(kProactiveTabFreezeAndDiscard_LowOccludedTimeoutParam, "---");
SetParam(kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutParam, " ");
SetParam(kProactiveTabFreezeAndDiscard_HighOccludedTimeoutParam, "");
SetParam(kProactiveTabFreezeAndDiscard_FreezeTimeoutParam, "b");
SetParam(kProactiveTabFreezeAndDiscard_UnfreezeTimeoutParam, "i");
SetParam(kProactiveTabFreezeAndDiscard_RefreezeTimeoutParam, "m");
SetParam(ProactiveTabFreezeAndDiscardParams::kHighLoadedTabCount.name, "4e8");
SetParam(ProactiveTabFreezeAndDiscardParams::kLowOccludedTimeout.name, "---");
SetParam(ProactiveTabFreezeAndDiscardParams::kModerateOccludedTimeout.name,
" ");
SetParam(ProactiveTabFreezeAndDiscardParams::kHighOccludedTimeout.name, "");
SetParam(ProactiveTabFreezeAndDiscardParams::kFreezeTimeout.name, "b");
SetParam(ProactiveTabFreezeAndDiscardParams::kUnfreezeTimeout.name, "i");
SetParam(ProactiveTabFreezeAndDiscardParams::kRefreezeTimeout.name, "m");
EnableProactiveTabFreezeAndDiscard();
ExpectDefaultProactiveTabFreezeAndDiscardParams();
}
TEST_F(TabManagerFeaturesTest, GetProactiveTabFreezeAndDiscardParams) {
SetParam(kProactiveTabFreezeAndDiscard_ShouldProactivelyDiscardParam, "true");
SetParam(kProactiveTabFreezeAndDiscard_ShouldPeriodicallyUnfreezeParam,
SetParam(ProactiveTabFreezeAndDiscardParams::kShouldProactivelyDiscard.name,
"true");
SetParam(
kProactiveTabFreezeAndDiscard_ShouldProtectTabsSharingBrowsingInstanceParam,
"true");
SetParam(kProactiveTabFreezeAndDiscard_LowLoadedTabCountParam, "7");
SetParam(kProactiveTabFreezeAndDiscard_ModerateLoadedTabsPerGbRamParam, "4");
SetParam(kProactiveTabFreezeAndDiscard_HighLoadedTabCountParam, "42");
SetParam(ProactiveTabFreezeAndDiscardParams::kShouldPeriodicallyUnfreeze.name,
"true");
SetParam(ProactiveTabFreezeAndDiscardParams::
kShouldProtectTabsSharingBrowsingInstance.name,
"true");
SetParam(ProactiveTabFreezeAndDiscardParams::kLowLoadedTabCount.name, "7");
SetParam(ProactiveTabFreezeAndDiscardParams::kModerateLoadedTabsPerGbRam.name,
"4");
SetParam(ProactiveTabFreezeAndDiscardParams::kHighLoadedTabCount.name, "42");
// These are expressed in seconds.
SetParam(kProactiveTabFreezeAndDiscard_LowOccludedTimeoutParam, "60");
SetParam(kProactiveTabFreezeAndDiscard_ModerateOccludedTimeoutParam, "120");
SetParam(kProactiveTabFreezeAndDiscard_HighOccludedTimeoutParam, "247");
SetParam(kProactiveTabFreezeAndDiscard_FreezeTimeoutParam, "10");
SetParam(kProactiveTabFreezeAndDiscard_UnfreezeTimeoutParam, "20");
SetParam(kProactiveTabFreezeAndDiscard_RefreezeTimeoutParam, "30");
SetParam(ProactiveTabFreezeAndDiscardParams::kLowOccludedTimeout.name, "60");
SetParam(ProactiveTabFreezeAndDiscardParams::kModerateOccludedTimeout.name,
"120");
SetParam(ProactiveTabFreezeAndDiscardParams::kHighOccludedTimeout.name,
"247");
SetParam(ProactiveTabFreezeAndDiscardParams::kFreezeTimeout.name, "10");
SetParam(ProactiveTabFreezeAndDiscardParams::kUnfreezeTimeout.name, "20");
SetParam(ProactiveTabFreezeAndDiscardParams::kRefreezeTimeout.name, "30");
EnableProactiveTabFreezeAndDiscard();
// Should snap |moderate_loaded_tab_count| to |low_loaded_tab_count|, when the
......@@ -277,24 +315,45 @@ TEST_F(TabManagerFeaturesTest,
TEST_F(TabManagerFeaturesTest,
GetSiteCharacteristicsDatabaseParamsInvalidGoesToDefault) {
SetParam(kSiteCharacteristicsDb_FaviconUpdateObservationWindow, " ");
SetParam(kSiteCharacteristicsDb_TitleUpdateObservationWindow, "foo");
SetParam(kSiteCharacteristicsDb_AudioUsageObservationWindow, ".");
SetParam(kSiteCharacteristicsDb_NotificationsUsageObservationWindow, "abc");
SetParam(kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod, "bleh");
SetParam(kSiteCharacteristicsDb_AudioUsageGracePeriod, "!!!");
SetParam(
SiteCharacteristicsDatabaseParams::kFaviconUpdateObservationWindow.name,
" ");
SetParam(
SiteCharacteristicsDatabaseParams::kTitleUpdateObservationWindow.name,
"foo");
SetParam(SiteCharacteristicsDatabaseParams::kAudioUsageObservationWindow.name,
".");
SetParam(
SiteCharacteristicsDatabaseParams::kNotificationsUsageObservationWindow
.name,
"abc");
SetParam(
SiteCharacteristicsDatabaseParams::kTitleOrFaviconChangeGracePeriod.name,
"bleh");
SetParam(SiteCharacteristicsDatabaseParams::kAudioUsageGracePeriod.name,
"!!!");
EnableSiteCharacteristicsDatabase();
ExpectDefaultSiteCharacteristicsDatabaseParams();
}
TEST_F(TabManagerFeaturesTest, GetSiteCharacteristicsDatabaseParams) {
SetParam(kSiteCharacteristicsDb_FaviconUpdateObservationWindow, "3600");
SetParam(kSiteCharacteristicsDb_TitleUpdateObservationWindow, "36000");
SetParam(kSiteCharacteristicsDb_AudioUsageObservationWindow, "360000");
SetParam(kSiteCharacteristicsDb_NotificationsUsageObservationWindow,
"3600000");
SetParam(kSiteCharacteristicsDb_TitleOrFaviconChangeGracePeriod, "42");
SetParam(kSiteCharacteristicsDb_AudioUsageGracePeriod, "43");
SetParam(
SiteCharacteristicsDatabaseParams::kFaviconUpdateObservationWindow.name,
"3600");
SetParam(
SiteCharacteristicsDatabaseParams::kTitleUpdateObservationWindow.name,
"36000");
SetParam(SiteCharacteristicsDatabaseParams::kAudioUsageObservationWindow.name,
"360000");
SetParam(
SiteCharacteristicsDatabaseParams::kNotificationsUsageObservationWindow
.name,
"3600000");
SetParam(
SiteCharacteristicsDatabaseParams::kTitleOrFaviconChangeGracePeriod.name,
"42");
SetParam(SiteCharacteristicsDatabaseParams::kAudioUsageGracePeriod.name,
"43");
EnableSiteCharacteristicsDatabase();
......@@ -307,27 +366,34 @@ TEST_F(TabManagerFeaturesTest, GetSiteCharacteristicsDatabaseParams) {
TEST_F(TabManagerFeaturesTest,
GetInfiniteSessionRestoreParamsInvalidGoesToDefault) {
SetParam(kInfiniteSessionRestore_MinSimultaneousTabLoads, " ");
SetParam(kInfiniteSessionRestore_MaxSimultaneousTabLoads, "a.b");
SetParam(kInfiniteSessionRestore_CoresPerSimultaneousTabLoad, "-- ");
SetParam(kInfiniteSessionRestore_MinTabsToRestore, "hey");
SetParam(kInfiniteSessionRestore_MaxTabsToRestore, ".");
SetParam(kInfiniteSessionRestore_MbFreeMemoryPerTabToRestore, "0x0");
SetParam(kInfiniteSessionRestore_MaxTimeSinceLastUseToRestore, "foo");
SetParam(kInfiniteSessionRestore_MinSiteEngagementToRestore, "bar");
SetParam(InfiniteSessionRestoreParams::kMinSimultaneousTabLoads.name, " ");
SetParam(InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads.name, "a.b");
SetParam(InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad.name,
"-- ");
SetParam(InfiniteSessionRestoreParams::kMinTabsToRestore.name, "hey");
SetParam(InfiniteSessionRestoreParams::kMaxTabsToRestore.name, ".");
SetParam(InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore.name,
"0x0");
SetParam(InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore.name,
"foo");
SetParam(InfiniteSessionRestoreParams::kMinSiteEngagementToRestore.name,
"bar");
EnableInfiniteSessionRestore();
ExpectDefaultInfiniteSessionRestoreParams();
}
TEST_F(TabManagerFeaturesTest, GetInfiniteSessionRestoreParams) {
SetParam(kInfiniteSessionRestore_MinSimultaneousTabLoads, "10");
SetParam(kInfiniteSessionRestore_MaxSimultaneousTabLoads, "20");
SetParam(kInfiniteSessionRestore_CoresPerSimultaneousTabLoad, "2");
SetParam(kInfiniteSessionRestore_MinTabsToRestore, "13");
SetParam(kInfiniteSessionRestore_MaxTabsToRestore, "27");
SetParam(kInfiniteSessionRestore_MbFreeMemoryPerTabToRestore, "1337");
SetParam(kInfiniteSessionRestore_MaxTimeSinceLastUseToRestore, "60");
SetParam(kInfiniteSessionRestore_MinSiteEngagementToRestore, "9");
SetParam(InfiniteSessionRestoreParams::kMinSimultaneousTabLoads.name, "10");
SetParam(InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads.name, "20");
SetParam(InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad.name,
"2");
SetParam(InfiniteSessionRestoreParams::kMinTabsToRestore.name, "13");
SetParam(InfiniteSessionRestoreParams::kMaxTabsToRestore.name, "27");
SetParam(InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore.name,
"1337");
SetParam(InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore.name,
"60");
SetParam(InfiniteSessionRestoreParams::kMinSiteEngagementToRestore.name, "9");
EnableInfiniteSessionRestore();
ExpectInfiniteSessionRestoreParams(10, 20, 2, 13, 27, 1337,
base::TimeDelta::FromMinutes(1), 9);
......
chrome/browser/sessions/tab_loader_unittest.cc
View file @ c84819af
......@@ -350,16 +350,20 @@ TEST_F(TabLoaderTest, DelegatePolicyIsApplied) {
// it such that there are 2 max simultaneous tab loads, and 3 maximum tabs to
// restore.
std::map<std::string, std::string> params;
params[rc::kInfiniteSessionRestore_MinSimultaneousTabLoads] = "2";
params[rc::kInfiniteSessionRestore_MaxSimultaneousTabLoads] = "2";
params[rc::kInfiniteSessionRestore_CoresPerSimultaneousTabLoad] = "0";
params[rc::kInfiniteSessionRestore_MinTabsToRestore] = "1";
params[rc::kInfiniteSessionRestore_MaxTabsToRestore] = "3";
params[rc::InfiniteSessionRestoreParams::kMinSimultaneousTabLoads.name] = "2";
params[rc::InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads.name] = "2";
params[rc::InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad.name] =
"0";
params[rc::InfiniteSessionRestoreParams::kMinTabsToRestore.name] = "1";
params[rc::InfiniteSessionRestoreParams::kMaxTabsToRestore.name] = "3";
// Disable these policy features.
params[rc::kInfiniteSessionRestore_MbFreeMemoryPerTabToRestore] = "0";
params[rc::kInfiniteSessionRestore_MaxTimeSinceLastUseToRestore] = "0";
params[rc::kInfiniteSessionRestore_MinSiteEngagementToRestore] = "0";
params[rc::InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore.name] =
"0";
params[rc::InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore.name] =
"0";
params[rc::InfiniteSessionRestoreParams::kMinSiteEngagementToRestore.name] =
"0";
variations::testing::VariationParamsManager variations_manager;
variations_manager.SetVariationParamsWithFeatureAssociations(
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment