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

storage/browser/fileapi/file_system_operation.h

 // 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.
 
 #ifndef WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_OPERATION_H_
 #define WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_OPERATION_H_
 
 #include <vector>
 
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/process/process.h"
-#include "webkit/browser/fileapi/file_system_operation_context.h"
-#include "webkit/browser/webkit_storage_browser_export.h"
-#include "webkit/common/fileapi/directory_entry.h"
+#include "storage/browser/fileapi/file_system_operation_context.h"
+#include "storage/common/storage_export.h"
+#include "storage/common/fileapi/directory_entry.h"
 
 namespace base {
 class Time;
 }
 
 namespace net {
 class URLRequest;
 }
 
-namespace webkit_blob {
+namespace storage {
 class ShareableFileReference;
 }
 
 class GURL;
 
-namespace fileapi {
+namespace storage {
 
 class FileSystemContext;
 class FileSystemURL;
 class FileWriterDelegate;
 
 // The interface class for FileSystemOperation implementations.
 //
 // This interface defines file system operations required to implement
 // "File API: Directories and System"
 // http://www.w3.org/TR/file-system-api/
 //
 // DESIGN NOTES
 //
 // This class is designed to
 //
 // 1) Serve one-time file system operation per instance.  Only one
 // method(CreateFile, CreateDirectory, Copy, Move, DirectoryExists,
 // GetMetadata, ReadDirectory and Remove) may be called during the
 // lifetime of this object and it should be called no more than once.
 //
 // 2) Deliver the results of operations to the client via the callback function
 // passed as the last parameter of the method.
 //
 // Note that it is valid to delete an operation while it is running.
 // The callback will NOT be fired if the operation is deleted before
 // it gets called.
 class FileSystemOperation {
  public:
-  WEBKIT_STORAGE_BROWSER_EXPORT static FileSystemOperation* Create(
+  STORAGE_EXPORT static FileSystemOperation* Create(
       const FileSystemURL& url,
       FileSystemContext* file_system_context,
       scoped_ptr<FileSystemOperationContext> operation_context);
 
   virtual ~FileSystemOperation() {}
 
   // Used for CreateFile(), etc. |result| is the return code of the operation.
   typedef base::Callback<void(base::File::Error result)> StatusCallback;
 
   // Used for GetMetadata(). |result| is the return code of the operation,
   // |file_info| is the obtained file info.
   typedef base::Callback<
-      void(base::File::Error result,
-           const base::File::Info& file_info)> GetMetadataCallback;
+      void(base::File::Error result, const base::File::Info& file_info)>
+      GetMetadataCallback;
 
   // Used for OpenFile(). |on_close_callback| will be called after the file is
   // closed in the child process. It can be null, if no operation is needed on
   // closing a file.
   typedef base::Callback<
-      void(base::File file,
-           const base::Closure& on_close_callback)> OpenFileCallback;
+      void(base::File file, const base::Closure& on_close_callback)>
+      OpenFileCallback;
 
   // Used for ReadDirectoryCallback.
   typedef std::vector<DirectoryEntry> FileEntryList;
 
   // Used for ReadDirectory(). |result| is the return code of the operation,
   // |file_list| is the list of files read, and |has_more| is true if some files
   // are yet to be read.
-  typedef base::Callback<
-      void(base::File::Error result,
-           const FileEntryList& file_list,
-           bool has_more)> ReadDirectoryCallback;
+  typedef base::Callback<void(base::File::Error result,
+                              const FileEntryList& file_list,
+                              bool has_more)> ReadDirectoryCallback;
 
   // Used for CreateSnapshotFile(). (Please see the comment at
   // CreateSnapshotFile() below for how the method is called)
   // |result| is the return code of the operation.
   // |file_info| is the metadata of the snapshot file created.
   // |platform_path| is the path to the snapshot file created.
   //
   // The snapshot file could simply be of the local file pointed by the given
   // filesystem URL in local filesystem cases; remote filesystems
   // may want to download the file into a temporary snapshot file and then
   // return the metadata of the temporary file.
   //
   // |file_ref| is used to manage the lifetime of the returned
   // snapshot file.  It can be set to let the chromium backend take
   // care of the life time of the snapshot file.  Otherwise (if the returned
   // file does not require any handling) the implementation can just
   // return NULL.  In a more complex case, the implementaiton can manage
   // the lifetime of the snapshot file on its own (e.g. by its cache system)
   // but also can be notified via the reference when the file becomes no
   // longer necessary in the javascript world.
   // Please see the comment for ShareableFileReference for details.
   //
   typedef base::Callback<
       void(base::File::Error result,
            const base::File::Info& file_info,
            const base::FilePath& platform_path,
-           const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref)>
-          SnapshotFileCallback;
+           const scoped_refptr<storage::ShareableFileReference>& file_ref)>
+      SnapshotFileCallback;
 
   // Used for progress update callback for Copy().
   //
   // BEGIN_COPY_ENTRY is fired for each copy creation beginning (for both
   // file and directory).
   // The |source_url| is the URL of the source entry. |size| should not be
   // used.
   //
   // END_COPY_ENTRY is fired for each copy creation finishing (for both
   // file and directory).
@@ skipping 58 matching lines @@
   // these operations should be done quickly (at least much faster than copying
   // usually).
   enum CopyProgressType {
     BEGIN_COPY_ENTRY,
     END_COPY_ENTRY,
     PROGRESS,
   };
   typedef base::Callback<void(CopyProgressType type,
                               const FileSystemURL& source_url,
                               const FileSystemURL& destination_url,
-                              int64 size)>
-      CopyProgressCallback;
+                              int64 size)> CopyProgressCallback;
 
   // Used for CopyFileLocal() to report progress update.
   // |size| is the cumulative copied bytes for the copy.
   // At the beginning the progress callback should be called with |size| = 0,
   // and also at the ending the progress callback should be called with |size|
   // set to the copied file size.
   typedef base::Callback<void(int64 size)> CopyFileProgressCallback;
 
   // The option for copy or move operation.
   enum CopyOrMoveOption {
     // No additional operation.
     OPTION_NONE,
 
     // Preserves last modified time if possible. If the operation to update
     // last modified time is not supported on the file system for the
     // destination file, this option would be simply ignored (i.e. Copy would
     // be successfully done without preserving last modified time).
     OPTION_PRESERVE_LAST_MODIFIED,
   };
 
   // Used for Write().
-  typedef base::Callback<void(base::File::Error result,
-                              int64 bytes,
-                              bool complete)> WriteCallback;
+  typedef base::Callback<
+      void(base::File::Error result, int64 bytes, bool complete)> WriteCallback;
 
   // Creates a file at |path|. If |exclusive| is true, an error is raised
   // in case a file is already present at the URL.
   virtual void CreateFile(const FileSystemURL& path,
                           bool exclusive,
                           const StatusCallback& callback) = 0;
 
   // Creates a directory at |path|. If |exclusive| is true, an error is
   // raised in case a directory is already present at the URL. If
   // |recursive| is true, create parent directories as needed just like
@@ skipping 56 matching lines @@
   // Gets the metadata of a file or directory at |path|.
   virtual void GetMetadata(const FileSystemURL& path,
                            const GetMetadataCallback& callback) = 0;
 
   // Reads contents of a directory at |path|.
   virtual void ReadDirectory(const FileSystemURL& path,
                              const ReadDirectoryCallback& callback) = 0;
 
   // Removes a file or directory at |path|. If |recursive| is true, remove
   // all files and directories under the directory at |path| recursively.
-  virtual void Remove(const FileSystemURL& path, bool recursive,
+  virtual void Remove(const FileSystemURL& path,
+                      bool recursive,
                       const StatusCallback& callback) = 0;
 
   // Writes the data read from |blob_request| using |writer_delegate|.
-  virtual void Write(
-    const FileSystemURL& url,
-    scoped_ptr<FileWriterDelegate> writer_delegate,
-    scoped_ptr<net::URLRequest> blob_request,
-    const WriteCallback& callback) = 0;
+  virtual void Write(const FileSystemURL& url,
+                     scoped_ptr<FileWriterDelegate> writer_delegate,
+                     scoped_ptr<net::URLRequest> blob_request,
+                     const WriteCallback& callback) = 0;
 
   // Truncates a file at |path| to |length|. If |length| is larger than
   // the original file size, the file will be extended, and the extended
   // part is filled with null bytes.
-  virtual void Truncate(const FileSystemURL& path, int64 length,
+  virtual void Truncate(const FileSystemURL& path,
+                        int64 length,
                         const StatusCallback& callback) = 0;
 
   // Tries to cancel the current operation [we support cancelling write or
   // truncate only]. Reports failure for the current operation, then reports
   // success for the cancel operation itself via the |cancel_dispatcher|.
   //
   // E.g. a typical cancel implementation would look like:
   //
   //   virtual void SomeOperationImpl::Cancel(
   //       const StatusCallback& cancel_callback) {
@@ skipping 147 matching lines @@
     kOperationWrite,
     kOperationTruncate,
     kOperationTouchFile,
     kOperationOpenFile,
     kOperationCloseFile,
     kOperationGetLocalPath,
     kOperationCancel,
   };
 };
 
-}  // namespace fileapi
+}  // namespace storage
 
 #endif  // WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_OPERATION_H_