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

chrome/browser/extensions/api/sync_file_system/sync_file_system_api.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/api/sync_file_system/sync_file_system_api.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 50 matching lines @@
       sync_file_system::SyncStatusCodeToString(code),
       static_cast<int>(code));
 }
 
 }  // namespace
 
 bool SyncFileSystemDeleteFileSystemFunction::RunAsync() {
   std::string url;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &url));
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       BrowserContext::GetStoragePartition(GetProfile(),
                                           render_view_host()->GetSiteInstance())
           ->GetFileSystemContext();
-  fileapi::FileSystemURL file_system_url(
+  storage::FileSystemURL file_system_url(
       file_system_context->CrackURL(GURL(url)));
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      Bind(&fileapi::FileSystemContext::DeleteFileSystem,
+      Bind(&storage::FileSystemContext::DeleteFileSystem,
            file_system_context,
            source_url().GetOrigin(),
            file_system_url.type(),
            Bind(&SyncFileSystemDeleteFileSystemFunction::DidDeleteFileSystem,
                 this)));
   return true;
 }
 
 void SyncFileSystemDeleteFileSystemFunction::DidDeleteFileSystem(
     base::File::Error error) {
@@ skipping 21 matching lines @@
 }
 
 bool SyncFileSystemRequestFileSystemFunction::RunAsync() {
   // SyncFileSystem initialization is done in OpenFileSystem below, but we call
   // GetSyncFileSystemService here too to initialize sync event observer for
   // extensions API.
   GetSyncFileSystemService(GetProfile());
 
   // Initializes sync context for this extension and continue to open
   // a new file system.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      Bind(&fileapi::FileSystemContext::OpenFileSystem,
-           GetFileSystemContext(),
-           source_url().GetOrigin(),
-           fileapi::kFileSystemTypeSyncable,
-           fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
-           base::Bind(&self::DidOpenFileSystem, this)));
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          Bind(&storage::FileSystemContext::OpenFileSystem,
+                               GetFileSystemContext(),
+                               source_url().GetOrigin(),
+                               storage::kFileSystemTypeSyncable,
+                               storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                               base::Bind(&self::DidOpenFileSystem, this)));
   return true;
 }
 
-fileapi::FileSystemContext*
+storage::FileSystemContext*
 SyncFileSystemRequestFileSystemFunction::GetFileSystemContext() {
   DCHECK(render_view_host());
   return BrowserContext::GetStoragePartition(
       GetProfile(), render_view_host()->GetSiteInstance())
       ->GetFileSystemContext();
 }
 
 void SyncFileSystemRequestFileSystemFunction::DidOpenFileSystem(
     const GURL& root_url,
     const std::string& file_system_name,
@@ skipping 19 matching lines @@
   SetResult(dict);
   dict->SetString("name", file_system_name);
   dict->SetString("root", root_url.spec());
   SendResponse(true);
 }
 
 bool SyncFileSystemGetFileStatusFunction::RunAsync() {
   std::string url;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &url));
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       BrowserContext::GetStoragePartition(GetProfile(),
                                           render_view_host()->GetSiteInstance())
           ->GetFileSystemContext();
