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

webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc

 // Copyright 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 "webkit/browser/fileapi/sandbox_file_system_backend_delegate.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 10 matching lines @@
 #include "webkit/browser/fileapi/obfuscated_file_util.h"
 #include "webkit/browser/fileapi/quota/quota_backend_impl.h"
 #include "webkit/browser/fileapi/quota/quota_reservation.h"
 #include "webkit/browser/fileapi/quota/quota_reservation_manager.h"
 #include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
 #include "webkit/browser/fileapi/sandbox_quota_observer.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-namespace fileapi {
+namespace storage {
 
 namespace {
 
 const char kTemporaryOriginsCountLabel[] = "FileSystem.TemporaryOriginsCount";
 const char kPersistentOriginsCountLabel[] = "FileSystem.PersistentOriginsCount";
 
 const char kOpenFileSystemLabel[] = "FileSystem.OpenFileSystem";
 const char kOpenFileSystemDetailLabel[] = "FileSystem.OpenFileSystemDetail";
 const char kOpenFileSystemDetailNonThrottledLabel[] =
     "FileSystem.OpenFileSystemDetailNonthrottled";
@@ skipping 121 matching lines @@
     case kFileSystemTypeSyncableForInternalSync:
       return kSyncableDirectoryName;
     case kFileSystemTypeUnknown:
     default:
       NOTREACHED() << "Unknown filesystem type requested:" << type;
       return std::string();
   }
 }
 
 SandboxFileSystemBackendDelegate::SandboxFileSystemBackendDelegate(
-    quota::QuotaManagerProxy* quota_manager_proxy,
+    storage::QuotaManagerProxy* quota_manager_proxy,
     base::SequencedTaskRunner* file_task_runner,
     const base::FilePath& profile_path,
-    quota::SpecialStoragePolicy* special_storage_policy,
+    storage::SpecialStoragePolicy* special_storage_policy,
     const FileSystemOptions& file_system_options)
     : file_task_runner_(file_task_runner),
       sandbox_file_util_(new AsyncFileUtilAdapter(
-          new ObfuscatedFileUtil(
-              special_storage_policy,
-              profile_path.Append(kFileSystemDirectory),
-              file_system_options.env_override(),
-              file_task_runner,
-              base::Bind(&GetTypeStringForURL),
-              GetKnownTypeStrings(),
-              this))),
+          new ObfuscatedFileUtil(special_storage_policy,
+                                 profile_path.Append(kFileSystemDirectory),
+                                 file_system_options.env_override(),
+                                 file_task_runner,
+                                 base::Bind(&GetTypeStringForURL),
+                                 GetKnownTypeStrings(),
+                                 this))),
       file_system_usage_cache_(new FileSystemUsageCache(file_task_runner)),
-      quota_observer_(new SandboxQuotaObserver(
-          quota_manager_proxy,
-          file_task_runner,
-          obfuscated_file_util(),
-          usage_cache())),
+      quota_observer_(new SandboxQuotaObserver(quota_manager_proxy,
+                                               file_task_runner,
+                                               obfuscated_file_util(),
+                                               usage_cache())),
       quota_reservation_manager_(new QuotaReservationManager(
           scoped_ptr<QuotaReservationManager::QuotaBackend>(
               new QuotaBackendImpl(file_task_runner_,
                                    obfuscated_file_util(),
                                    usage_cache(),
                                    quota_manager_proxy)))),
       special_storage_policy_(special_storage_policy),
       file_system_options_(file_system_options),
       is_filesystem_opened_(false),
       weak_factory_(this) {
@@ skipping 86 matching lines @@
 
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
   operation_context->set_update_observers(*update_observers);
   operation_context->set_change_observers(
       change_observers ? *change_observers : ChangeObserverList());
 
   return operation_context.Pass();
 }
 
-scoped_ptr<webkit_blob::FileStreamReader>
+scoped_ptr<storage::FileStreamReader>
 SandboxFileSystemBackendDelegate::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     FileSystemContext* context) const {
   if (!IsAccessValid(url))
-    return scoped_ptr<webkit_blob::FileStreamReader>();
-  return scoped_ptr<webkit_blob::FileStreamReader>(
-      webkit_blob::FileStreamReader::CreateForFileSystemFile(
+    return scoped_ptr<storage::FileStreamReader>();
+  return scoped_ptr<storage::FileStreamReader>(
+      storage::FileStreamReader::CreateForFileSystemFile(
           context, url, offset, expected_modification_time));
 }
 
 scoped_ptr<FileStreamWriter>
 SandboxFileSystemBackendDelegate::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context,
     FileSystemType type) const {
   if (!IsAccessValid(url))
     return scoped_ptr<FileStreamWriter>();
   const UpdateObserverList* observers = GetUpdateObservers(type);
   DCHECK(observers);
   return scoped_ptr<FileStreamWriter>(
       new SandboxFileStreamWriter(context, url, offset, *observers));
 }
 
 base::File::Error
 SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner(
     FileSystemContext* file_system_context,
-    quota::QuotaManagerProxy* proxy,
+    storage::QuotaManagerProxy* proxy,
     const GURL& origin_url,
     FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   int64 usage = GetOriginUsageOnFileTaskRunner(
       file_system_context, origin_url, type);
   usage_cache()->CloseCacheFiles();
   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
       origin_url, GetTypeString(type));
   if (result && proxy) {
-    proxy->NotifyStorageModified(
-        quota::QuotaClient::kFileSystem,
-        origin_url,
-        FileSystemTypeToQuotaStorageType(type),
-        -usage);
+    proxy->NotifyStorageModified(storage::QuotaClient::kFileSystem,
+                                 origin_url,
+                                 FileSystemTypeToQuotaStorageType(type),
+                                 -usage);
   }
 
   if (result)
     return base::File::FILE_OK;
   return base::File::FILE_ERROR_FAILED;
 }
 
 void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileTaskRunner(
     FileSystemType type, std::set<GURL>* origins) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 298 matching lines @@
 #undef REPORT
 }
 
 ObfuscatedFileUtil* SandboxFileSystemBackendDelegate::obfuscated_file_util() {
   return static_cast<ObfuscatedFileUtil*>(sync_file_util());
 }
 
 // Declared in obfuscated_file_util.h.
 // static
 ObfuscatedFileUtil* ObfuscatedFileUtil::CreateForTesting(
-    quota::SpecialStoragePolicy* special_storage_policy,
+    storage::SpecialStoragePolicy* special_storage_policy,
     const base::FilePath& file_system_directory,
     leveldb::Env* env_override,
     base::SequencedTaskRunner* file_task_runner) {
   return new ObfuscatedFileUtil(special_storage_policy,
                                 file_system_directory,
                                 env_override,
                                 file_task_runner,
                                 base::Bind(&GetTypeStringForURL),
                                 GetKnownTypeStrings(),
                                 NULL);
 }
 
-}  // namespace fileapi
+}  // namespace storage