Create InfiniteSessionRestore feature and parameters.

BUG=749785

Change-Id: Ie89ec2c4869851e5734fde94656052e933faac96
Reviewed-on: https://chromium-review.googlesource.com/1088970Reviewed-by: Sébastien Marchand <sebmarchand@chromium.org>
Commit-Queue: Chris Hamilton <chrisha@chromium.org>
Cr-Commit-Position: refs/heads/master@{#564912}

chrome/browser/resource_coordinator/tab_manager_features.cc

@@ -6,12 +6,23 @@
 
 #include "base/metrics/field_trial_params.h"
 #include "base/numerics/ranges.h"
+#include "base/sys_info.h"
 #include "chrome/common/chrome_features.h"
 
 namespace {
 
 constexpr char kTabLoadTimeoutInMsParameterName[] = "tabLoadTimeoutInMs";
 
+// The number of cores to use for testing when computing InfiniteSessionRestore
+// parameters. Setting this to zero means the actual system info is used.
+static size_t g_num_cores_for_testing = 0;
+
+size_t GetNumCores() {
+  if (g_num_cores_for_testing != 0)
+    return g_num_cores_for_testing;
+  return base::SysInfo::NumberOfProcessors();
+}
+
 }  // namespace
 
 namespace features {
@@ -23,6 +34,11 @@ namespace features {
 const base::Feature kCustomizedTabLoadTimeout{
     "CustomizedTabLoadTimeout", base::FEATURE_DISABLED_BY_DEFAULT};
 
+// Enables TabLoader improvements for reducing the overhead of session restores
+// involving many many tabs.
+const base::Feature kInfiniteSessionRestore{"InfiniteSessionRestore",
+                                            base::FEATURE_DISABLED_BY_DEFAULT};
+
 // Enables proactive tab freezing and discarding.
 const base::Feature kProactiveTabFreezeAndDiscard{
     "ProactiveTabFreezeAndDiscard", base::FEATURE_DISABLED_BY_DEFAULT};
@@ -102,6 +118,21 @@ const char kSiteCharacteristicsDb_AudioUsageObservationWindow[] =
 const char kSiteCharacteristicsDb_NotificationsUsageObservationWindow[] =
     "NotificationsUsageObservationWindow";
 
+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;
@@ -149,6 +180,24 @@ const base::TimeDelta
     kSiteCharacteristicsDb_NotificationsUsageObservationWindow_Default =
         base::TimeDelta::FromHours(2);
 
+// 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;
+
 ProactiveTabFreezeAndDiscardParams::ProactiveTabFreezeAndDiscardParams() =
     default;
 ProactiveTabFreezeAndDiscardParams::ProactiveTabFreezeAndDiscardParams(
@@ -159,6 +208,10 @@ SiteCharacteristicsDatabaseParams::SiteCharacteristicsDatabaseParams() =
 SiteCharacteristicsDatabaseParams::SiteCharacteristicsDatabaseParams(
     const SiteCharacteristicsDatabaseParams& rhs) = default;
 
+InfiniteSessionRestoreParams::InfiniteSessionRestoreParams() = default;
+InfiniteSessionRestoreParams::InfiniteSessionRestoreParams(
+    const InfiniteSessionRestoreParams& rhs) = default;
+
 ProactiveTabFreezeAndDiscardParams GetProactiveTabFreezeAndDiscardParams(
     int memory_in_gb) {
   ProactiveTabFreezeAndDiscardParams params = {};
@@ -271,4 +324,90 @@ GetStaticSiteCharacteristicsDatabaseParams() {
   return *params;
 }
 
+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.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);
+  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()));
+  params.min_site_engagement_to_restore =
+      base::GetFieldTrialParamByFeatureAsInt(
+          features::kInfiniteSessionRestore,
+          kInfiniteSessionRestore_MinSiteEngagementToRestore,
+          kInfiniteSessionRestore_MinSiteEngagementToRestoreDefault);
+
+  params.simultaneous_tab_loads = CalculateSimultaneousTabLoads(
+      params.min_simultaneous_tab_loads, params.max_simultaneous_tab_loads,
+      params.cores_per_simultaneous_tab_load, GetNumCores());
+
+  return params;
+}
+
+const InfiniteSessionRestoreParams& GetStaticInfiniteSessionRestoreParams() {
+  static base::NoDestructor<InfiniteSessionRestoreParams> params(
+      GetInfiniteSessionRestoreParams());
+  return *params;
+}
+
+size_t CalculateSimultaneousTabLoads(size_t min_loads,
+                                     size_t max_loads,
+                                     size_t cores_per_load,
+                                     size_t num_cores) {
+  DCHECK(max_loads == 0 || min_loads <= max_loads);
+
+  if (num_cores == 0)
+    num_cores = GetNumCores();
+  DCHECK(num_cores > 0);
+
+  size_t loads = 0;
+
+  // Setting |cores_per_load| == 0 means that no per-core limit is applied.
+  if (cores_per_load == 0) {
+    loads = std::numeric_limits<size_t>::max();
+  } else {
+    loads = num_cores / cores_per_load;
+  }
+
+  // If |max_loads| isn't zero then apply the maximum that it implies.
+  if (max_loads != 0)
+    loads = std::min(loads, max_loads);
+
+  loads = std::max(loads, min_loads);
+
+  return loads;
+}
+
+void SetCoresForTesting(size_t num_cores) {
+  g_num_cores_for_testing = num_cores;
+}
+
 }  // namespace resource_coordinator

