| OLD | NEW |
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef BASE_FILES_FILE_PROXY_H_ | |
| 6 #define BASE_FILES_FILE_PROXY_H_ | |
| 7 | |
| 8 #include "base/base_export.h" | |
| 9 #include "base/callback_forward.h" | |
| 10 #include "base/files/file.h" | |
| 11 #include "base/files/file_path.h" | |
| 12 #include "base/memory/ref_counted.h" | |
| 13 #include "base/memory/weak_ptr.h" | |
| 14 | |
| 15 namespace tracked_objects { | |
| 16 class Location; | |
| 17 }; | |
| 18 | |
| 19 namespace base { | |
| 20 | |
| 21 class TaskRunner; | |
| 22 class Time; | |
| 23 | |
| 24 // This class provides asynchronous access to a File. All methods follow the | |
| 25 // same rules of the equivalent File method, as they are implemented by bouncing | |
| 26 // the operation to File using a TaskRunner. | |
| 27 // | |
| 28 // This class performs automatic proxying to close the underlying file at | |
| 29 // destruction. | |
| 30 // | |
| 31 // The TaskRunner is in charge of any sequencing of the operations, but a single | |
| 32 // operation can be proxied at a time, regardless of the use of a callback. | |
| 33 // In other words, having a sequence like | |
| 34 // | |
| 35 // proxy.Write(...); | |
| 36 // proxy.Write(...); | |
| 37 // | |
| 38 // means the second Write will always fail. | |
| 39 class BASE_EXPORT FileProxy : public SupportsWeakPtr<FileProxy> { | |
| 40 public: | |
| 41 // This callback is used by methods that report only an error code. It is | |
| 42 // valid to pass a null callback to some functions that takes a | |
| 43 // StatusCallback, in which case the operation will complete silently. | |
| 44 typedef Callback<void(File::Error)> StatusCallback; | |
| 45 | |
| 46 typedef Callback<void(File::Error, | |
| 47 const FilePath&)> CreateTemporaryCallback; | |
| 48 typedef Callback<void(File::Error, | |
| 49 const File::Info&)> GetFileInfoCallback; | |
| 50 typedef Callback<void(File::Error, | |
| 51 const char* data, | |
| 52 int bytes_read)> ReadCallback; | |
| 53 typedef Callback<void(File::Error, | |
| 54 int bytes_written)> WriteCallback; | |
| 55 | |
| 56 FileProxy(); | |
| 57 explicit FileProxy(TaskRunner* task_runner); | |
| 58 ~FileProxy(); | |
| 59 | |
| 60 // Creates or opens a file with the given flags. It is invalid to pass a null | |
| 61 // callback. If File::FLAG_CREATE is set in |file_flags| it always tries to | |
| 62 // create a new file at the given |file_path| and fails if the file already | |
| 63 // exists. | |
| 64 // | |
| 65 // This returns false if task posting to |task_runner| has failed. | |
| 66 bool CreateOrOpen(const FilePath& file_path, | |
| 67 uint32 file_flags, | |
| 68 const StatusCallback& callback); | |
| 69 | |
| 70 // Creates a temporary file for writing. The path and an open file are | |
| 71 // returned. It is invalid to pass a null callback. The additional file flags | |
| 72 // will be added on top of the default file flags which are: | |
| 73 // File::FLAG_CREATE_ALWAYS | |
| 74 // File::FLAG_WRITE | |
| 75 // File::FLAG_TEMPORARY. | |
| 76 // | |
| 77 // This returns false if task posting to |task_runner| has failed. | |
| 78 bool CreateTemporary(uint32 additional_file_flags, | |
| 79 const CreateTemporaryCallback& callback); | |
| 80 | |
| 81 // Returns true if the underlying |file_| is valid. | |
| 82 bool IsValid() const; | |
| 83 | |
| 84 // Returns true if a new file was created (or an old one truncated to zero | |
| 85 // length to simulate a new file), and false otherwise. | |
| 86 bool created() const { return file_.created(); } | |
| 87 | |
| 88 // Claims ownership of |file|. It is an error to call this method when | |
| 89 // IsValid() returns true. | |
| 90 void SetFile(File file); | |
| 91 | |
| 92 File TakeFile(); | |
| 93 | |
| 94 PlatformFile GetPlatformFile() const; | |
| 95 | |
| 96 // Proxies File::Close. The callback can be null. | |
| 97 // This returns false if task posting to |task_runner| has failed. | |
| 98 bool Close(const StatusCallback& callback); | |
| 99 | |
| 100 // Proxies File::GetInfo. The callback can't be null. | |
| 101 // This returns false if task posting to |task_runner| has failed. | |
| 102 bool GetInfo(const GetFileInfoCallback& callback); | |
| 103 | |
| 104 // Proxies File::Read. The callback can't be null. | |
| 105 // This returns false if |bytes_to_read| is less than zero, or | |
| 106 // if task posting to |task_runner| has failed. | |
| 107 bool Read(int64 offset, int bytes_to_read, const ReadCallback& callback); | |
| 108 | |
| 109 // Proxies File::Write. The callback can be null. | |
| 110 // This returns false if |bytes_to_write| is less than or equal to zero, | |
| 111 // if |buffer| is NULL, or if task posting to |task_runner| has failed. | |
| 112 bool Write(int64 offset, | |
| 113 const char* buffer, | |
| 114 int bytes_to_write, | |
| 115 const WriteCallback& callback); | |
| 116 | |
| 117 // Proxies File::SetTimes. The callback can be null. | |
| 118 // This returns false if task posting to |task_runner| has failed. | |
| 119 bool SetTimes(Time last_access_time, | |
| 120 Time last_modified_time, | |
| 121 const StatusCallback& callback); | |
| 122 | |
| 123 // Proxies File::SetLength. The callback can be null. | |
| 124 // This returns false if task posting to |task_runner| has failed. | |
| 125 bool SetLength(int64 length, const StatusCallback& callback); | |
| 126 | |
| 127 // Proxies File::Flush. The callback can be null. | |
| 128 // This returns false if task posting to |task_runner| has failed. | |
| 129 bool Flush(const StatusCallback& callback); | |
| 130 | |
| 131 private: | |
| 132 friend class FileHelper; | |
| 133 TaskRunner* task_runner() { return task_runner_.get(); } | |
| 134 | |
| 135 scoped_refptr<TaskRunner> task_runner_; | |
| 136 File file_; | |
| 137 DISALLOW_COPY_AND_ASSIGN(FileProxy); | |
| 138 }; | |
| 139 | |
| 140 } // namespace base | |
| 141 | |
| 142 #endif // BASE_FILES_FILE_PROXY_H_ | |
| OLD | NEW |