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

webkit/browser/fileapi/file_system_context.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 "webkit/browser/fileapi/file_system_context.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
@@ skipping 13 matching lines @@
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/isolated_file_system_backend.h"
 #include "webkit/browser/fileapi/mount_points.h"
 #include "webkit/browser/fileapi/quota/quota_reservation.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 #include "webkit/browser/quota/special_storage_policy.h"
 #include "webkit/common/fileapi/file_system_info.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-using quota::QuotaClient;
+using storage::QuotaClient;
 
-namespace fileapi {
+namespace storage {
 
 namespace {
 
 QuotaClient* CreateQuotaClient(
     FileSystemContext* context,
     bool is_incognito) {
   return new FileSystemQuotaClient(context, is_incognito);
 }
 
 
@@ skipping 80 matching lines @@
       return FILE_PERMISSION_ALWAYS_DENY;
   }
   NOTREACHED();
   return FILE_PERMISSION_ALWAYS_DENY;
 }
 
 FileSystemContext::FileSystemContext(
     base::SingleThreadTaskRunner* io_task_runner,
     base::SequencedTaskRunner* file_task_runner,
     ExternalMountPoints* external_mount_points,
-    quota::SpecialStoragePolicy* special_storage_policy,
-    quota::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy,
+    storage::QuotaManagerProxy* quota_manager_proxy,
     ScopedVector<FileSystemBackend> additional_backends,
     const std::vector<URLRequestAutoMountHandler>& auto_mount_handlers,
     const base::FilePath& partition_path,
     const FileSystemOptions& options)
     : io_task_runner_(io_task_runner),
       default_file_task_runner_(file_task_runner),
       quota_manager_proxy_(quota_manager_proxy),
-      sandbox_delegate_(new SandboxFileSystemBackendDelegate(
-          quota_manager_proxy,
-          file_task_runner,
-          partition_path,
-          special_storage_policy,
-          options)),
-      sandbox_backend_(new SandboxFileSystemBackend(
-          sandbox_delegate_.get())),
+      sandbox_delegate_(
+          new SandboxFileSystemBackendDelegate(quota_manager_proxy,
+                                               file_task_runner,
+                                               partition_path,
+                                               special_storage_policy,
+                                               options)),
+      sandbox_backend_(new SandboxFileSystemBackend(sandbox_delegate_.get())),
       isolated_backend_(new IsolatedFileSystemBackend()),
-      plugin_private_backend_(new PluginPrivateFileSystemBackend(
-          file_task_runner,
-          partition_path,
-          special_storage_policy,
-          options)),
+      plugin_private_backend_(
+          new PluginPrivateFileSystemBackend(file_task_runner,
+                                             partition_path,
+                                             special_storage_policy,
+                                             options)),
       additional_backends_(additional_backends.Pass()),
       auto_mount_handlers_(auto_mount_handlers),
       external_mount_points_(external_mount_points),
       partition_path_(partition_path),
       is_incognito_(options.is_incognito()),
       operation_runner_(new FileSystemOperationRunner(this)) {
   RegisterBackend(sandbox_backend_.get());
   RegisterBackend(isolated_backend_.get());
   RegisterBackend(plugin_private_backend_.get());
 
@@ skipping 242 matching lines @@
       // It is safe to pass Unretained(quota_util) since context owns it.
       base::Bind(&FileSystemQuotaUtil::DeleteOriginDataOnFileTaskRunner,
                  base::Unretained(backend->GetQuotaUtil()),
                  make_scoped_refptr(this),
                  base::Unretained(quota_manager_proxy()),
                  origin_url,
                  type),
       callback);
 }
 
-scoped_ptr<webkit_blob::FileStreamReader>
-FileSystemContext::CreateFileStreamReader(
+scoped_ptr<storage::FileStreamReader> FileSystemContext::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time) {
   if (!url.is_valid())
-    return scoped_ptr<webkit_blob::FileStreamReader>();
+    return scoped_ptr<storage::FileStreamReader>();
   FileSystemBackend* backend = GetFileSystemBackend(url.type());
   if (!backend)
-    return scoped_ptr<webkit_blob::FileStreamReader>();
+    return scoped_ptr<storage::FileStreamReader>();
   return backend->CreateFileStreamReader(
       url, offset, expected_modification_time, this);
 }
 
 scoped_ptr<FileStreamWriter> FileSystemContext::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset) {
   if (!url.is_valid())
     return scoped_ptr<FileStreamWriter>();
   FileSystemBackend* backend = GetFileSystemBackend(url.type());
@@ skipping 159 matching lines @@
     const std::string& filesystem_name,
     base::File::Error error) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   if (error != base::File::FILE_OK) {
     callback.Run(error, FileSystemInfo(), base::FilePath(),
                  FileSystemContext::RESOLVED_ENTRY_NOT_FOUND);
     return;
   }
 
-  fileapi::FileSystemInfo info(
+  storage::FileSystemInfo info(
       filesystem_name, filesystem_root, url.mount_type());
 
   // Extract the virtual path not containing a filesystem type part from |url|.
   base::FilePath parent = CrackURL(filesystem_root).virtual_path();
   base::FilePath child = url.virtual_path();
   base::FilePath path;
 
   if (parent.empty()) {
     path = child;
   } else if (parent != child) {
     bool result = parent.AppendRelativePath(child, &path);
     DCHECK(result);
   }
 
   operation_runner()->GetMetadata(
       url, base::Bind(&DidGetMetadataForResolveURL, path, callback, info));
 }
 
-}  // namespace fileapi
+}  // namespace storage