chrome/browser/resource_coordinator/tab_manager_features.h

@@ -13,6 +13,7 @@
 namespace features {
 
 extern const base::Feature kCustomizedTabLoadTimeout;
+extern const base::Feature kInfiniteSessionRestore;
 extern const base::Feature kProactiveTabFreezeAndDiscard;
 extern const base::Feature kSiteCharacteristicsDatabase;
 extern const base::Feature kStaggeredBackgroundTabOpening;
@@ -42,6 +43,17 @@ extern const char kSiteCharacteristicsDb_TitleUpdateObservationWindow[];
 extern const char kSiteCharacteristicsDb_AudioUsageObservationWindow[];
 extern const char kSiteCharacteristicsDb_NotificationsUsageObservationWindow[];
 
+// 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;
@@ -69,6 +81,19 @@ extern const base::TimeDelta
 extern const base::TimeDelta
     kSiteCharacteristicsDb_NotificationsUsageObservationWindow_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:
@@ -169,6 +194,42 @@ struct SiteCharacteristicsDatabaseParams {
   base::TimeDelta notifications_usage_observation_window;
 };
 
+// Parameters used by the infinite session restore feature.
+struct InfiniteSessionRestoreParams {
+  InfiniteSessionRestoreParams();
+  InfiniteSessionRestoreParams(const InfiniteSessionRestoreParams& rhs);
+
+  // Parameters directly retrieved from the experiment configuration.
+
+  // The maximum number of tabs to ever load simultaneously. This can be
+  // exceeded by user actions or load timeouts. See TabLoader for details.
+  uint32_t min_simultaneous_tab_loads;
+  // The minimum number of simultaneous tab loads that should be permitted.
+  // Setting to zero means no maximum is applied.
+  uint32_t max_simultaneous_tab_loads;
+  // The number of CPU cores required before per permitted simultaneous tab
+  // load. Setting to zero means no CPU core limit applies.
+  uint32_t cores_per_simultaneous_tab_load;
+  // The minimum total number of tabs to restore (if there are even that many).
+  uint32_t min_tabs_to_restore;
+  // The maximum total number of tabs to restore in a session restore. Setting
+  // to zero means no maximum is applied.
+  uint32_t max_tabs_to_restore;
+  // The required amount of system free memory per tab to restore. Setting to
+  // zero means no memory limit will be applied.
+  uint32_t mb_free_memory_per_tab_to_restore;
+  // The maximum time since last use of a tab in order for it to be restored.
+  // Setting to zero means this logic does not apply.
+  base::TimeDelta max_time_since_last_use_to_restore;
+  // The minimum site engagement score in order for a tab to be restored.
+  // Setting this to zero means all tabs will be restored regardless of the
+  // site engagement score.
+  uint32_t min_site_engagement_to_restore;
+
+  // Calculated parameters.
+  uint32_t simultaneous_tab_loads;
+};
+
 // Gets parameters for the proactive tab discarding feature. This does no
 // parameter validation, and sets the default values if the feature is not
 // enabled.
@@ -193,6 +254,25 @@ SiteCharacteristicsDatabaseParams GetSiteCharacteristicsDatabaseParams();
 const SiteCharacteristicsDatabaseParams&
 GetStaticSiteCharacteristicsDatabaseParams();
 
+// Gets parameters for the infinite session restore feature.
+InfiniteSessionRestoreParams GetInfiniteSessionRestoreParams();
+
+// Returns a static InfiniteSessionRestoreParams object that can be used by all
+// instances of TabLoader.
+const InfiniteSessionRestoreParams& GetStaticInfiniteSessionRestoreParams();
+
+// Returns the number of simultaneous tab loads to use given the provided
+// parameters. If |num_cores| is zero it will be automatically determined.
+size_t CalculateSimultaneousTabLoads(size_t min_loads,
+                                     size_t max_loads,
+                                     size_t cores_per_load,
+                                     size_t num_cores);
+
+// Testing seam. This allows setting the number of system cores used in the
+// calculation of the InfiniteSessionRestore params. Setting this to zero means
+// the actual system values will be used.
+void SetCoresForTesting(size_t num_cores);
+
 }  // namespace resource_coordinator
 
 #endif  // CHROME_BROWSER_RESOURCE_COORDINATOR_TAB_MANAGER_FEATURES_H_

