| OLD | NEW |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 #ifndef WEBKIT_BROWSER_FILEAPI_ASYNC_FILE_UTIL_H_ | 5 #include "storage/browser/fileapi/async_file_util.h" |
| 6 #define WEBKIT_BROWSER_FILEAPI_ASYNC_FILE_UTIL_H_ | |
| 7 | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/basictypes.h" | |
| 11 #include "base/callback_forward.h" | |
| 12 #include "base/files/file.h" | |
| 13 #include "base/files/file_util_proxy.h" | |
| 14 #include "base/memory/scoped_ptr.h" | |
| 15 #include "webkit/browser/fileapi/file_system_operation.h" | |
| 16 #include "webkit/browser/storage_browser_export.h" | |
| 17 #include "webkit/common/fileapi/directory_entry.h" | |
| 18 | |
| 19 namespace base { | |
| 20 class Time; | |
| 21 } | |
| 22 | |
| 23 namespace storage { | |
| 24 class ShareableFileReference; | |
| 25 } | |
| 26 | |
| 27 namespace storage { | |
| 28 | |
| 29 class FileSystemOperationContext; | |
| 30 class FileSystemURL; | |
| 31 | |
| 32 // An interface which provides filesystem-specific file operations for | |
| 33 // FileSystemOperationImpl. | |
| 34 // | |
| 35 // Each filesystem which needs to be dispatched from FileSystemOperationImpl | |
| 36 // must implement this interface or a synchronous version of interface: | |
| 37 // FileSystemFileUtil. | |
| 38 // | |
| 39 // As far as an instance of this class is owned by a FileSystemBackend | |
| 40 // (which is owned by FileSystemContext), it's guaranteed that this instance's | |
| 41 // alive while FileSystemOperationContext given to each operation is kept | |
| 42 // alive. (Note that this instance might be freed on different thread | |
| 43 // from the thread it is created.) | |
| 44 // | |
| 45 // It is NOT valid to give null callback to this class, and implementors | |
| 46 // can assume that they don't get any null callbacks. | |
| 47 // | |
| 48 class AsyncFileUtil { | |
| 49 public: | |
| 50 typedef base::Callback<void(base::File::Error result)> StatusCallback; | |
| 51 | |
| 52 // |on_close_callback| will be called after the |file| is closed in the | |
| 53 // child process. |on_close_callback|.is_null() can be true, if no operation | |
| 54 // is needed on closing the file. | |
| 55 typedef base::Callback< | |
| 56 void(base::File file, | |
| 57 const base::Closure& on_close_callback)> CreateOrOpenCallback; | |
| 58 | |
| 59 typedef base::Callback< | |
| 60 void(base::File::Error result, | |
| 61 bool created)> EnsureFileExistsCallback; | |
| 62 | |
| 63 typedef base::Callback< | |
| 64 void(base::File::Error result, | |
| 65 const base::File::Info& file_info)> GetFileInfoCallback; | |
| 66 | |
| 67 typedef std::vector<DirectoryEntry> EntryList; | |
| 68 typedef base::Callback< | |
| 69 void(base::File::Error result, | |
| 70 const EntryList& file_list, | |
| 71 bool has_more)> ReadDirectoryCallback; | |
| 72 | |
| 73 typedef base::Callback< | |
| 74 void(base::File::Error result, | |
| 75 const base::File::Info& file_info, | |
| 76 const base::FilePath& platform_path, | |
| 77 const scoped_refptr<storage::ShareableFileReference>& file_ref)> | |
| 78 CreateSnapshotFileCallback; | |
| 79 | |
| 80 typedef base::Callback<void(int64 size)> CopyFileProgressCallback; | |
| 81 | |
| 82 typedef FileSystemOperation::CopyOrMoveOption CopyOrMoveOption; | |
| 83 | |
| 84 // Creates an AsyncFileUtil instance which performs file operations on | |
| 85 // local native file system. The created instance assumes | |
| 86 // FileSystemURL::path() has the target platform path. | |
| 87 STORAGE_EXPORT static AsyncFileUtil* | |
| 88 CreateForLocalFileSystem(); | |
| 89 | |
| 90 AsyncFileUtil() {} | |
| 91 virtual ~AsyncFileUtil() {} | |
| 92 | |
| 93 // Creates or opens a file with the given flags. | |
| 94 // If File::FLAG_CREATE is set in |file_flags| it always tries to create | |
| 95 // a new file at the given |url| and calls back with | |
| 96 // File::FILE_ERROR_FILE_EXISTS if the |url| already exists. | |
| 97 // | |
| 98 // FileSystemOperationImpl::OpenFile calls this. | |
| 99 // This is used only by Pepper/NaCl File API. | |
| 100 // | |
| 101 virtual void CreateOrOpen( | |
| 102 scoped_ptr<FileSystemOperationContext> context, | |
| 103 const FileSystemURL& url, | |
| 104 int file_flags, | |
| 105 const CreateOrOpenCallback& callback) = 0; | |
| 106 | |
| 107 // Ensures that the given |url| exist. This creates a empty new file | |
| 108 // at |url| if the |url| does not exist. | |
| 109 // | |
| 110 // FileSystemOperationImpl::CreateFile calls this. | |
| 111 // | |
| 112 // This reports following error code via |callback|: | |
| 113 // - File::FILE_OK and created==true if a file has not existed and | |
| 114 // is created at |url|. | |
| 115 // - File::FILE_OK and created==false if the file already exists. | |
| 116 // - Other error code (with created=false) if a file hasn't existed yet | |
| 117 // and there was an error while creating a new file. | |
| 118 // | |
| 119 virtual void EnsureFileExists( | |
| 120 scoped_ptr<FileSystemOperationContext> context, | |
| 121 const FileSystemURL& url, | |
| 122 const EnsureFileExistsCallback& callback) = 0; | |
| 123 | |
| 124 // Creates directory at given url. | |
| 125 // | |
| 126 // FileSystemOperationImpl::CreateDirectory calls this. | |
| 127 // | |
| 128 // This reports following error code via |callback|: | |
| 129 // - File::FILE_ERROR_NOT_FOUND if the |url|'s parent directory | |
| 130 // does not exist and |recursive| is false. | |
| 131 // - File::FILE_ERROR_EXISTS if a directory already exists at |url| | |
| 132 // and |exclusive| is true. | |
| 133 // - File::FILE_ERROR_EXISTS if a file already exists at |url| | |
| 134 // (regardless of |exclusive| value). | |
| 135 // - Other error code if it failed to create a directory. | |
| 136 // | |
| 137 virtual void CreateDirectory( | |
| 138 scoped_ptr<FileSystemOperationContext> context, | |
| 139 const FileSystemURL& url, | |
| 140 bool exclusive, | |
| 141 bool recursive, | |
| 142 const StatusCallback& callback) = 0; | |
| 143 | |
| 144 // Retrieves the information about a file. | |
| 145 // | |
| 146 // FileSystemOperationImpl::GetMetadata calls this. | |
| 147 // | |
| 148 // This reports following error code via |callback|: | |
| 149 // - File::FILE_ERROR_NOT_FOUND if the file doesn't exist. | |
| 150 // - Other error code if there was an error while retrieving the file info. | |
| 151 // | |
| 152 virtual void GetFileInfo( | |
| 153 scoped_ptr<FileSystemOperationContext> context, | |
| 154 const FileSystemURL& url, | |
| 155 const GetFileInfoCallback& callback) = 0; | |
| 156 | |
| 157 // Reads contents of a directory at |path|. | |
| 158 // | |
| 159 // FileSystemOperationImpl::ReadDirectory calls this. | |
| 160 // | |
| 161 // Note that the |name| field of each entry in |file_list| | |
| 162 // returned by |callback| should have a base file name | |
| 163 // of the entry relative to the directory, but not an absolute path. | |
| 164 // | |
| 165 // (E.g. if ReadDirectory is called for a directory | |
| 166 // 'path/to/dir' and the directory has entries 'a' and 'b', | |
| 167 // the returned |file_list| should include entries whose names | |
| 168 // are 'a' and 'b', but not '/path/to/dir/a' and '/path/to/dir/b'.) | |
| 169 // | |
| 170 // This reports following error code via |callback|: | |
| 171 // - File::FILE_ERROR_NOT_FOUND if the target directory doesn't exist. | |
| 172 // - File::FILE_ERROR_NOT_A_DIRECTORY if an entry exists at |url| but | |
| 173 // is a file (not a directory). | |
| 174 // | |
| 175 virtual void ReadDirectory( | |
| 176 scoped_ptr<FileSystemOperationContext> context, | |
| 177 const FileSystemURL& url, | |
| 178 const ReadDirectoryCallback& callback) = 0; | |
| 179 | |
| 180 // Modifies timestamps of a file or directory at |url| with | |
| 181 // |last_access_time| and |last_modified_time|. The function DOES NOT | |
| 182 // create a file unlike 'touch' command on Linux. | |
| 183 // | |
| 184 // FileSystemOperationImpl::TouchFile calls this. | |
| 185 // This is used only by Pepper/NaCl File API. | |
| 186 // | |
| 187 virtual void Touch( | |
| 188 scoped_ptr<FileSystemOperationContext> context, | |
| 189 const FileSystemURL& url, | |
| 190 const base::Time& last_access_time, | |
| 191 const base::Time& last_modified_time, | |
| 192 const StatusCallback& callback) = 0; | |
| 193 | |
| 194 // Truncates a file at |path| to |length|. If |length| is larger than | |
| 195 // the original file size, the file will be extended, and the extended | |
| 196 // part is filled with null bytes. | |
| 197 // | |
| 198 // FileSystemOperationImpl::Truncate calls this. | |
| 199 // | |
| 200 // This reports following error code via |callback|: | |
| 201 // - File::FILE_ERROR_NOT_FOUND if the file doesn't exist. | |
| 202 // | |
| 203 virtual void Truncate( | |
| 204 scoped_ptr<FileSystemOperationContext> context, | |
| 205 const FileSystemURL& url, | |
| 206 int64 length, | |
| 207 const StatusCallback& callback) = 0; | |
| 208 | |
| 209 // Copies a file from |src_url| to |dest_url|. | |
| 210 // This must be called for files that belong to the same filesystem | |
| 211 // (i.e. type() and origin() of the |src_url| and |dest_url| must match). | |
| 212 // |progress_callback| is a callback to report the progress update. | |
| 213 // See file_system_operations.h for details. This should be called on the | |
| 214 // same thread as where the method's called (IO thread). Calling this | |
| 215 // is optional. It is recommended to use this callback for heavier operations | |
| 216 // (such as file network downloading), so that, e.g., clients (UIs) can | |
| 217 // update its state to show progress to users. This may be a null callback. | |
| 218 // | |
| 219 // FileSystemOperationImpl::Copy calls this for same-filesystem copy case. | |
| 220 // | |
| 221 // This reports following error code via |callback|: | |
| 222 // - File::FILE_ERROR_NOT_FOUND if |src_url| | |
| 223 // or the parent directory of |dest_url| does not exist. | |
| 224 // - File::FILE_ERROR_NOT_A_FILE if |src_url| exists but is not a file. | |
| 225 // - File::FILE_ERROR_INVALID_OPERATION if |dest_url| exists and | |
| 226 // is not a file. | |
| 227 // - File::FILE_ERROR_FAILED if |dest_url| does not exist and | |
| 228 // its parent path is a file. | |
| 229 // | |
| 230 virtual void CopyFileLocal( | |
| 231 scoped_ptr<FileSystemOperationContext> context, | |
| 232 const FileSystemURL& src_url, | |
| 233 const FileSystemURL& dest_url, | |
| 234 CopyOrMoveOption option, | |
| 235 const CopyFileProgressCallback& progress_callback, | |
| 236 const StatusCallback& callback) = 0; | |
| 237 | |
| 238 // Moves a local file from |src_url| to |dest_url|. | |
| 239 // This must be called for files that belong to the same filesystem | |
| 240 // (i.e. type() and origin() of the |src_url| and |dest_url| must match). | |
| 241 // | |
| 242 // FileSystemOperationImpl::Move calls this for same-filesystem move case. | |
| 243 // | |
| 244 // This reports following error code via |callback|: | |
| 245 // - File::FILE_ERROR_NOT_FOUND if |src_url| | |
| 246 // or the parent directory of |dest_url| does not exist. | |
| 247 // - File::FILE_ERROR_NOT_A_FILE if |src_url| exists but is not a file. | |
| 248 // - File::FILE_ERROR_INVALID_OPERATION if |dest_url| exists and | |
| 249 // is not a file. | |
| 250 // - File::FILE_ERROR_FAILED if |dest_url| does not exist and | |
| 251 // its parent path is a file. | |
| 252 // | |
| 253 virtual void MoveFileLocal( | |
| 254 scoped_ptr<FileSystemOperationContext> context, | |
| 255 const FileSystemURL& src_url, | |
| 256 const FileSystemURL& dest_url, | |
| 257 CopyOrMoveOption option, | |
| 258 const StatusCallback& callback) = 0; | |
| 259 | |
| 260 // Copies in a single file from a different filesystem. | |
| 261 // | |
| 262 // FileSystemOperationImpl::Copy or Move calls this for cross-filesystem | |
| 263 // cases. | |
| 264 // | |
| 265 // This reports following error code via |callback|: | |
| 266 // - File::FILE_ERROR_NOT_FOUND if |src_file_path| | |
| 267 // or the parent directory of |dest_url| does not exist. | |
| 268 // - File::FILE_ERROR_INVALID_OPERATION if |dest_url| exists and | |
| 269 // is not a file. | |
| 270 // - File::FILE_ERROR_FAILED if |dest_url| does not exist and | |
| 271 // its parent path is a file. | |
| 272 // | |
| 273 virtual void CopyInForeignFile( | |
| 274 scoped_ptr<FileSystemOperationContext> context, | |
| 275 const base::FilePath& src_file_path, | |
| 276 const FileSystemURL& dest_url, | |
| 277 const StatusCallback& callback) = 0; | |
| 278 | |
| 279 // Deletes a single file. | |
| 280 // | |
| 281 // FileSystemOperationImpl::RemoveFile calls this. | |
| 282 // | |
| 283 // This reports following error code via |callback|: | |
| 284 // - File::FILE_ERROR_NOT_FOUND if |url| does not exist. | |
| 285 // - File::FILE_ERROR_NOT_A_FILE if |url| is not a file. | |
| 286 // | |
| 287 virtual void DeleteFile( | |
| 288 scoped_ptr<FileSystemOperationContext> context, | |
| 289 const FileSystemURL& url, | |
| 290 const StatusCallback& callback) = 0; | |
| 291 | |
| 292 // Removes a single empty directory. | |
| 293 // | |
| 294 // FileSystemOperationImpl::RemoveDirectory calls this. | |
| 295 // | |
| 296 // This reports following error code via |callback|: | |
| 297 // - File::FILE_ERROR_NOT_FOUND if |url| does not exist. | |
| 298 // - File::FILE_ERROR_NOT_A_DIRECTORY if |url| is not a directory. | |
| 299 // - File::FILE_ERROR_NOT_EMPTY if |url| is not empty. | |
| 300 // | |
| 301 virtual void DeleteDirectory( | |
| 302 scoped_ptr<FileSystemOperationContext> context, | |
| 303 const FileSystemURL& url, | |
| 304 const StatusCallback& callback) = 0; | |
| 305 | |
| 306 // Removes a single file or a single directory with its contents | |
| 307 // (i.e. files/subdirectories under the directory). | |
| 308 // | |
| 309 // FileSystemOperationImpl::Remove calls this. | |
| 310 // On some platforms, such as Chrome OS Drive File System, recursive file | |
| 311 // deletion can be implemented more efficiently than calling DeleteFile() and | |
| 312 // DeleteDirectory() for each files/directories. | |
| 313 // This method is optional, so if not supported, | |
| 314 // File::FILE_ERROR_INVALID_OPERATION should be returned via |callback|. | |
| 315 // | |
| 316 // This reports following error code via |callback|: | |
| 317 // - File::FILE_ERROR_NOT_FOUND if |url| does not exist. | |
| 318 // - File::FILE_ERROR_INVALID_OPERATION if this operation is not supported. | |
| 319 virtual void DeleteRecursively( | |
| 320 scoped_ptr<FileSystemOperationContext> context, | |
| 321 const FileSystemURL& url, | |
| 322 const StatusCallback& callback) = 0; | |
| 323 | |
| 324 // Creates a local snapshot file for a given |url| and returns the | |
| 325 // metadata and platform path of the snapshot file via |callback|. | |
| 326 // In regular filesystem cases the implementation may simply return | |
| 327 // the metadata of the file itself (as well as GetMetadata does), | |
| 328 // while in non-regular filesystem case the backend may create a | |
| 329 // temporary snapshot file which holds the file data and return | |
| 330 // the metadata of the temporary file. | |
| 331 // | |
| 332 // In the callback, it returns: | |
| 333 // |file_info| is the metadata of the snapshot file created. | |
| 334 // |platform_path| is the full absolute platform path to the snapshot | |
| 335 // file created. If a file is not backed by a real local file in | |
| 336 // the implementor's FileSystem, the implementor must create a | |
| 337 // local snapshot file and return the path of the created file. | |
| 338 // | |
| 339 // If implementors creates a temporary file for snapshotting and wants | |
| 340 // FileAPI backend to take care of the lifetime of the file (so that | |
| 341 // it won't get deleted while JS layer has any references to the created | |
| 342 // File/Blob object), it should return non-empty |file_ref|. | |
| 343 // Via the |file_ref| implementors can schedule a file deletion | |
| 344 // or arbitrary callbacks when the last reference of File/Blob is dropped. | |
| 345 // | |
| 346 // FileSystemOperationImpl::CreateSnapshotFile calls this. | |
| 347 // | |
| 348 // This reports following error code via |callback|: | |
| 349 // - File::FILE_ERROR_NOT_FOUND if |url| does not exist. | |
| 350 // - File::FILE_ERROR_NOT_A_FILE if |url| exists but is a directory. | |
| 351 // | |
| 352 // The field values of |file_info| are undefined (implementation | |
| 353 // dependent) in error cases, and the caller should always | |
| 354 // check the return code. | |
| 355 virtual void CreateSnapshotFile( | |
| 356 scoped_ptr<FileSystemOperationContext> context, | |
| 357 const FileSystemURL& url, | |
| 358 const CreateSnapshotFileCallback& callback) = 0; | |
| 359 | |
| 360 private: | |
| 361 DISALLOW_COPY_AND_ASSIGN(AsyncFileUtil); | |
| 362 }; | |
| 363 | |
| 364 } // namespace storage | |
| 365 | |
| 366 #endif // WEBKIT_BROWSER_FILEAPI_ASYNC_FILE_UTIL_H_ | |
| OLD | NEW |