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 2021 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)          \
+  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().
+    storage::TemporaryStorageConfiguration config;
+    config.pool_size = 300 * kMBytes;
+    config.must_remain_available = 0;
+    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.

[jsbell, 2016/10/17 23:56:54]

Nit: capitalize OS in comments/strings (here and below)

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

Done.

+  const int64_t kDefaultOSAccomodation =
+#if defined(OS_ANDROID)
+      1000 * kMBytes;
+#elif defined(OS_CHROMEOS)
+      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,

[jsbell, 2016/10/17 23:56:54]

TODO: UMA histogram for kDefaultOSAccomodation / (total * 0.8) ?

if it's > 1 we need to figure out why and tweak our numbers

(and make sure total != 0)

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

Done.

+                                     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);

[jsbell, 2016/10/17 23:56:53]

This was UMA stat was previously recorded from QuotaManager, and with this CL
the Quota.QuotaForOrigin still is recorded from QuotaManager. ISTM we'd want
them recorded from the same place.

If we record them here then we're missing out on getting stats non-Chrome
clients. So... maybe record them from QuotaManager and add additional stats here
for Chrome specifically? 

(Maybe we don't get stats from non-Chrome clients so it's moot?)

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

Done - now gathering this stat in quota_manager.cc

+
+  config.pool_size = pool_size;
+  config.must_remain_available = total * kMustRemainAvailableRatio;
+  config.per_host_quota = pool_size / kPerHostTemporaryPortion;;
+  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 1144 matching lines @@
   if (channel <= kMaxDisableEncryptionChannel) {
     static const char* const kWebRtcDevSwitchNames[] = {
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)