-  fileapi::FileSystemURL file_system_url(
+  storage::FileSystemURL file_system_url(
       file_system_context->CrackURL(GURL(url)));
 
   GetSyncFileSystemService(GetProfile())->GetFileSyncStatus(
       file_system_url,
       Bind(&SyncFileSystemGetFileStatusFunction::DidGetFileStatus, this));
   return true;
 }
 
 void SyncFileSystemGetFileStatusFunction::DidGetFileStatus(
     const SyncStatusCode sync_status_code,
@@ skipping 15 matching lines @@
 }
 
 SyncFileSystemGetFileStatusesFunction::~SyncFileSystemGetFileStatusesFunction(
     ) {}
 
 bool SyncFileSystemGetFileStatusesFunction::RunAsync() {
   // All FileEntries converted into array of URL Strings in JS custom bindings.
   base::ListValue* file_entry_urls = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetList(0, &file_entry_urls));
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       BrowserContext::GetStoragePartition(GetProfile(),
                                           render_view_host()->GetSiteInstance())
           ->GetFileSystemContext();
 
   // Map each file path->SyncFileStatus in the callback map.
   // TODO(calvinlo): Overload GetFileSyncStatus to take in URL array.
   num_expected_results_ = file_entry_urls->GetSize();
   num_results_received_ = 0;
   file_sync_statuses_.clear();
   sync_file_system::SyncFileSystemService* sync_file_system_service =
       GetSyncFileSystemService(GetProfile());
   for (unsigned int i = 0; i < num_expected_results_; i++) {
     std::string url;
     file_entry_urls->GetString(i, &url);
-    fileapi::FileSystemURL file_system_url(
+    storage::FileSystemURL file_system_url(
         file_system_context->CrackURL(GURL(url)));
 
     sync_file_system_service->GetFileSyncStatus(
         file_system_url,
         Bind(&SyncFileSystemGetFileStatusesFunction::DidGetFileStatus,
              this, file_system_url));
   }
 
   return true;
 }
 
 void SyncFileSystemGetFileStatusesFunction::DidGetFileStatus(
-    const fileapi::FileSystemURL& file_system_url,
+    const storage::FileSystemURL& file_system_url,
     SyncStatusCode sync_status_code,
     SyncFileStatus sync_file_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   num_results_received_++;
   DCHECK_LE(num_results_received_, num_expected_results_);
 
   file_sync_statuses_[file_system_url] =
       std::make_pair(sync_status_code, sync_file_status);
 
   // Keep mapping file statuses until all of them have been received.
   // TODO(calvinlo): Get rid of this check when batch version of
   // GetFileSyncStatus(GURL urls[]); is added.
   if (num_results_received_ < num_expected_results_)
     return;
 
   // All results received. Dump array of statuses into extension enum values.
   // Note that the enum types need to be set as strings manually as the
   // autogenerated Results::Create function thinks the enum values should be
   // returned as int values.
   base::ListValue* status_array = new base::ListValue();
   for (URLToStatusMap::iterator it = file_sync_statuses_.begin();
        it != file_sync_statuses_.end(); ++it) {
     base::DictionaryValue* dict = new base::DictionaryValue();
     status_array->Append(dict);
 
-    fileapi::FileSystemURL url = it->first;
+    storage::FileSystemURL url = it->first;
     SyncStatusCode file_error = it->second.first;
     api::sync_file_system::FileStatus file_status =
         SyncFileStatusToExtensionEnum(it->second.second);
 
     dict->Set("entry", CreateDictionaryValueForFileSystemEntry(
         url, sync_file_system::SYNC_FILE_TYPE_FILE));
     dict->SetString("status", ToString(file_status));
 
     if (file_error == sync_file_system::SYNC_STATUS_OK)
       continue;
     dict->SetString("error", ErrorToString(file_error));
   }
   SetResult(status_array);
 
   SendResponse(true);
 }
 
 bool SyncFileSystemGetUsageAndQuotaFunction::RunAsync() {
   std::string url;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &url));
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       BrowserContext::GetStoragePartition(GetProfile(),
                                           render_view_host()->GetSiteInstance())
           ->GetFileSystemContext();
-  fileapi::FileSystemURL file_system_url(
+  storage::FileSystemURL file_system_url(
       file_system_context->CrackURL(GURL(url)));
 
-  scoped_refptr<quota::QuotaManager> quota_manager =
+  scoped_refptr<storage::QuotaManager> quota_manager =
       BrowserContext::GetStoragePartition(GetProfile(),
                                           render_view_host()->GetSiteInstance())
           ->GetQuotaManager();
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      Bind(&quota::QuotaManager::GetUsageAndQuotaForWebApps,
+      Bind(&storage::QuotaManager::GetUsageAndQuotaForWebApps,
            quota_manager,
            source_url().GetOrigin(),
-           fileapi::FileSystemTypeToQuotaStorageType(file_system_url.type()),
+           storage::FileSystemTypeToQuotaStorageType(file_system_url.type()),
            Bind(&SyncFileSystemGetUsageAndQuotaFunction::DidGetUsageAndQuota,
                 this)));
 
   return true;
 }
 
 void SyncFileSystemGetUsageAndQuotaFunction::DidGetUsageAndQuota(
-      quota::QuotaStatusCode status, int64 usage, int64 quota) {
+    storage::QuotaStatusCode status,
+    int64 usage,
+    int64 quota) {
   // Repost to switch from IO thread to UI thread for SendResponse().
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         Bind(&SyncFileSystemGetUsageAndQuotaFunction::DidGetUsageAndQuota, this,
              status, usage, quota));
     return;
   }
 
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (status != quota::kQuotaStatusOk) {
+  if (status != storage::kQuotaStatusOk) {
     error_ = QuotaStatusCodeToString(status);
     SendResponse(false);
     return;
   }
 
   api::sync_file_system::StorageInfo info;
   info.usage_bytes = usage;
   info.quota_bytes = quota;
   results_ = api::sync_file_system::GetUsageAndQuota::Results::Create(info);
   SendResponse(true);
@@ skipping 21 matching lines @@
 
 bool SyncFileSystemGetServiceStatusFunction::RunSync() {
   sync_file_system::SyncFileSystemService* service =
       GetSyncFileSystemService(GetProfile());
   results_ = api::sync_file_system::GetServiceStatus::Results::Create(
       SyncServiceStateToExtensionEnum(service->GetSyncServiceState()));
   return true;
 }
 
 }  // namespace extensions