Quota: Add metrics about the age and amount of data stored in temporary storage, and a metric about…

storage/browser/quota/quota_manager.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 "storage/browser/quota/quota_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 #include <limits>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/url_util.h"
 #include "storage/browser/quota/client_usage_tracker.h"
@@ skipping 300 matching lines @@
     quota = std::min(quota, QuotaManager::kIncognitoDefaultQuotaLimit);
     callback.Run(status, usage, quota);
     return;
   }
 
   // For apps with unlimited permission or can_query_disk_size is true (and not
   // in incognito mode).
   // We assume we can expose the actual disk size for them and cap the quota by
   // the available disk space.
   if (is_unlimited || can_query_disk_size) {
-    callback.Run(
-        status, usage,
-        CalculateQuotaWithDiskSpace(
-            usage_and_quota.available_disk_space,
-            usage, quota));
-    return;
+    quota = CalculateQuotaWithDiskSpace(
+        usage_and_quota.available_disk_space,
+        usage, quota);
   }
 
   callback.Run(status, usage, quota);
+
+  if (type == kStorageTypeTemporary && !is_unlimited)
+    UMA_HISTOGRAM_MBYTES("Quota.QuotaForOrigin", quota);
 }
 
 }  // namespace
 
 UsageAndQuota::UsageAndQuota()
     : usage(0),
       global_limited_usage(0),
       quota(0),
       available_disk_space(0) {
 }
@@ skipping 1109 matching lines @@
     return;
   }
 
   DCHECK(origin == origin.GetOrigin());
   OriginDataDeleter* deleter = new OriginDataDeleter(
       this, origin, type, quota_client_mask, is_eviction, callback);
   deleter->Start();
 }
 
 void QuotaManager::ReportHistogram() {
+  DCHECK(!is_incognito_);
   GetGlobalUsage(kStorageTypeTemporary,
                  base::Bind(
                      &QuotaManager::DidGetTemporaryGlobalUsageForHistogram,
                      weak_factory_.GetWeakPtr()));
-  GetGlobalUsage(kStorageTypePersistent,
-                 base::Bind(
-                     &QuotaManager::DidGetPersistentGlobalUsageForHistogram,
-                     weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetTemporaryGlobalUsageForHistogram(
     int64_t usage,
     int64_t unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfTemporaryStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(kStorageTypeTemporary, &origins);
 
   size_t num_origins = origins.size();
   size_t protected_origins = 0;
   size_t unlimited_origins = 0;
   CountOriginType(origins,
                   special_storage_policy_.get(),
                   &protected_origins,
                   &unlimited_origins);
-
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfTemporaryStorageOrigins",
                        num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedTemporaryStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedTemporaryStorageOrigins",
                        unlimited_origins);
+
+  GetGlobalUsage(kStorageTypePersistent,
+                 base::Bind(
+                     &QuotaManager::DidGetPersistentGlobalUsageForHistogram,
+                     weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetPersistentGlobalUsageForHistogram(
     int64_t usage,
     int64_t unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfPersistentStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(kStorageTypePersistent, &origins);
 
   size_t num_origins = origins.size();
   size_t protected_origins = 0;
   size_t unlimited_origins = 0;
   CountOriginType(origins,
                   special_storage_policy_.get(),
                   &protected_origins,
                   &unlimited_origins);
-
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfPersistentStorageOrigins",
                        num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedPersistentStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedPersistentStorageOrigins",
                        unlimited_origins);
+
+  // We DumpOriginInfoTable last to ensure the trackers caches are loaded.
+  DumpOriginInfoTable(
+      base::Bind(&QuotaManager::DidDumpOriginInfoTableForHistogram,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void QuotaManager::DidDumpOriginInfoTableForHistogram(
+    const OriginInfoTableEntries& entries) {
+  using UsageMap = std::map<GURL, int64_t>;
+  UsageMap usage_map;
+  GetUsageTracker(kStorageTypeTemporary)->GetCachedOriginsUsage(&usage_map);
+  base::Time now = base::Time::Now();
+  for (const auto& info : entries) {
+    if (info.type != kStorageTypeTemporary)
+      continue;
+
+    // Ignore stale database entries. If there is no map entry, the origin's
+    // data has been deleted.
+    UsageMap::const_iterator found = usage_map.find(info.origin);
+    if (found == usage_map.end() || found->second == 0)
+      continue;
+
+    base::TimeDelta age = now - std::max(info.last_access_time,
+                                         info.last_modified_time);
+    UMA_HISTOGRAM_COUNTS_1000("Quota.AgeOfOriginInDays", age.InDays());
+
+    int64_t kilobytes = std::max(found->second / INT64_C(1024), INT64_C(1));
+    base::Histogram::FactoryGet(
+        "Quota.AgeOfDataInDays", 1, 1000, 50,
+        base::HistogramBase::kUmaTargetedHistogramFlag)->
+            AddCount(age.InDays(),
+                     base::saturated_cast<int>(kilobytes));
+  }
 }
 
 std::set<GURL> QuotaManager::GetEvictionOriginExceptions(
     const std::set<GURL>& extra_exceptions) {
   std::set<GURL> exceptions = extra_exceptions;
   for (const auto& p : origins_in_use_) {
     if (p.second > 0)
       exceptions.insert(p.first);
   }
 
@@ skipping 163 matching lines @@
 }
 
 void QuotaManager::DidInitialize(int64_t* temporary_quota_override,
                                  int64_t* desired_available_space,
                                  bool success) {
   temporary_quota_override_ = *temporary_quota_override;
   desired_available_space_ = *desired_available_space;
   temporary_quota_initialized_ = true;
   DidDatabaseWork(success);
 
-  histogram_timer_.Start(FROM_HERE,
-                         base::TimeDelta::FromMilliseconds(
-                             kReportHistogramInterval),
-                         this, &QuotaManager::ReportHistogram);
+  if (!is_incognito_) {
+    histogram_timer_.Start(FROM_HERE,
+                           base::TimeDelta::FromMilliseconds(
+                               kReportHistogramInterval),
+                           this, &QuotaManager::ReportHistogram);
+  }
 
   db_initialization_callbacks_.Run();
   GetTemporaryGlobalQuota(
       base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
                  weak_factory_.GetWeakPtr(), base::TimeTicks::Now()));
 }
 
 void QuotaManager::DidGetLRUOrigin(const GURL* origin,
                                    bool success) {
   DidDatabaseWork(success);
@@ skipping 102 matching lines @@
     return false;
   *available_space = static_cast<uint64_t>(stats.f_bavail) * stats.f_frsize;
   *total_size = static_cast<uint64_t>(stats.f_blocks) * stats.f_frsize;
 #else
 #error Not implemented
 #endif
   return true;
 }
 
 }  // namespace storage