chrome/browser/resource_coordinator/tab_manager_features_unittest.cc

@@ -34,6 +34,15 @@ class TabManagerFeaturesTest : public testing::Test {
         "DummyTrial", params_, features);
   }
 
+  // Enables the site characteristics database feature, and sets up the
+  // associated variations parameter values.
+  void EnableInfiniteSessionRestore() {
+    std::set<std::string> features;
+    features.insert(features::kInfiniteSessionRestore.name);
+    variations_manager_.SetVariationParamsWithFeatureAssociations(
+        "DummyTrial", params_, features);
+  }
+
   void SetParam(base::StringPiece key, base::StringPiece value) {
     params_[key.as_string()] = value.as_string();
   }
@@ -83,6 +92,30 @@ class TabManagerFeaturesTest : public testing::Test {
               params.notifications_usage_observation_window);
   }
 
+  void ExpectInfiniteSessionRestoreParams(
+      uint32_t min_simultaneous_tab_loads,
+      uint32_t max_simultaneous_tab_loads,
+      uint32_t cores_per_simultaneous_tab_load,
+      uint32_t min_tabs_to_restore,
+      uint32_t max_tabs_to_restore,
+      uint32_t mb_free_memory_per_tab_to_restore,
+      base::TimeDelta max_time_since_last_use_to_restore,
+      uint32_t min_site_engagement_to_restore,
+      uint32_t simultaneous_tab_loads) {
+    InfiniteSessionRestoreParams params = GetInfiniteSessionRestoreParams();
+    EXPECT_EQ(min_simultaneous_tab_loads, params.min_simultaneous_tab_loads);
+    EXPECT_EQ(max_simultaneous_tab_loads, params.max_simultaneous_tab_loads);
+    EXPECT_EQ(cores_per_simultaneous_tab_load,
+              params.cores_per_simultaneous_tab_load);
+    EXPECT_EQ(min_tabs_to_restore, params.min_tabs_to_restore);
+    EXPECT_EQ(max_tabs_to_restore, params.max_tabs_to_restore);
+    EXPECT_EQ(mb_free_memory_per_tab_to_restore,
+              params.mb_free_memory_per_tab_to_restore);
+    EXPECT_EQ(min_site_engagement_to_restore,
+              params.min_site_engagement_to_restore);
+    EXPECT_EQ(simultaneous_tab_loads, params.simultaneous_tab_loads);
+  }
+
   void ExpectDefaultProactiveTabFreezeAndDiscardParams() {
     int memory_in_gb = 4;
     ExpectProactiveTabFreezeAndDiscardParams(
@@ -104,6 +137,22 @@ class TabManagerFeaturesTest : public testing::Test {
         kSiteCharacteristicsDb_NotificationsUsageObservationWindow_Default);
   }
 
+  void ExpectDefaultInfiniteSessionRestoreParams() {
+    ExpectInfiniteSessionRestoreParams(
+        kInfiniteSessionRestore_MinSimultaneousTabLoadsDefault,
+        kInfiniteSessionRestore_MaxSimultaneousTabLoadsDefault,
+        kInfiniteSessionRestore_CoresPerSimultaneousTabLoadDefault,
+        kInfiniteSessionRestore_MinTabsToRestoreDefault,
+        kInfiniteSessionRestore_MaxTabsToRestoreDefault,
+        kInfiniteSessionRestore_MbFreeMemoryPerTabToRestoreDefault,
+        kInfiniteSessionRestore_MaxTimeSinceLastUseToRestoreDefault,
+        kInfiniteSessionRestore_MinSiteEngagementToRestoreDefault,
+        CalculateSimultaneousTabLoads(
+            kInfiniteSessionRestore_MinSimultaneousTabLoadsDefault,
+            kInfiniteSessionRestore_MaxSimultaneousTabLoadsDefault,
+            kInfiniteSessionRestore_CoresPerSimultaneousTabLoadDefault, 0));
+  }
+
  private:
   std::map<std::string, std::string> params_;
   variations::testing::VariationParamsManager variations_manager_;
@@ -208,4 +257,53 @@ TEST_F(TabManagerFeaturesTest, GetSiteCharacteristicsDatabaseParams) {
       base::TimeDelta::FromSeconds(3600000));
 }
 
