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

webkit/browser/fileapi/plugin_private_file_system_backend.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/plugin_private_file_system_backend.h"
 
 #include <map>
 
 #include "base/stl_util.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.h"
 #include "net/base/net_util.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/async_file_util_adapter.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_options.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/obfuscated_file_util.h"
 #include "webkit/browser/fileapi/quota/quota_reservation.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-namespace fileapi {
+namespace storage {
 
 class PluginPrivateFileSystemBackend::FileSystemIDToPluginMap {
  public:
   explicit FileSystemIDToPluginMap(base::SequencedTaskRunner* task_runner)
       : task_runner_(task_runner) {}
   ~FileSystemIDToPluginMap() {}
 
   std::string GetPluginIDForURL(const FileSystemURL& url) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     Map::iterator found = map_.find(url.filesystem_id());
@@ skipping 44 matching lines @@
   if (error == base::File::FILE_OK)
     plugin_map->RegisterFileSystem(filesystem_id, plugin_id);
   return error;
 }
 
 }  // namespace
 
 PluginPrivateFileSystemBackend::PluginPrivateFileSystemBackend(
     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),
       file_system_options_(file_system_options),
-      base_path_(profile_path.Append(
-          kFileSystemDirectory).Append(kPluginPrivateDirectory)),
+      base_path_(profile_path.Append(kFileSystemDirectory)
+                     .Append(kPluginPrivateDirectory)),
       plugin_map_(new FileSystemIDToPluginMap(file_task_runner)),
       weak_factory_(this) {
   file_util_.reset(
       new AsyncFileUtilAdapter(new ObfuscatedFileUtil(
           special_storage_policy,
           base_path_, file_system_options.env_override(),
           file_task_runner,
           base::Bind(&FileSystemIDToPluginMap::GetPluginIDForURL,
                      base::Owned(plugin_map_)),
           std::set<std::string>(),
@@ skipping 66 matching lines @@
 FileSystemOperation* PluginPrivateFileSystemBackend::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context,
     base::File::Error* error_code) const {
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
   return FileSystemOperation::Create(url, context, operation_context.Pass());
 }
 
 bool PluginPrivateFileSystemBackend::SupportsStreaming(
-    const fileapi::FileSystemURL& url) const {
+    const storage::FileSystemURL& url) const {
   return false;
 }
 
 bool PluginPrivateFileSystemBackend::HasInplaceCopyImplementation(
-    fileapi::FileSystemType type) const {
+    storage::FileSystemType type) const {
   return false;
 }
 
-scoped_ptr<webkit_blob::FileStreamReader>
+scoped_ptr<storage::FileStreamReader>
 PluginPrivateFileSystemBackend::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     FileSystemContext* context) const {
-  return scoped_ptr<webkit_blob::FileStreamReader>();
+  return scoped_ptr<storage::FileStreamReader>();
 }
 
 scoped_ptr<FileStreamWriter>
 PluginPrivateFileSystemBackend::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   return scoped_ptr<FileStreamWriter>();
 }
 
 FileSystemQuotaUtil* PluginPrivateFileSystemBackend::GetQuotaUtil() {
   return this;
 }
 
 base::File::Error
 PluginPrivateFileSystemBackend::DeleteOriginDataOnFileTaskRunner(
     FileSystemContext* context,
-    quota::QuotaManagerProxy* proxy,
+    storage::QuotaManagerProxy* proxy,
     const GURL& origin_url,
     FileSystemType type) {
   if (!CanHandleType(type))
     return base::File::FILE_ERROR_SECURITY;
   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
       origin_url, std::string());
   if (result)
     return base::File::FILE_OK;
   return base::File::FILE_ERROR_FAILED;
 }
@@ skipping 70 matching lines @@
 const AccessObserverList* PluginPrivateFileSystemBackend::GetAccessObservers(
     FileSystemType type) const {
   return NULL;
 }
 
 ObfuscatedFileUtil* PluginPrivateFileSystemBackend::obfuscated_file_util() {
   return static_cast<ObfuscatedFileUtil*>(
       static_cast<AsyncFileUtilAdapter*>(file_util_.get())->sync_file_util());
 }
 
-}  // namespace fileapi
+}  // namespace storage