Purge browser cache for dom storage in a smarter way

content/browser/dom_storage/dom_storage_context_impl.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 "content/browser/dom_storage/dom_storage_context_impl.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/location.h"
+#include "base/metrics/histogram.h"
+#include "base/sys_info.h"
 #include "base/time/time.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_database.h"
 #include "content/browser/dom_storage/dom_storage_namespace.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/session_storage_database.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/session_storage_usage_info.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
+namespace {
 
-static const int kSessionStoraceScavengingSeconds = 60;
+// Limits on the cache size and number of areas in memory, over which the areas
+// are purged.
+#if defined(OS_ANDROID)
+const unsigned kMaxStorageAreaCount = 20;
+const size_t kMaxCacheSize = 2 * 1024 * 1024;
+#else
+const unsigned kMaxStorageAreaCount = 100;
+const size_t kMaxCacheSize = 20 * 1024 * 1024;
+#endif
+
+const int kSessionStoraceScavengingSeconds = 60;
 
 // Offset the session storage namespace ids generated by different contexts
 // to help identify when an id from one is mistakenly used in another.
-static int g_session_id_offset_sequence = 1;
+int g_session_id_offset_sequence = 1;
+
+// Aggregates statistics from all the namespaces.
+DOMStorageNamespace::UsageStatistics GetTotalNamespaceStatistics(
+    const DOMStorageContextImpl::StorageNamespaceMap& namespace_map) {
+  DOMStorageNamespace::UsageStatistics total_stats = {0};
+  for (const auto& it : namespace_map) {
+    DOMStorageNamespace::UsageStatistics stats =
+        it.second->GetUsageStatistics();
+    total_stats.total_cache_size += stats.total_cache_size;
+    total_stats.total_area_count += stats.total_area_count;
+    total_stats.inactive_area_count += stats.inactive_area_count;
+  }
+  return total_stats;
+}
+
+}  // namespace
 
 DOMStorageContextImpl::DOMStorageContextImpl(
     const base::FilePath& localstorage_directory,
     const base::FilePath& sessionstorage_directory,
     storage::SpecialStoragePolicy* special_storage_policy,
     DOMStorageTaskRunner* task_runner)
     : localstorage_directory_(localstorage_directory),
       sessionstorage_directory_(sessionstorage_directory),
       task_runner_(task_runner),
       session_id_offset_(abs((g_session_id_offset_sequence++ % 10)) * 1000),
       is_shutdown_(false),
       force_keep_session_state_(false),
       special_storage_policy_(special_storage_policy),
-      scavenging_started_(false) {
+      scavenging_started_(false),
+      is_low_end_device_(base::SysInfo::IsLowEndDevice()) {
   // AtomicSequenceNum starts at 0 but we want to start session
   // namespace ids at one since zero is reserved for the
   // kLocalStorageNamespaceId.
   session_id_sequence_.GetNext();
 
   // Tests may run without task runners.
   if (task_runner_) {
     // Registering dump provider is safe even outside the task runner.
     base::trace_event::MemoryDumpManager::GetInstance()
         ->RegisterDumpProviderWithSequencedTaskRunner(
@@ skipping 328 matching lines @@
 
 void DOMStorageContextImpl::StartScavengingUnusedSessionStorage() {
   if (session_storage_database_.get()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DOMStorageContextImpl::FindUnusedNamespaces,
                               this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
+void DOMStorageContextImpl::PurgeMemory(PurgeOption purge_option) {
+  if (is_shutdown_)
+    return;
+
+  DOMStorageNamespace::UsageStatistics initial_stats =
+      GetTotalNamespaceStatistics(namespaces_);
+
+  // Track the total localStorage cache size.
+  UMA_HISTOGRAM_CUSTOM_COUNTS("LocalStorage.BrowserLocalStorageCacheSizeInKB",
+                              initial_stats.total_cache_size / 1024, 0, 100000,

[Mark P, 2016/05/23 18:27:14]

There is already an "underflow" bucket; please use a min_value of 1, not 0.
ditto below

[ssid, 2016/05/23 18:42:17]

Done.

+                              50);
+
+  if (purge_option == PURGE_IF_NEEDED) {
+    // Purging is done based on the cache sizes without including the database
+    // size since it can be expensive trying to estimate the sqlite usage for
+    // all databases. For low end devices purge all inactive areas.
+    bool should_purge =
+        (is_low_end_device_ && initial_stats.inactive_area_count) ||
+        initial_stats.total_cache_size > kMaxCacheSize ||
+        initial_stats.total_area_count > kMaxStorageAreaCount;
+    if (!should_purge)
+      return;
+
+    purge_option = PURGE_UNOPENED;
+  }
+
+  bool aggressively = purge_option == PURGE_AGGRESSIVE;
+  for (const auto& it : namespaces_)
+    it.second->PurgeMemory(aggressively);
+
+  // Track the size of cache purged.
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      "LocalStorage.BrowserLocalStorageCachePurgedInKB",
+      (initial_stats.total_cache_size -
+       GetTotalNamespaceStatistics(namespaces_).total_cache_size) /
+          1024,
+      0, 100000, 50);
+}
+
 bool DOMStorageContextImpl::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   for (const auto& it : namespaces_) {
     it.second->OnMemoryDump(pmd);
   }
   if (session_storage_database_)
     session_storage_database_->OnMemoryDump(pmd);
   return true;
 }
@@ skipping 61 matching lines @@
   if (!deletable_persistent_namespace_ids_.empty()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(
             &DOMStorageContextImpl::DeleteNextUnusedNamespace,
             this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
 }  // namespace content