Move storage-related files from webkit/ to new top-level directory storage/

storage/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 "storage/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"
+#include "storage/browser/blob/file_stream_reader.h"
+#include "storage/browser/fileapi/async_file_util_adapter.h"
+#include "storage/browser/fileapi/file_stream_writer.h"
+#include "storage/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_operation.h"
+#include "storage/browser/fileapi/file_system_operation_context.h"
+#include "storage/browser/fileapi/file_system_options.h"
+#include "storage/browser/fileapi/isolated_context.h"
+#include "storage/browser/fileapi/obfuscated_file_util.h"
+#include "storage/browser/fileapi/quota/quota_reservation.h"
+#include "storage/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 48 matching lines @@
 
 }  // namespace
 
 PluginPrivateFileSystemBackend::PluginPrivateFileSystemBackend(
     base::SequencedTaskRunner* file_task_runner,
     const base::FilePath& profile_path,
     quota::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>(),
-          NULL)));
+  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>(),
+      NULL)));
 }
 
 PluginPrivateFileSystemBackend::~PluginPrivateFileSystemBackend() {
   if (!file_task_runner_->RunsTasksOnCurrentThread()) {
     AsyncFileUtil* file_util = file_util_.release();
     if (!file_task_runner_->DeleteSoon(FROM_HERE, file_util))
       delete file_util;
   }
 }
 
 void PluginPrivateFileSystemBackend::OpenPrivateFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     const std::string& filesystem_id,
     const std::string& plugin_id,
     OpenFileSystemMode mode,
     const StatusCallback& callback) {
   if (!CanHandleType(type) || file_system_options_.is_incognito()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, base::File::FILE_ERROR_SECURITY));
     return;
   }
 
-  PostTaskAndReplyWithResult(
-      file_task_runner_.get(),
-      FROM_HERE,
-      base::Bind(&OpenFileSystemOnFileTaskRunner,
-                 obfuscated_file_util(), plugin_map_,
-                 origin_url, filesystem_id, plugin_id, mode),
-      callback);
+  PostTaskAndReplyWithResult(file_task_runner_.get(),
+                             FROM_HERE,
+                             base::Bind(&OpenFileSystemOnFileTaskRunner,
+                                        obfuscated_file_util(),
+                                        plugin_map_,
+                                        origin_url,
+                                        filesystem_id,
+                                        plugin_id,
+                                        mode),
+                             callback);
 }
 
 bool PluginPrivateFileSystemBackend::CanHandleType(FileSystemType type) const {
   return type == kFileSystemTypePluginPrivate;
 }
 
 void PluginPrivateFileSystemBackend::Initialize(FileSystemContext* context) {
 }
 
 void PluginPrivateFileSystemBackend::ResolveURL(
     const FileSystemURL& url,
     OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback) {
   // We never allow opening a new plugin-private filesystem via usual
   // ResolveURL.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(callback, GURL(), std::string(),
-                 base::File::FILE_ERROR_SECURITY));
+      base::Bind(
+          callback, GURL(), std::string(), base::File::FILE_ERROR_SECURITY));
 }
 
-AsyncFileUtil*
-PluginPrivateFileSystemBackend::GetAsyncFileUtil(FileSystemType type) {
+AsyncFileUtil* PluginPrivateFileSystemBackend::GetAsyncFileUtil(
+    FileSystemType type) {
   return file_util_.get();
 }
 
 CopyOrMoveFileValidatorFactory*
 PluginPrivateFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
     FileSystemType type,
     base::File::Error* error_code) {
   DCHECK(error_code);
   *error_code = base::File::FILE_OK;
   return NULL;
 }
 
 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;
 }
 
-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>();
 }
 
@@ skipping 56 matching lines @@
     const GURL& origin_url,
     FileSystemType type) {
   // We don't track usage on this filesystem.
   NOTREACHED();
   return scoped_refptr<QuotaReservation>();
 }
 
 void PluginPrivateFileSystemBackend::AddFileUpdateObserver(
     FileSystemType type,
     FileUpdateObserver* observer,
-    base::SequencedTaskRunner* task_runner) {}
+    base::SequencedTaskRunner* task_runner) {
+}
 
 void PluginPrivateFileSystemBackend::AddFileChangeObserver(
     FileSystemType type,
     FileChangeObserver* observer,
-    base::SequencedTaskRunner* task_runner) {}
+    base::SequencedTaskRunner* task_runner) {
+}
 
 void PluginPrivateFileSystemBackend::AddFileAccessObserver(
     FileSystemType type,
     FileAccessObserver* observer,
-    base::SequencedTaskRunner* task_runner) {}
+    base::SequencedTaskRunner* task_runner) {
+}
 
 const UpdateObserverList* PluginPrivateFileSystemBackend::GetUpdateObservers(
     FileSystemType type) const {
   return NULL;
 }
 
 const ChangeObserverList* PluginPrivateFileSystemBackend::GetChangeObservers(
     FileSystemType type) const {
   return NULL;
 }
 
 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