Purge browser cache for dom storage in a smarter way

content/browser/dom_storage/dom_storage_namespace.cc

 // Copyright 2013 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_namespace.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
@@ skipping 99 matching lines @@
     area->DeleteOrigin();
   }
 }
 
 void DOMStorageNamespace::DeleteSessionStorageOrigin(const GURL& origin) {
   DOMStorageArea* area = OpenStorageArea(origin);
   area->FastClear();
   CloseStorageArea(area);
 }
 
-void DOMStorageNamespace::PurgeMemory(PurgeOption option) {
+void DOMStorageNamespace::PurgeMemory(bool aggressively) {
   if (directory_.empty())
     return;  // We can't purge w/o backing on disk.
+
   AreaMap::iterator it = areas_.begin();
   while (it != areas_.end()) {
     const AreaHolder& holder = it->second;
 
     // We can't purge if there are changes pending.
     if (holder.area_->HasUncommittedChanges()) {
       if (holder.open_count_ == 0) {
          // Schedule an immediate commit so the next time we're asked to purge,
          // we can drop it from memory.
          holder.area_->ScheduleImmediateCommit();
       }
       ++it;
       continue;
     }
 
     // If not in use, we can shut it down and remove
     // it from our collection entirely.
     if (holder.open_count_ == 0) {
       holder.area_->Shutdown();
       areas_.erase(it++);
       continue;
     }
 
-    if (option == PURGE_AGGRESSIVE) {
+    if (aggressively) {
       // If aggressive is true, we clear caches and such
       // for opened areas.
       holder.area_->PurgeMemory();
     }
 
     ++it;
   }
 }
 
 void DOMStorageNamespace::Shutdown() {
   AreaMap::const_iterator it = areas_.begin();
   for (; it != areas_.end(); ++it)
     it->second.area_->Shutdown();
 }
 
 void DOMStorageNamespace::Flush() {
   for (auto& entry : areas_) {
     if (!entry.second.area_->HasUncommittedChanges())
       continue;
     entry.second.area_->ScheduleImmediateCommit();
   }
 }
 
-unsigned int DOMStorageNamespace::CountInMemoryAreas() const {
-  unsigned int area_count = 0;
+DOMStorageNamespace::UsageStatistics DOMStorageNamespace::GetUsageStatistics()
+    const {
+  UsageStatistics stats = {0};
   for (AreaMap::const_iterator it = areas_.begin(); it != areas_.end(); ++it) {
-    if (it->second.area_->IsLoadedInMemory())
-      ++area_count;
+    if (it->second.area_->IsLoadedInMemory()) {
+      stats.total_cache_size += it->second.area_->map_usage_in_bytes();
+      ++stats.total_area_count;
+      if (it->second.open_count_ == 0)
+        ++stats.inactive_area_count;
+    }
   }
-  return area_count;
+  return stats;
 }
 
 void DOMStorageNamespace::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd) {
   DCHECK(task_runner_->IsRunningOnPrimarySequence());
   for (const auto& it : areas_)
     it.second.area_->OnMemoryDump(pmd);
 }
 
 void DOMStorageNamespace::GetOriginsWithAreas(
@@ skipping 21 matching lines @@
     DOMStorageArea* area, int count)
     : area_(area), open_count_(count) {
 }
 
 DOMStorageNamespace::AreaHolder::AreaHolder(const AreaHolder& other) = default;
 
 DOMStorageNamespace::AreaHolder::~AreaHolder() {
 }
 
 }  // namespace content