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

content/browser/devtools/renderer_overrides_handler.cc

 // Copyright (c) 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 "content/browser/devtools/renderer_overrides_handler.h"
 
 #include <map>
 #include <string>
 
 #include "base/barrier_closure.h"
@@ skipping 714 matching lines @@
     const std::string& client_id,
     const base::Closure& barrier,
     int64 value) {
   base::DictionaryValue* usage_item = new base::DictionaryValue;
   usage_item->SetString(devtools::Page::UsageItem::kParamId, client_id);
   usage_item->SetDouble(devtools::Page::UsageItem::kParamValue, value);
   list->Append(usage_item);
   barrier.Run();
 }
 
-void DidGetQuotaValue(
-    base::DictionaryValue* dictionary,
-    const std::string& item_name,
-    const base::Closure& barrier,
-    quota::QuotaStatusCode status,
-    int64 value) {
-  if (status == quota::kQuotaStatusOk)
+void DidGetQuotaValue(base::DictionaryValue* dictionary,
+                      const std::string& item_name,
+                      const base::Closure& barrier,
+                      storage::QuotaStatusCode status,
+                      int64 value) {
+  if (status == storage::kQuotaStatusOk)
     dictionary->SetDouble(item_name, value);
   barrier.Run();
 }
 
-void DidGetUsageAndQuotaForWebApps(
-    base::DictionaryValue* quota,
-    const std::string& item_name,
-    const base::Closure& barrier,
-    quota::QuotaStatusCode status,
-    int64 used_bytes,
-    int64 quota_in_bytes) {
-  if (status == quota::kQuotaStatusOk)
+void DidGetUsageAndQuotaForWebApps(base::DictionaryValue* quota,
+                                   const std::string& item_name,
+                                   const base::Closure& barrier,
+                                   storage::QuotaStatusCode status,
+                                   int64 used_bytes,
+                                   int64 quota_in_bytes) {
+  if (status == storage::kQuotaStatusOk)
     quota->SetDouble(item_name, quota_in_bytes);
   barrier.Run();
 }
 
-std::string GetStorageTypeName(quota::StorageType type) {
+std::string GetStorageTypeName(storage::StorageType type) {
   switch (type) {
-    case quota::kStorageTypeTemporary:
+    case storage::kStorageTypeTemporary:
       return devtools::Page::Usage::kParamTemporary;
-    case quota::kStorageTypePersistent:
+    case storage::kStorageTypePersistent:
       return devtools::Page::Usage::kParamPersistent;
-    case quota::kStorageTypeSyncable:
+    case storage::kStorageTypeSyncable:
       return devtools::Page::Usage::kParamSyncable;
-    case quota::kStorageTypeQuotaNotManaged:
-    case quota::kStorageTypeUnknown:
+    case storage::kStorageTypeQuotaNotManaged:
+    case storage::kStorageTypeUnknown:
       NOTREACHED();
   }
   return "";
 }
 
-std::string GetQuotaClientName(quota::QuotaClient::ID id) {
+std::string GetQuotaClientName(storage::QuotaClient::ID id) {
   switch (id) {
-    case quota::QuotaClient::kFileSystem:
+    case storage::QuotaClient::kFileSystem:
       return devtools::Page::UsageItem::Id::kEnumFilesystem;
-    case quota::QuotaClient::kDatabase:
+    case storage::QuotaClient::kDatabase:
       return devtools::Page::UsageItem::Id::kEnumDatabase;
-    case quota::QuotaClient::kAppcache:
+    case storage::QuotaClient::kAppcache:
       return devtools::Page::UsageItem::Id::kEnumAppcache;
-    case quota::QuotaClient::kIndexedDatabase:
+    case storage::QuotaClient::kIndexedDatabase:
       return devtools::Page::UsageItem::Id::kEnumIndexeddatabase;
     default:
       NOTREACHED();
   }
   return "";
 }
 
 void QueryUsageAndQuotaOnIOThread(
-    scoped_refptr<quota::QuotaManager> quota_manager,
+    scoped_refptr<storage::QuotaManager> quota_manager,
     const GURL& security_origin,
     const ResponseCallback& callback) {
   scoped_ptr<base::DictionaryValue> quota(new base::DictionaryValue);
   scoped_ptr<base::DictionaryValue> usage(new base::DictionaryValue);
 
-  static quota::QuotaClient::ID kQuotaClients[] = {
-      quota::QuotaClient::kFileSystem,
-      quota::QuotaClient::kDatabase,
-      quota::QuotaClient::kAppcache,
-      quota::QuotaClient::kIndexedDatabase
-  };
+  static storage::QuotaClient::ID kQuotaClients[] = {
+      storage::QuotaClient::kFileSystem, storage::QuotaClient::kDatabase,
+      storage::QuotaClient::kAppcache, storage::QuotaClient::kIndexedDatabase};
 
-  static const size_t kStorageTypeCount = quota::kStorageTypeUnknown;
-  std::map<quota::StorageType, base::ListValue*> storage_type_lists;
+  static const size_t kStorageTypeCount = storage::kStorageTypeUnknown;
+  std::map<storage::StorageType, base::ListValue*> storage_type_lists;
 
   for (size_t i = 0; i != kStorageTypeCount; i++) {
-    const quota::StorageType type = static_cast<quota::StorageType>(i);
-    if (type == quota::kStorageTypeQuotaNotManaged)
+    const storage::StorageType type = static_cast<storage::StorageType>(i);
+    if (type == storage::kStorageTypeQuotaNotManaged)
       continue;
     storage_type_lists[type] = new base::ListValue;
     usage->Set(GetStorageTypeName(type), storage_type_lists[type]);
   }
 
   const int kExpectedResults =
       2 + arraysize(kQuotaClients) * storage_type_lists.size();
   base::DictionaryValue* quota_raw_ptr = quota.get();
 
   // Takes ownership on usage and quota.
   base::Closure barrier = BarrierClosure(
       kExpectedResults,
       base::Bind(&QueryUsageAndQuotaCompletedOnIOThread,
                  base::Passed(&quota),
                  base::Passed(&usage),
                  callback));
   std::string host = net::GetHostOrSpecFromURL(security_origin);
 
   quota_manager->GetUsageAndQuotaForWebApps(
       security_origin,
-      quota::kStorageTypeTemporary,
-      base::Bind(&DidGetUsageAndQuotaForWebApps, quota_raw_ptr,
-                 std::string(devtools::Page::Quota::kParamTemporary), barrier));
+      storage::kStorageTypeTemporary,
+      base::Bind(&DidGetUsageAndQuotaForWebApps,
+                 quota_raw_ptr,
+                 std::string(devtools::Page::Quota::kParamTemporary),
+                 barrier));
 
   quota_manager->GetPersistentHostQuota(
       host,
       base::Bind(&DidGetQuotaValue, quota_raw_ptr,
                  std::string(devtools::Page::Quota::kParamPersistent),
                  barrier));
 
   for (size_t i = 0; i != arraysize(kQuotaClients); i++) {
-    std::map<quota::StorageType, base::ListValue*>::const_iterator iter;
+    std::map<storage::StorageType, base::ListValue*>::const_iterator iter;
     for (iter = storage_type_lists.begin();
          iter != storage_type_lists.end(); ++iter) {
-      const quota::StorageType type = (*iter).first;
+      const storage::StorageType type = (*iter).first;
       if (!quota_manager->IsTrackingHostUsage(type, kQuotaClients[i])) {
         barrier.Run();
         continue;
       }
       quota_manager->GetHostUsage(
           host, type, kQuotaClients[i],
           base::Bind(&DidGetHostUsage, (*iter).second,
                      GetQuotaClientName(kQuotaClients[i]),
                      barrier));
     }
@@ skipping 15 matching lines @@
   }
 
   ResponseCallback callback = base::Bind(
       &RendererOverridesHandler::PageQueryUsageAndQuotaCompleted,
       weak_factory_.GetWeakPtr(),
       command);
 
   if (!host_)
     return command->InternalErrorResponse("Could not connect to view");
 
-  scoped_refptr<quota::QuotaManager> quota_manager =
+  scoped_refptr<storage::QuotaManager> quota_manager =
       host_->GetProcess()->GetStoragePartition()->GetQuotaManager();
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &QueryUsageAndQuotaOnIOThread,
           quota_manager,
           GURL(security_origin),
           callback));
 
@@ skipping 389 matching lines @@
     return;
   bool enabled = touch_emulation_enabled_ || screencast_command_;
   host_->SetTouchEventEmulationEnabled(enabled);
   WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
       WebContents::FromRenderViewHost(host_));
   if (web_contents)
     web_contents->SetForceDisableOverscrollContent(enabled);
 }
 
 }  // namespace content