Change how the quota system computes the total poolsize for temporary storage

chrome/browser/chrome_content_browser_client.cc

 // Copyright (c) 2012 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 "chrome/browser/chrome_content_browser_client.h"
 
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/sys_info.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/after_startup_task_utils.h"
 #include "chrome/browser/apps/app_url_redirector.h"
 #include "chrome/browser/browser_about_handler.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
@@ skipping 2071 matching lines @@
 }
 
 std::unique_ptr<storage::QuotaEvictionPolicy>
 ChromeContentBrowserClient::GetTemporaryStorageEvictionPolicy(
     content::BrowserContext* context) {
   return SiteEngagementEvictionPolicy::IsEnabled()
              ? base::MakeUnique<SiteEngagementEvictionPolicy>(context)
              : nullptr;
 }
 
+namespace {
+#define UMA_HISTOGRAM_MBYTES(name, sample)          \

[cmumford, 2016/10/25 20:30:54]

Do you want the do/while(0) style for multi-line macros? Isn't that the "proper"
way to do a multi-line macro?

[michaeln, 2016/10/26 21:47:53]

i don't think so, there are multiple lines, but there is only one statement
define here, take a look at how other UMA_ macros are defined

+  UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
+      (name), static_cast<int>((sample) / kMBytes), \
+      1, 10 * 1024 * 1024 /* 10TB */, 100)
+
+storage::TemporaryStorageConfiguration CalculateTemporaryStorageConfig(
+    const base::FilePath& partition_path, bool is_incognito) {
+  const int64_t kMBytes = 1024 * 1024;
+
+  if (is_incognito) {
+    // TODO(michaeln): Base the poolsize on SysInfo::AmountOfPhysicalMemory().

[cmumford, 2016/10/25 20:30:54]

This seems like something we should do in this first CL - avoid the TODO.

[michaeln, 2016/10/26 21:47:53]

agreed, but not done yet

+    storage::TemporaryStorageConfiguration config;
+    config.pool_size = 300 * kMBytes;
+    config.must_remain_available = 0;

[cmumford, 2016/10/25 20:30:54]

Why not leave default values alone?

[michaeln, 2016/10/26 21:47:53]

Done.

+    config.per_host_quota = config.pool_size / 3;
+    config.refresh_interval = base::TimeDelta::Max();
+    return config;
+  }
+
+  // The fraction of the device's storage the browser is willing to
+  // use for temporary storage, this is applied after adjusting the
+  // total to take os_accomodation into account.
+  const double kTemporaryPoolSizeRatio = 1.0 / 3.0;  // 33%
+
+  // The fraction of the device's storage the browser attempts to
+  // keep free.
+  const double kMustRemainAvailableRatio = 0.1;
+
+  // Determines the portion of the temp pool that can be
+  // utilized by a single host (ie. 5 for 20%).
+  const int kPerHostTemporaryPortion = 5;
+
+  // os_accomodation is an estimate of how much storage is needed for
+  // the os and essential application code outside of the browser.
+  const int64_t kDefaultOSAccomodation =
+#if defined(OS_ANDROID)
+      1000 * kMBytes;
+#elif defined(OS_CHROMEOS)

[cmumford, 2016/10/25 20:30:54]

Do you think we should have a different value for Chromecast? I think that's a
runtime check.

[michaeln, 2016/10/26 21:47:53]

i think chromecast uses a different ContentBrowserClient derivative, its also in
this CL, but if thats not right, yes, agreed about needing a value that makes
sense for it

+      1000 * kMBytes;
+#elif defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
+      10000 * kMBytes;
+#else
+#error "Port: Need to define os_accomodation for unknown os."
+#endif
+
+  storage::TemporaryStorageConfiguration config;
+
+  int64_t total = base::SysInfo::AmountOfTotalDiskSpace(partition_path);
+  if (total == -1) {
+    LOG(ERROR) << "Failed to get the amount of total disk space.";
+    config.refresh_interval = base::TimeDelta::FromSeconds(60);
+    return config;
+  }
+
+  // If our hardcoded os accomodation is too large for the volume size, define
+  // the value as a large fraction of the total volume size instead.
+  int64_t os_accomodation = std::min(kDefaultOSAccomodation,
+                                     static_cast<int64_t>(total * 0.8));
+
+  int64_t adjusted_total = total - os_accomodation;
+  int64_t pool_size = adjusted_total * kTemporaryPoolSizeRatio;
+  UMA_HISTOGRAM_MBYTES("Quota.GlobalTemporaryPoolSize", pool_size);
+
+  config.pool_size = pool_size;
+  config.must_remain_available = total * kMustRemainAvailableRatio;
+  config.per_host_quota = pool_size / kPerHostTemporaryPortion;;

[cmumford, 2016/10/25 20:30:54]

double ;;

[michaeln, 2016/10/26 21:47:53]

Done.

+  config.refresh_interval = base::TimeDelta::FromSeconds(60);
+  return config;
+}
+
+}  // namespace
+
+void  ChromeContentBrowserClient::GetTemporaryStorageConfiguration(
+    content::BrowserContext* context,
+    const base::FilePath& partition_path, bool is_incognito,
+    const storage::TemporaryStorageConfigurationCallback& callback) {
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&CalculateTemporaryStorageConfig,
+                 partition_path, is_incognito),
+      callback);
+}
+
 void ChromeContentBrowserClient::AllowCertificateError(
     content::WebContents* web_contents,
     int cert_error,
     const net::SSLInfo& ssl_info,
     const GURL& request_url,
     ResourceType resource_type,
     bool overridable,
     bool strict_enforcement,
     bool expired_previous_decision,
     const base::Callback<void(content::CertificateRequestResultType)>&
@@ skipping 1120 matching lines @@
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)
 
 std::unique_ptr<content::MemoryCoordinatorDelegate>
 ChromeContentBrowserClient::GetMemoryCoordinatorDelegate() {
   return memory::ChromeMemoryCoordinatorDelegate::Create();
 }