Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(154)

Side by Side Diff: webkit/fileapi/file_system_operation.cc

Issue 3599011: Add truncate and cancel for FileWriter; write and tests will come in later CL... (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: '' Created 10 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2010 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 #include "webkit/fileapi/file_system_operation.h" 5 #include "webkit/fileapi/file_system_operation.h"
6 6
7 #include "base/time.h" 7 #include "base/time.h"
8 #include "googleurl/src/gurl.h" 8 #include "googleurl/src/gurl.h"
9 #include "webkit/fileapi/file_system_callback_dispatcher.h" 9 #include "webkit/fileapi/file_system_callback_dispatcher.h"
10 10
11 namespace fileapi { 11 namespace fileapi {
12 12
13 FileSystemOperation::FileSystemOperation( 13 FileSystemOperation::FileSystemOperation(
14 FileSystemCallbackDispatcher* dispatcher, 14 FileSystemCallbackDispatcher* dispatcher,
15 scoped_refptr<base::MessageLoopProxy> proxy) 15 scoped_refptr<base::MessageLoopProxy> proxy)
16 : proxy_(proxy), 16 : proxy_(proxy),
17 dispatcher_(dispatcher), 17 dispatcher_(dispatcher),
18 callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { 18 callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
19 cancel_operation_(NULL) {
19 DCHECK(dispatcher); 20 DCHECK(dispatcher);
20 #ifndef NDEBUG 21 #ifndef NDEBUG
21 operation_pending_ = false; 22 pending_operation_ = kOperationNone;
22 #endif 23 #endif
23 } 24 }
24 25
25 FileSystemOperation::~FileSystemOperation() { 26 FileSystemOperation::~FileSystemOperation() {
26 } 27 }
27 28
28 void FileSystemOperation::CreateFile(const FilePath& path, 29 void FileSystemOperation::CreateFile(const FilePath& path,
29 bool exclusive) { 30 bool exclusive) {
30 #ifndef NDEBUG 31 #ifndef NDEBUG
31 DCHECK(!operation_pending_); 32 DCHECK(kOperationNone == pending_operation_);
32 operation_pending_ = true; 33 pending_operation_ = kOperationCreateFile;
33 #endif 34 #endif
34 35
35 base::FileUtilProxy::CreateOrOpen( 36 base::FileUtilProxy::CreateOrOpen(
36 proxy_, path, base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ, 37 proxy_, path, base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ,
37 callback_factory_.NewCallback( 38 callback_factory_.NewCallback(
38 exclusive ? &FileSystemOperation::DidCreateFileExclusive 39 exclusive ? &FileSystemOperation::DidCreateFileExclusive
39 : &FileSystemOperation::DidCreateFileNonExclusive)); 40 : &FileSystemOperation::DidCreateFileNonExclusive));
40 } 41 }
41 42
42 void FileSystemOperation::CreateDirectory(const FilePath& path, 43 void FileSystemOperation::CreateDirectory(const FilePath& path,
43 bool exclusive, 44 bool exclusive,
44 bool recursive) { 45 bool recursive) {
45 #ifndef NDEBUG 46 #ifndef NDEBUG
46 DCHECK(!operation_pending_); 47 DCHECK(kOperationNone == pending_operation_);
47 operation_pending_ = true; 48 pending_operation_ = kOperationCreateDirectory;
48 #endif 49 #endif
49 50
50 base::FileUtilProxy::CreateDirectory( 51 base::FileUtilProxy::CreateDirectory(
51 proxy_, path, exclusive, recursive, callback_factory_.NewCallback( 52 proxy_, path, exclusive, recursive, callback_factory_.NewCallback(
52 &FileSystemOperation::DidFinishFileOperation)); 53 &FileSystemOperation::DidFinishFileOperation));
53 } 54 }
54 55
55 void FileSystemOperation::Copy(const FilePath& src_path, 56 void FileSystemOperation::Copy(const FilePath& src_path,
56 const FilePath& dest_path) { 57 const FilePath& dest_path) {
57 #ifndef NDEBUG 58 #ifndef NDEBUG
58 DCHECK(!operation_pending_); 59 DCHECK(kOperationNone == pending_operation_);
59 operation_pending_ = true; 60 pending_operation_ = kOperationCopy;
60 #endif 61 #endif
61 62
62 base::FileUtilProxy::Copy(proxy_, src_path, dest_path, 63 base::FileUtilProxy::Copy(proxy_, src_path, dest_path,
63 callback_factory_.NewCallback( 64 callback_factory_.NewCallback(
64 &FileSystemOperation::DidFinishFileOperation)); 65 &FileSystemOperation::DidFinishFileOperation));
65 } 66 }
66 67
67 void FileSystemOperation::Move(const FilePath& src_path, 68 void FileSystemOperation::Move(const FilePath& src_path,
68 const FilePath& dest_path) { 69 const FilePath& dest_path) {
69 #ifndef NDEBUG 70 #ifndef NDEBUG
70 DCHECK(!operation_pending_); 71 DCHECK(kOperationNone == pending_operation_);
71 operation_pending_ = true; 72 pending_operation_ = kOperationMove;
72 #endif 73 #endif
73 74
74 base::FileUtilProxy::Move(proxy_, src_path, dest_path, 75 base::FileUtilProxy::Move(proxy_, src_path, dest_path,
75 callback_factory_.NewCallback( 76 callback_factory_.NewCallback(
76 &FileSystemOperation::DidFinishFileOperation)); 77 &FileSystemOperation::DidFinishFileOperation));
77 } 78 }
78 79
79 void FileSystemOperation::DirectoryExists(const FilePath& path) { 80 void FileSystemOperation::DirectoryExists(const FilePath& path) {
80 #ifndef NDEBUG 81 #ifndef NDEBUG
81 DCHECK(!operation_pending_); 82 DCHECK(kOperationNone == pending_operation_);
82 operation_pending_ = true; 83 pending_operation_ = kOperationDirectoryExists;
83 #endif 84 #endif
84 85
85 base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback( 86 base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback(
86 &FileSystemOperation::DidDirectoryExists)); 87 &FileSystemOperation::DidDirectoryExists));
87 } 88 }
88 89
89 void FileSystemOperation::FileExists(const FilePath& path) { 90 void FileSystemOperation::FileExists(const FilePath& path) {
90 #ifndef NDEBUG 91 #ifndef NDEBUG
91 DCHECK(!operation_pending_); 92 DCHECK(kOperationNone == pending_operation_);
92 operation_pending_ = true; 93 pending_operation_ = kOperationFileExists;
93 #endif 94 #endif
94 95
95 base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback( 96 base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback(
96 &FileSystemOperation::DidFileExists)); 97 &FileSystemOperation::DidFileExists));
97 } 98 }
98 99
99 void FileSystemOperation::GetMetadata(const FilePath& path) { 100 void FileSystemOperation::GetMetadata(const FilePath& path) {
100 #ifndef NDEBUG 101 #ifndef NDEBUG
101 DCHECK(!operation_pending_); 102 DCHECK(kOperationNone == pending_operation_);
102 operation_pending_ = true; 103 pending_operation_ = kOperationGetMetadata;
103 #endif 104 #endif
104 105
105 base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback( 106 base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback(
106 &FileSystemOperation::DidGetMetadata)); 107 &FileSystemOperation::DidGetMetadata));
107 } 108 }
108 109
109 void FileSystemOperation::ReadDirectory(const FilePath& path) { 110 void FileSystemOperation::ReadDirectory(const FilePath& path) {
110 #ifndef NDEBUG 111 #ifndef NDEBUG
111 DCHECK(!operation_pending_); 112 DCHECK(kOperationNone == pending_operation_);
112 operation_pending_ = true; 113 pending_operation_ = kOperationReadDirectory;
113 #endif 114 #endif
114 115
115 base::FileUtilProxy::ReadDirectory(proxy_, path, 116 base::FileUtilProxy::ReadDirectory(proxy_, path,
116 callback_factory_.NewCallback( 117 callback_factory_.NewCallback(
117 &FileSystemOperation::DidReadDirectory)); 118 &FileSystemOperation::DidReadDirectory));
118 } 119 }
119 120
120 void FileSystemOperation::Remove(const FilePath& path) { 121 void FileSystemOperation::Remove(const FilePath& path) {
121 #ifndef NDEBUG 122 #ifndef NDEBUG
122 DCHECK(!operation_pending_); 123 DCHECK(kOperationNone == pending_operation_);
123 operation_pending_ = true; 124 pending_operation_ = kOperationRemove;
124 #endif 125 #endif
125 126
126 base::FileUtilProxy::Delete(proxy_, path, callback_factory_.NewCallback( 127 base::FileUtilProxy::Delete(proxy_, path, callback_factory_.NewCallback(
127 &FileSystemOperation::DidFinishFileOperation)); 128 &FileSystemOperation::DidFinishFileOperation));
128 } 129 }
129 130
130 void FileSystemOperation::Write( 131 void FileSystemOperation::Write(
131 const FilePath&, 132 const FilePath& path,
132 const GURL&, 133 const GURL& blob_url,
133 int64) { 134 int64 offset) {
134 #ifndef NDEBUG 135 #ifndef NDEBUG
135 DCHECK(!operation_pending_); 136 DCHECK(kOperationNone == pending_operation_);
136 operation_pending_ = true; 137 pending_operation_ = kOperationWrite;
137 #endif 138 #endif
138 NOTREACHED(); 139 NOTREACHED();
139 // TODO(ericu):
140 // Set up a loop that, via multiple callback invocations, reads from a
141 // URLRequest wrapping blob_url, writes the bytes to the file, reports
142 // progress events no more frequently than some set rate, and periodically
143 // checks to see if it's been cancelled.
144 } 140 }
145 141
146 void FileSystemOperation::Truncate(const FilePath& path, int64 length) { 142 void FileSystemOperation::Truncate(const FilePath& path, int64 length) {
147 #ifndef NDEBUG 143 #ifndef NDEBUG
148 DCHECK(!operation_pending_); 144 DCHECK(kOperationNone == pending_operation_);
149 operation_pending_ = true; 145 pending_operation_ = kOperationTruncate;
150 #endif 146 #endif
151 // TODO(ericu): 147 base::FileUtilProxy::Truncate(proxy_, path, length,
152 NOTREACHED(); 148 callback_factory_.NewCallback(
149 &FileSystemOperation::DidFinishFileOperation));
153 } 150 }
154 151
155 void FileSystemOperation::TouchFile(const FilePath& path, 152 void FileSystemOperation::TouchFile(const FilePath& path,
156 const base::Time& last_access_time, 153 const base::Time& last_access_time,
157 const base::Time& last_modified_time) { 154 const base::Time& last_modified_time) {
158 #ifndef NDEBUG 155 #ifndef NDEBUG
159 DCHECK(!operation_pending_); 156 DCHECK(kOperationNone == pending_operation_);
160 operation_pending_ = true; 157 pending_operation_ = kOperationTouchFile;
161 #endif 158 #endif
162 159
163 base::FileUtilProxy::Touch( 160 base::FileUtilProxy::Touch(
164 proxy_, path, last_access_time, last_modified_time, 161 proxy_, path, last_access_time, last_modified_time,
165 callback_factory_.NewCallback(&FileSystemOperation::DidTouchFile)); 162 callback_factory_.NewCallback(&FileSystemOperation::DidTouchFile));
166 } 163 }
167 164
168 void FileSystemOperation::Cancel() { 165 // We can only get here on a write or truncate that's not yet completed.
166 // We don't support cancelling any other operation at this time.
167 void FileSystemOperation::Cancel(FileSystemOperation* cancel_operation) {
169 #ifndef NDEBUG 168 #ifndef NDEBUG
170 DCHECK(operation_pending_); 169 DCHECK(kOperationTruncate == pending_operation_);
170 // FIXME(ericu): Cancelling for writes coming soon.
171 #endif 171 #endif
172 NOTREACHED(); 172 // We're cancelling a truncate operation, but we can't actually stop it
173 // TODO(ericu): 173 // since it's been proxied to another thread. We need to save the
174 // Make sure this was done on a FileSystemOperation used for a Write. 174 // cancel_operation so that when the truncate returns, it can see that it's
175 // Then set a flag that ensures that the Write loop will exit without 175 // been cancelled, report it, and report that the cancel has succeeded.
176 // reporting any more progress, with a failure notification. 176 cancel_operation_ = cancel_operation;
177 } 177 }
178 178
179 void FileSystemOperation::DidCreateFileExclusive( 179 void FileSystemOperation::DidCreateFileExclusive(
180 base::PlatformFileError rv, 180 base::PlatformFileError rv,
181 base::PassPlatformFile file, 181 base::PassPlatformFile file,
182 bool created) { 182 bool created) {
183 DidFinishFileOperation(rv); 183 DidFinishFileOperation(rv);
184 } 184 }
185 185
186 void FileSystemOperation::DidCreateFileNonExclusive( 186 void FileSystemOperation::DidCreateFileNonExclusive(
187 base::PlatformFileError rv, 187 base::PlatformFileError rv,
188 base::PassPlatformFile file, 188 base::PassPlatformFile file,
189 bool created) { 189 bool created) {
190 // Suppress the already exists error and report success. 190 // Suppress the already exists error and report success.
191 if (rv == base::PLATFORM_FILE_OK || 191 if (rv == base::PLATFORM_FILE_OK ||
192 rv == base::PLATFORM_FILE_ERROR_EXISTS) 192 rv == base::PLATFORM_FILE_ERROR_EXISTS)
193 dispatcher_->DidSucceed(); 193 dispatcher_->DidSucceed();
194 else 194 else
195 dispatcher_->DidFail(rv); 195 dispatcher_->DidFail(rv);
196 } 196 }
197 197
198 void FileSystemOperation::DidFinishFileOperation( 198 void FileSystemOperation::DidFinishFileOperation(
199 base::PlatformFileError rv) { 199 base::PlatformFileError rv) {
200 if (rv == base::PLATFORM_FILE_OK) 200 if (cancel_operation_) {
201 #ifndef NDEBUG
202 DCHECK(kOperationTruncate == pending_operation_);
203 #endif
204 FileSystemOperation *cancel_op = cancel_operation_;
205 // This call deletes us, so we have to extract cancel_op first.
206 dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
207 cancel_op->dispatcher_->DidSucceed();
208 } else if (rv == base::PLATFORM_FILE_OK) {
201 dispatcher_->DidSucceed(); 209 dispatcher_->DidSucceed();
202 else 210 } else {
203 dispatcher_->DidFail(rv); 211 dispatcher_->DidFail(rv);
212 }
204 } 213 }
205 214
206 void FileSystemOperation::DidDirectoryExists( 215 void FileSystemOperation::DidDirectoryExists(
207 base::PlatformFileError rv, 216 base::PlatformFileError rv,
208 const base::PlatformFileInfo& file_info) { 217 const base::PlatformFileInfo& file_info) {
209 if (rv == base::PLATFORM_FILE_OK) { 218 if (rv == base::PLATFORM_FILE_OK) {
210 if (file_info.is_directory) 219 if (file_info.is_directory)
211 dispatcher_->DidSucceed(); 220 dispatcher_->DidSucceed();
212 else 221 else
213 dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_FAILED); 222 dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_FAILED);
(...skipping 29 matching lines...) Expand all
243 dispatcher_->DidReadDirectory(entries, false /* has_more */); 252 dispatcher_->DidReadDirectory(entries, false /* has_more */);
244 else 253 else
245 dispatcher_->DidFail(rv); 254 dispatcher_->DidFail(rv);
246 } 255 }
247 256
248 void FileSystemOperation::DidWrite( 257 void FileSystemOperation::DidWrite(
249 base::PlatformFileError rv, 258 base::PlatformFileError rv,
250 int64 bytes, 259 int64 bytes,
251 bool complete) { 260 bool complete) {
252 if (rv == base::PLATFORM_FILE_OK) 261 if (rv == base::PLATFORM_FILE_OK)
253 /* dispatcher_->DidWrite(bytes, complete) TODO(ericu): Coming soon. */ {} 262 dispatcher_->DidWrite(bytes, complete);
254 else 263 else
255 dispatcher_->DidFail(rv); 264 dispatcher_->DidFail(rv);
256 } 265 }
257 266
258 void FileSystemOperation::DidTouchFile(base::PlatformFileError rv) { 267 void FileSystemOperation::DidTouchFile(base::PlatformFileError rv) {
259 if (rv == base::PLATFORM_FILE_OK) 268 if (rv == base::PLATFORM_FILE_OK)
260 dispatcher_->DidSucceed(); 269 dispatcher_->DidSucceed();
261 else 270 else
262 dispatcher_->DidFail(rv); 271 dispatcher_->DidFail(rv);
263 } 272 }
264 273
265 } // namespace fileapi 274 } // namespace fileapi
OLDNEW
« no previous file with comments | « webkit/fileapi/file_system_operation.h ('k') | webkit/fileapi/file_system_operation_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698