Add unittest for incognito poolsize.

Unittests are added for incognito poolsize, when dynamic quota feature
is enabled or disabled.

Bug: 1017120
Change-Id: Ib0ef8528cc4550c1556645d39312451b0fa3a58b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1890055
Commit-Queue: Ramin Halavati <rhalavati@chromium.org>
Reviewed-by: Jarryd Goodman <jarrydg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#711220}

storage/browser/quota/quota_settings.cc

@@ -21,46 +21,52 @@ namespace storage {
 
 namespace {
 
+const int64_t kMBytes = 1024 * 1024;
+const int kRandomizedPercentage = 10;
+
 // Skews |value| by +/- |percent|.
 int64_t RandomizeByPercent(int64_t value, int percent) {
   double random_percent = (base::RandDouble() - 0.5) * percent * 2;
   return value + (value * (random_percent / 100.0));
 }
 
+storage::QuotaSettings CalculateIncognitoDynamicSettings(
+    int64_t physical_memory_amount) {
+  // The incognito pool size is a fraction of the amount of system memory,
+  // and the amount is capped to a hard limit.
+  double kIncognitoPoolSizeRatio = 0.1;  // 10%
+  int64_t kMaxIncognitoPoolSize = 300 * kMBytes;
+  if (base::FeatureList::IsEnabled(features::kIncognitoDynamicQuota)) {
+    const double lower_bound = features::kIncognitoQuotaRatioLowerBound.Get();
+    const double upper_bound = features::kIncognitoQuotaRatioUpperBound.Get();
+    kIncognitoPoolSizeRatio =
+        lower_bound + (base::RandDouble() * (upper_bound - lower_bound));
+    kMaxIncognitoPoolSize = std::numeric_limits<int64_t>::max();
+  } else {
+    kMaxIncognitoPoolSize =
+        RandomizeByPercent(kMaxIncognitoPoolSize, kRandomizedPercentage);
+  }
+
+  storage::QuotaSettings settings;
+  settings.pool_size = std::min(
+      kMaxIncognitoPoolSize,
+      static_cast<int64_t>(physical_memory_amount * kIncognitoPoolSizeRatio));
+  settings.per_host_quota = settings.pool_size / 3;
+  settings.session_only_per_host_quota = settings.per_host_quota;
+  settings.refresh_interval = base::TimeDelta::Max();
+  return settings;
+}
+
 base::Optional<storage::QuotaSettings> CalculateNominalDynamicSettings(
     const base::FilePath& partition_path,
     bool is_incognito,
     QuotaDiskInfoHelper* disk_info_helper) {
   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
                                                 base::BlockingType::MAY_BLOCK);
-  const int64_t kMBytes = 1024 * 1024;
-  const int kRandomizedPercentage = 10;
 
   if (is_incognito) {
-    // The incognito pool size is a fraction of the amount of system memory,
-    // and the amount is capped to a hard limit.
-    double kIncognitoPoolSizeRatio = 0.1;  // 10%
-    int64_t kMaxIncognitoPoolSize = 300 * kMBytes;
-    if (base::FeatureList::IsEnabled(features::kIncognitoDynamicQuota)) {
-      const double lower_bound = features::kIncognitoQuotaRatioLowerBound.Get();
-      const double upper_bound = features::kIncognitoQuotaRatioUpperBound.Get();
-      kIncognitoPoolSizeRatio =
-          lower_bound + (base::RandDouble() * (upper_bound - lower_bound));
-      kMaxIncognitoPoolSize = std::numeric_limits<int64_t>::max();
-    } else {
-      kMaxIncognitoPoolSize =
-          RandomizeByPercent(kMaxIncognitoPoolSize, kRandomizedPercentage);
-    }
-
-    storage::QuotaSettings settings;
-    settings.pool_size =
-        std::min(kMaxIncognitoPoolSize,
-                 static_cast<int64_t>(base::SysInfo::AmountOfPhysicalMemory() *
-                                      kIncognitoPoolSizeRatio));
-    settings.per_host_quota = settings.pool_size / 3;
-    settings.session_only_per_host_quota = settings.per_host_quota;
-    settings.refresh_interval = base::TimeDelta::Max();
-    return settings;
+    return CalculateIncognitoDynamicSettings(
+        base::SysInfo::AmountOfPhysicalMemory());
   }
 
   // The fraction of the device's storage the browser is willing to
@@ -144,6 +150,10 @@ base::Optional<storage::QuotaSettings> CalculateNominalDynamicSettings(
 
 }  // namespace
 
+int64_t GetIncognitoPoolSizeForTesting(int64_t physical_memory_amount) {
+  return CalculateIncognitoDynamicSettings(physical_memory_amount).pool_size;
+}
+
 void GetNominalDynamicSettings(const base::FilePath& partition_path,
                                bool is_incognito,
                                QuotaDiskInfoHelper* disk_info_helper,

storage/browser/quota/quota_settings.h

@@ -82,6 +82,11 @@ void GetNominalDynamicSettings(const base::FilePath& partition_path,
                                QuotaDiskInfoHelper* diskInfoHelper,
                                OptionalQuotaSettingsCallback callback);
 
+COMPONENT_EXPORT(STORAGE_BROWSER)
+// TODO(https://crbug.com/1017120): Add memory size mocking support to
+// QuotaDiskInfoHelper and remove this function.
+int64_t GetIncognitoPoolSizeForTesting(int64_t physical_memory_amount);
+
 // Returns settings with a poolsize of zero and no per host quota.
 inline QuotaSettings GetNoQuotaSettings() {
   return QuotaSettings();

storage/browser/quota/quota_settings_unittest.cc

@@ -103,4 +103,35 @@ TEST_F(QuotaSettingsTest, UnlimitedTempPool) {
   task_environment_.RunUntilIdle();
   EXPECT_TRUE(callback_executed);
 }
+
+TEST_F(QuotaSettingsTest, IncognitoQuotaCapped) {
+  const int64_t kMBytes = 1024 * 1024;
+  const int64_t kMaxIncognitoPoolSize = 330 * kMBytes;  // 300 MB + 10%
+
+  scoped_feature_list_.InitAndDisableFeature(features::kIncognitoDynamicQuota);
+  EXPECT_GE(kMaxIncognitoPoolSize,
+            GetIncognitoPoolSizeForTesting(kMaxIncognitoPoolSize * 1000));
+}
+
+TEST_F(QuotaSettingsTest, IncognitoQuotaDynamic) {
+  const int64_t kMBytes = 1024 * 1024;
+  const int64_t kMaxIncognitoPoolSize = 330 * kMBytes;  // 300 MB + 10%
+  const int64_t test_cases[] = {
+      kMaxIncognitoPoolSize / 10, kMaxIncognitoPoolSize,
+      kMaxIncognitoPoolSize * 100, kMaxIncognitoPoolSize * 1000};
+
+  scoped_feature_list_.InitAndEnableFeatureWithParameters(
+      features::kIncognitoDynamicQuota,
+      {{"IncognitoQuotaRatioLowerBound", "0.1"},
+       {"IncognitoQuotaRatioLowerBound", "0.2"}});
+
+  for (const int64_t physical_memory_amount : test_cases) {
+    EXPECT_LE(physical_memory_amount / 10,
+              GetIncognitoPoolSizeForTesting(physical_memory_amount))
+        << physical_memory_amount;
+    EXPECT_GE(physical_memory_amount / 5,
+              GetIncognitoPoolSizeForTesting(physical_memory_amount))
+        << physical_memory_amount;
+  }
+}
 }  // namespace storage