Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

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 "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 28 matching lines @@
 using content::BrowserThread;
 
 namespace extensions {
 
 namespace {
 
 // The rate at which we would like to observe storage events.
 const int kStorageEventRateSec = 30;
 
 // The storage type to monitor.
-const quota::StorageType kMonitorStorageType = quota::kStorageTypePersistent;
+const storage::StorageType kMonitorStorageType =
+    storage::kStorageTypePersistent;
 
 // Set the thresholds for the first notification. Ephemeral apps have a lower
 // threshold than installed extensions and apps. Once a threshold is exceeded,
 // it will be doubled to throttle notifications.
 const int64 kMBytes = 1024 * 1024;
 const int64 kEphemeralAppInitialThreshold = 250 * kMBytes;
 const int64 kExtensionInitialThreshold = 1000 * kMBytes;
 
 // Notifications have an ID so that we can update them.
 const char kNotificationIdFormat[] = "ExtensionStorageMonitor-$1-$2";
@@ skipping 21 matching lines @@
   return ExtensionRegistry::Get(context)->GetExtensionById(
       extension_id, ExtensionRegistry::EVERYTHING);
 }
 
 }  // 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,
-          BrowserThread::DeleteOnIOThread>,
-      public quota::StorageObserver {
+    : public base::RefCountedThreadSafe<StorageEventObserver,
+                                        BrowserThread::DeleteOnIOThread>,
+      public storage::StorageObserver {
  public:
   explicit StorageEventObserver(
       base::WeakPtr<ExtensionStorageMonitor> storage_monitor)
       : storage_monitor_(storage_monitor) {
   }
 
   // Register as an observer for the extension's storage events.
   void StartObservingForExtension(
-      scoped_refptr<quota::QuotaManager> quota_manager,
+      scoped_refptr<storage::QuotaManager> quota_manager,
       const std::string& extension_id,
       const GURL& site_url,
       int64 next_threshold,
       int rate) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     DCHECK(quota_manager.get());
 
     GURL origin = site_url.GetOrigin();
     StorageState& state = origin_state_map_[origin];
     state.quota_manager = quota_manager;
     state.extension_id = extension_id;
     state.next_threshold = next_threshold;
 
-    quota::StorageObserver::MonitorParams params(
-        kMonitorStorageType,
-        origin,
-        base::TimeDelta::FromSeconds(rate),
-        false);
+    storage::StorageObserver::MonitorParams params(
+        kMonitorStorageType, origin, base::TimeDelta::FromSeconds(rate), false);
     quota_manager->AddStorageObserver(this, params);
   }
 
   // Updates the threshold for an extension already being monitored.
   void UpdateThresholdForExtension(const std::string& extension_id,
                                    int64 next_threshold) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
          it != origin_state_map_.end();
          ++it) {
       if (it->second.extension_id == extension_id) {
         it->second.next_threshold = next_threshold;
         break;
       }
     }
   }
 
   // Deregister as an observer for the extension's storage events.
   void StopObservingForExtension(const std::string& extension_id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
          it != origin_state_map_.end(); ) {
       if (it->second.extension_id == extension_id) {
-        quota::StorageObserver::Filter filter(kMonitorStorageType, it->first);
+        storage::StorageObserver::Filter filter(kMonitorStorageType, it->first);
         it->second.quota_manager->RemoveStorageObserverForFilter(this, filter);
         origin_state_map_.erase(it++);
       } else {
         ++it;
       }
     }
   }
 
   // Stop observing all storage events. Called during shutdown.
   void StopObserving() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
          it != origin_state_map_.end(); ++it) {
       it->second.quota_manager->RemoveStorageObserver(this);
     }
     origin_state_map_.clear();
   }
 
  private:
   friend class base::DeleteHelper<StorageEventObserver>;
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::IO>;
 
   struct StorageState {
-    scoped_refptr<quota::QuotaManager> quota_manager;
+    scoped_refptr<storage::QuotaManager> quota_manager;
     std::string extension_id;
     int64 next_threshold;
 
     StorageState() : next_threshold(0) {}
   };
   typedef std::map<GURL, StorageState> OriginStorageStateMap;
 
   virtual ~StorageEventObserver() {
     DCHECK(origin_state_map_.empty());
     StopObserving();
   }
 
-  // quota::StorageObserver implementation.
+  // storage::StorageObserver implementation.
   virtual void OnStorageEvent(const Event& event) OVERRIDE {
     OriginStorageStateMap::iterator state =
         origin_state_map_.find(event.filter.origin);
     if (state == origin_state_map_.end())
       return;
 
     if (event.usage >= state->second.next_threshold) {
       while (event.usage >= state->second.next_threshold)
         state->second.next_threshold *= 2;
 
@@ skipping 267 matching lines @@
   if (!storage_observer_.get()) {
     storage_observer_ =
         new StorageEventObserver(weak_ptr_factory_.GetWeakPtr());
   }
 
   GURL site_url =
       extensions::util::GetSiteForExtensionId(extension->id(), context_);
   content::StoragePartition* storage_partition =
       content::BrowserContext::GetStoragePartitionForSite(context_, site_url);
   DCHECK(storage_partition);
-  scoped_refptr<quota::QuotaManager> quota_manager(
+  scoped_refptr<storage::QuotaManager> quota_manager(
       storage_partition->GetQuotaManager());
 
   GURL storage_origin(site_url.GetOrigin());
   if (extension->is_hosted_app())
     storage_origin = AppLaunchInfo::GetLaunchWebURL(extension).GetOrigin();
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&StorageEventObserver::StartObservingForExtension,
@@ skipping 127 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