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

content/child/fileapi/file_system_dispatcher.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 "content/child/fileapi/file_system_dispatcher.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/process/process.h"
 #include "content/child/child_thread.h"
 #include "content/common/fileapi/file_system_messages.h"
-#include "webkit/common/fileapi/file_system_info.h"
+#include "storage/common/fileapi/file_system_info.h"
 
 namespace content {
 
 class FileSystemDispatcher::CallbackDispatcher {
  public:
   typedef CallbackDispatcher self;
   typedef FileSystemDispatcher::StatusCallback StatusCallback;
   typedef FileSystemDispatcher::MetadataCallback MetadataCallback;
   typedef FileSystemDispatcher::ReadDirectoryCallback ReadDirectoryCallback;
   typedef FileSystemDispatcher::OpenFileSystemCallback OpenFileSystemCallback;
@@ skipping 65 matching lines @@
     metadata_callback_.Run(file_info);
   }
 
   void DidCreateSnapshotFile(
       const base::File::Info& file_info,
       const base::FilePath& platform_path,
       int request_id) {
     snapshot_callback_.Run(file_info, platform_path, request_id);
   }
 
-  void DidReadDirectory(
-      const std::vector<fileapi::DirectoryEntry>& entries,
-      bool has_more) {
+  void DidReadDirectory(const std::vector<storage::DirectoryEntry>& entries,
+                        bool has_more) {
     directory_callback_.Run(entries, has_more);
   }
 
   void DidOpenFileSystem(const std::string& name,
                          const GURL& root) {
     filesystem_callback_.Run(name, root);
   }
 
-  void DidResolveURL(const fileapi::FileSystemInfo& info,
+  void DidResolveURL(const storage::FileSystemInfo& info,
                      const base::FilePath& file_path,
                      bool is_directory) {
     resolve_callback_.Run(info, file_path, is_directory);
   }
 
   void DidWrite(int64 bytes, bool complete) {
     write_callback_.Run(bytes, complete);
   }
 
  private:
@@ skipping 39 matching lines @@
                         OnDidCreateSnapshotFile)
     IPC_MESSAGE_HANDLER(FileSystemMsg_DidFail, OnDidFail)
     IPC_MESSAGE_HANDLER(FileSystemMsg_DidWrite, OnDidWrite)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void FileSystemDispatcher::OpenFileSystem(
     const GURL& origin_url,
-    fileapi::FileSystemType type,
+    storage::FileSystemType type,
     const OpenFileSystemCallback& success_callback,
     const StatusCallback& error_callback) {
   int request_id = dispatchers_.Add(
       CallbackDispatcher::Create(success_callback, error_callback));
   ChildThread::current()->Send(new FileSystemHostMsg_OpenFileSystem(
       request_id, origin_url, type));
 }
 
 void FileSystemDispatcher::ResolveURL(
     const GURL& filesystem_url,
     const ResolveURLCallback& success_callback,
     const StatusCallback& error_callback) {
   int request_id = dispatchers_.Add(
       CallbackDispatcher::Create(success_callback, error_callback));
   ChildThread::current()->Send(new FileSystemHostMsg_ResolveURL(
           request_id, filesystem_url));
 }
 
-void FileSystemDispatcher::DeleteFileSystem(
-    const GURL& origin_url,
-    fileapi::FileSystemType type,
-    const StatusCallback& callback) {
+void FileSystemDispatcher::DeleteFileSystem(const GURL& origin_url,
+                                            storage::FileSystemType type,
+                                            const StatusCallback& callback) {
   int request_id = dispatchers_.Add(CallbackDispatcher::Create(callback));
   ChildThread::current()->Send(new FileSystemHostMsg_DeleteFileSystem(
           request_id, origin_url, type));
 }
 
 void FileSystemDispatcher::Move(
     const GURL& src_path,
     const GURL& dest_path,
     const StatusCallback& callback) {
   int request_id = dispatchers_.Add(CallbackDispatcher::Create(callback));
@@ skipping 131 matching lines @@
                                                const std::string& name,
                                                const GURL& root) {
   DCHECK(root.is_valid());
   CallbackDispatcher* dispatcher = dispatchers_.Lookup(request_id);
   DCHECK(dispatcher);
   dispatcher->DidOpenFileSystem(name, root);
   dispatchers_.Remove(request_id);
 }
 
 void FileSystemDispatcher::OnDidResolveURL(int request_id,
-                                           const fileapi::FileSystemInfo& info,
+                                           const storage::FileSystemInfo& info,
                                            const base::FilePath& file_path,
                                            bool is_directory) {
   DCHECK(info.root_url.is_valid());
   CallbackDispatcher* dispatcher = dispatchers_.Lookup(request_id);
   DCHECK(dispatcher);
   dispatcher->DidResolveURL(info, file_path, is_directory);
   dispatchers_.Remove(request_id);
 }
 
 void FileSystemDispatcher::OnDidSucceed(int request_id) {
@@ skipping 15 matching lines @@
     int request_id, const base::File::Info& file_info,
     const base::FilePath& platform_path) {
   CallbackDispatcher* dispatcher = dispatchers_.Lookup(request_id);
   DCHECK(dispatcher);
   dispatcher->DidCreateSnapshotFile(file_info, platform_path, request_id);
   dispatchers_.Remove(request_id);
 }
 
 void FileSystemDispatcher::OnDidReadDirectory(
     int request_id,
-    const std::vector<fileapi::DirectoryEntry>& entries,
+    const std::vector<storage::DirectoryEntry>& entries,
     bool has_more) {
   CallbackDispatcher* dispatcher = dispatchers_.Lookup(request_id);
   DCHECK(dispatcher);
   dispatcher->DidReadDirectory(entries, has_more);
   if (!has_more)
     dispatchers_.Remove(request_id);
 }
 
 void FileSystemDispatcher::OnDidFail(
     int request_id, base::File::Error error_code) {
   CallbackDispatcher* dispatcher = dispatchers_.Lookup(request_id);
   DCHECK(dispatcher);
   dispatcher->DidFail(error_code);
   dispatchers_.Remove(request_id);
 }
 
 void FileSystemDispatcher::OnDidWrite(
     int request_id, int64 bytes, bool complete) {
   CallbackDispatcher* dispatcher = dispatchers_.Lookup(request_id);
   DCHECK(dispatcher);
   dispatcher->DidWrite(bytes, complete);
   if (complete)
     dispatchers_.Remove(request_id);
 }
 
 }  // namespace content