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

chrome/browser/browsing_data/browsing_data_quota_helper_impl.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/browsing_data/browsing_data_quota_helper_impl.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 39 matching lines @@
 
   quota_manager_->SetPersistentHostQuota(
       host, 0,
       base::Bind(&BrowsingDataQuotaHelperImpl::DidRevokeHostQuota,
                  weak_factory_.GetWeakPtr()));
 }
 
 BrowsingDataQuotaHelperImpl::BrowsingDataQuotaHelperImpl(
     base::MessageLoopProxy* ui_thread,
     base::MessageLoopProxy* io_thread,
-    quota::QuotaManager* quota_manager)
+    storage::QuotaManager* quota_manager)
     : BrowsingDataQuotaHelper(io_thread),
       quota_manager_(quota_manager),
       is_fetching_(false),
       ui_thread_(ui_thread),
       io_thread_(io_thread),
       weak_factory_(this) {
   DCHECK(quota_manager);
 }
 
 BrowsingDataQuotaHelperImpl::~BrowsingDataQuotaHelperImpl() {}
 
 void BrowsingDataQuotaHelperImpl::FetchQuotaInfo() {
   if (!io_thread_->BelongsToCurrentThread()) {
     io_thread_->PostTask(
         FROM_HERE,
         base::Bind(&BrowsingDataQuotaHelperImpl::FetchQuotaInfo, this));
     return;
   }
 
   quota_manager_->GetOriginsModifiedSince(
-      quota::kStorageTypeTemporary,
+      storage::kStorageTypeTemporary,
       base::Time(),
       base::Bind(&BrowsingDataQuotaHelperImpl::GotOrigins,
                  weak_factory_.GetWeakPtr()));
 }
 
-void BrowsingDataQuotaHelperImpl::GotOrigins(
-    const std::set<GURL>& origins, quota::StorageType type) {
+void BrowsingDataQuotaHelperImpl::GotOrigins(const std::set<GURL>& origins,
+                                             storage::StorageType type) {
   for (std::set<GURL>::const_iterator itr = origins.begin();
        itr != origins.end();
        ++itr)
     if (BrowsingDataHelper::HasWebScheme(*itr))
       pending_hosts_.insert(std::make_pair(itr->host(), type));
 
-  DCHECK(type == quota::kStorageTypeTemporary ||
-         type == quota::kStorageTypePersistent ||
-         type == quota::kStorageTypeSyncable);
+  DCHECK(type == storage::kStorageTypeTemporary ||
+         type == storage::kStorageTypePersistent ||
+         type == storage::kStorageTypeSyncable);
 
   // Calling GetOriginsModifiedSince() for all types by chaining callbacks.
-  if (type == quota::kStorageTypeTemporary) {
+  if (type == storage::kStorageTypeTemporary) {
     quota_manager_->GetOriginsModifiedSince(
-        quota::kStorageTypePersistent,
+        storage::kStorageTypePersistent,
         base::Time(),
         base::Bind(&BrowsingDataQuotaHelperImpl::GotOrigins,
                    weak_factory_.GetWeakPtr()));
-  } else if (type == quota::kStorageTypePersistent) {
+  } else if (type == storage::kStorageTypePersistent) {
     quota_manager_->GetOriginsModifiedSince(
-        quota::kStorageTypeSyncable,
+        storage::kStorageTypeSyncable,
         base::Time(),
         base::Bind(&BrowsingDataQuotaHelperImpl::GotOrigins,
                    weak_factory_.GetWeakPtr()));
   } else {
-    DCHECK(type == quota::kStorageTypeSyncable);
+    DCHECK(type == storage::kStorageTypeSyncable);
     ProcessPendingHosts();
   }
 }
 
 void BrowsingDataQuotaHelperImpl::ProcessPendingHosts() {
   if (pending_hosts_.empty()) {
     OnComplete();
     return;
   }
 
   PendingHosts::iterator itr = pending_hosts_.begin();
   std::string host = itr->first;
-  quota::StorageType type = itr->second;
+  storage::StorageType type = itr->second;
   pending_hosts_.erase(itr);
   GetHostUsage(host, type);
 }
 
 void BrowsingDataQuotaHelperImpl::GetHostUsage(const std::string& host,
-                                               quota::StorageType type) {
+                                               storage::StorageType type) {
   DCHECK(quota_manager_.get());
   quota_manager_->GetHostUsage(
       host, type,
       base::Bind(&BrowsingDataQuotaHelperImpl::GotHostUsage,
                  weak_factory_.GetWeakPtr(), host, type));
 }
 
 void BrowsingDataQuotaHelperImpl::GotHostUsage(const std::string& host,
-                                               quota::StorageType type,
+                                               storage::StorageType type,
                                                int64 usage) {
   switch (type) {
-    case quota::kStorageTypeTemporary:
+    case storage::kStorageTypeTemporary:
       quota_info_[host].temporary_usage = usage;
       break;
-    case quota::kStorageTypePersistent:
+    case storage::kStorageTypePersistent:
       quota_info_[host].persistent_usage = usage;
       break;
-    case quota::kStorageTypeSyncable:
+    case storage::kStorageTypeSyncable:
       quota_info_[host].syncable_usage = usage;
       break;
     default:
       NOTREACHED();
   }
   ProcessPendingHosts();
 }
 
 void BrowsingDataQuotaHelperImpl::OnComplete() {
   if (!ui_thread_->BelongsToCurrentThread()) {
@@ skipping 19 matching lines @@
 
     info->host = itr->first;
     result.push_back(*info);
   }
 
   callback_.Run(result);
   callback_.Reset();
 }
 
 void BrowsingDataQuotaHelperImpl::DidRevokeHostQuota(
-    quota::QuotaStatusCode status_unused,
+    storage::QuotaStatusCode status_unused,
     int64 quota_unused) {
 }