+TEST_F(TabManagerFeaturesTest, CalculateSimultaneousTabLoads) {
+  // Test the minimum is enforced.
+  EXPECT_EQ(10u, CalculateSimultaneousTabLoads(10, 20, 1, 1));
+
+  // Test the maximum is enforced.
+  EXPECT_EQ(20u, CalculateSimultaneousTabLoads(10, 20, 1, 30));
+
+  // Test the per-core calculation is correct.
+  EXPECT_EQ(15u, CalculateSimultaneousTabLoads(10, 20, 1, 15));
+  EXPECT_EQ(15u, CalculateSimultaneousTabLoads(10, 20, 2, 30));
+
+  // If no per-core is specified then max is returned.
+  EXPECT_EQ(5u, CalculateSimultaneousTabLoads(1, 5, 0, 10));
+
+  // If no per-core and no max is applied, then "max" is returned.
+  EXPECT_EQ(std::numeric_limits<size_t>::max(),
+            CalculateSimultaneousTabLoads(3, 0, 0, 4));
+}
+
+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");
+  EnableInfiniteSessionRestore();
+  ExpectDefaultInfiniteSessionRestoreParams();
+}
+
+TEST_F(TabManagerFeaturesTest, GetInfiniteSessionRestoreParams) {
+  SetCoresForTesting(1);
+  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");
+  EnableInfiniteSessionRestore();
+  ExpectInfiniteSessionRestoreParams(10, 20, 2, 13, 27, 1337,
+                                     base::TimeDelta::FromMinutes(1), 9, 10);
+  SetCoresForTesting(0);
+}
+
 }  // namespace resource_coordinator