Gather metrics on hosted app unlimitedStorage usage

chrome/browser/extensions/extension_special_storage_policy.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/extensions/extension_special_storage_policy.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/manifest_handlers/app_isolation_info.h"
+#include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/url_constants.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/permissions/permissions_data.h"
+#include "storage/browser/quota/quota_manager.h"
+#include "storage/common/quota/quota_status_code.h"
+#include "storage/common/quota/quota_types.h"
 
 using content::BrowserThread;
 using extensions::APIPermission;
 using extensions::Extension;
 using storage::SpecialStoragePolicy;
 
+namespace {
+
+void ReportQuotaUsage(storage::QuotaStatusCode code, int64 usage, int64 quota) {
+  if (code == storage::kQuotaStatusOk) {
+    // We're interested in the amount of space hosted apps are using. Record it
+    // when the extension is granted the unlimited storage permission (once per
+    // extension load, so on average once per run).
+    UMA_HISTOGRAM_MEMORY_KB("Extensions.HostedAppUnlimitedStorageUsage", usage);
+  }
+}
+
+// Log the usage for a hosted app with unlimited storage.
+void LogHostedAppUnlimitedStorageUsage(
+    scoped_refptr<const Extension> extension,
+    content::BrowserContext* browser_context) {
+  GURL launch_url =
+      extensions::AppLaunchInfo::GetLaunchWebURL(extension.get()).GetOrigin();
+  content::StoragePartition* partition =
+      browser_context ?  // |browser_context| can be NULL in unittests.
+      content::BrowserContext::GetStoragePartitionForSite(browser_context,
+                                                          launch_url) :
+      NULL;
+  if (partition) {
+    // We only have to query for kStorageTypePersistent data usage, because apps
+    // cannot ask for any more temporary storage, according to
+    // https://developers.google.com/chrome/whitepapers/storage.
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&storage::QuotaManager::GetUsageAndQuotaForWebApps,
+                   partition->GetQuotaManager(),
+                   launch_url,
+                   storage::kStorageTypePersistent,
+                   base::Bind(&ReportQuotaUsage)));
+  }
+}
+
+}  // namespace
+
 ExtensionSpecialStoragePolicy::ExtensionSpecialStoragePolicy(
     CookieSettings* cookie_settings)
     : cookie_settings_(cookie_settings) {}
 
 ExtensionSpecialStoragePolicy::~ExtensionSpecialStoragePolicy() {}
 
 bool ExtensionSpecialStoragePolicy::IsStorageProtected(const GURL& origin) {
   if (origin.SchemeIs(extensions::kExtensionScheme))
     return true;
   base::AutoLock locker(lock_);
@@ skipping 54 matching lines @@
 }
 
 const extensions::ExtensionSet*
 ExtensionSpecialStoragePolicy::ExtensionsProtectingOrigin(
     const GURL& origin) {
   base::AutoLock locker(lock_);
   return protected_apps_.ExtensionsContaining(origin);
 }
 
 void ExtensionSpecialStoragePolicy::GrantRightsForExtension(
-    const extensions::Extension* extension) {
+    const extensions::Extension* extension,
+    content::BrowserContext* browser_context) {
   DCHECK(extension);
   if (!(NeedsProtection(extension) ||
         extension->permissions_data()->HasAPIPermission(
             APIPermission::kUnlimitedStorage) ||
         extension->permissions_data()->HasAPIPermission(
             APIPermission::kFileBrowserHandler) ||
         extensions::AppIsolationInfo::HasIsolatedStorage(extension) ||
         extension->is_app())) {
     return;
   }
 
   int change_flags = 0;
   {
     base::AutoLock locker(lock_);
     if (NeedsProtection(extension) && protected_apps_.Add(extension))
       change_flags |= SpecialStoragePolicy::STORAGE_PROTECTED;
     // FIXME: Does GrantRightsForExtension imply |extension| is installed?
     if (extension->is_app())
       installed_apps_.Add(extension);
 
     if (extension->permissions_data()->HasAPIPermission(
             APIPermission::kUnlimitedStorage) &&
-        unlimited_extensions_.Add(extension))
+        unlimited_extensions_.Add(extension)) {
+      if (extension->is_hosted_app())
+        LogHostedAppUnlimitedStorageUsage(extension, browser_context);
+
       change_flags |= SpecialStoragePolicy::STORAGE_UNLIMITED;
+    }
 
     if (extension->permissions_data()->HasAPIPermission(
             APIPermission::kFileBrowserHandler))
       file_handler_extensions_.Add(extension);
 
     if (extensions::AppIsolationInfo::HasIsolatedStorage(extension))
       isolated_extensions_.Add(extension);
   }
 
   if (change_flags) {
@@ skipping 142 matching lines @@
 
 void ExtensionSpecialStoragePolicy::SpecialCollection::Clear() {
   ClearCache();
   extensions_.Clear();
 }
 
 void ExtensionSpecialStoragePolicy::SpecialCollection::ClearCache() {
   STLDeleteValues(&cached_results_);
   cached_results_.clear();
 }