Revert of Change how the quota system computes the total poolsize for temporary storage

chrome/browser/extensions/extension_storage_monitor.cc

 // Copyright 2014 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_storage_monitor.h"
 
 #include <map>
 #include <utility>
 
 #include "base/metrics/histogram_macros.h"
@@ skipping 66 matching lines @@
   // We want to know the usage of hosted apps' storage.
   return ShouldMonitorStorageFor(extension) && extension->is_hosted_app();
 }
 
 const Extension* GetExtensionById(content::BrowserContext* context,
                                   const std::string& extension_id) {
   return ExtensionRegistry::Get(context)->GetExtensionById(
       extension_id, ExtensionRegistry::EVERYTHING);
 }
 
-void LogTemporaryStorageUsage(
-    scoped_refptr<storage::QuotaManager> quota_manager,
-    int64_t usage) {
-  const storage::QuotaSettings& settings = quota_manager->settings();
-  if (settings.per_host_quota > 0) {
+void LogTemporaryStorageUsage(int64_t usage,
+                              storage::QuotaStatusCode status,
+                              int64_t global_quota) {
+  if (status == storage::kQuotaStatusOk) {
+    int64_t per_app_quota =
+        global_quota / storage::QuotaManager::kPerHostTemporaryPortion;
     // Note we use COUNTS_100 (instead of PERCENT) because this can potentially
     // exceed 100%.
     UMA_HISTOGRAM_COUNTS_100(
         "Extensions.HostedAppUnlimitedStorageTemporaryStorageUsage",
-        100.0 * usage / settings.per_host_quota);
+        100.0 * usage / per_app_quota);
   }
 }
 
 }  // namespace
 
 // StorageEventObserver monitors the storage usage of extensions and lives on
 // the IO thread. When a threshold is exceeded, a message will be posted to the
 // UI thread, which displays the notification.
 class StorageEventObserver
     : public base::RefCountedThreadSafe<StorageEventObserver,
@@ skipping 120 matching lines @@
     StorageState& state = iter->second;
 
     if (state.should_uma) {
       if (event.filter.storage_type == storage::kStorageTypePersistent) {
         UMA_HISTOGRAM_MEMORY_KB(
             "Extensions.HostedAppUnlimitedStoragePersistentStorageUsage",
             event.usage);
       } else {
         // We can't use the quota in the event because it assumes unlimited
         // storage.
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                                base::Bind(&LogTemporaryStorageUsage,
-                                           state.quota_manager, event.usage));
+        BrowserThread::PostTask(
+            BrowserThread::IO,
+            FROM_HERE,
+            base::Bind(&storage::QuotaManager::GetTemporaryGlobalQuota,
+                       state.quota_manager,
+                       base::Bind(&LogTemporaryStorageUsage, event.usage)));
       }
     }
 
     if (state.next_threshold != -1 &&
         event.usage >= state.next_threshold) {
       while (event.usage >= state.next_threshold)
         state.next_threshold *= 2;
 
       BrowserThread::PostTask(
           BrowserThread::UI,
@@ skipping 394 matching lines @@
 void ExtensionStorageMonitor::SetStorageNotificationEnabled(
     const std::string& extension_id,
     bool enable_notifications) {
   extension_prefs_->UpdateExtensionPref(
       extension_id,
       kPrefDisableStorageNotifications,
       enable_notifications ? NULL : new base::FundamentalValue(true));
 }
 
 }  // namespace extensions