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

Side by Side Diff: net/base/file_stream_posix.cc

Issue 10701050: net: Implement canceling of all async operations in FileStream. (Closed) Base URL: https://src.chromium.org/chrome/trunk/src/
Patch Set: Created 8 years, 3 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
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 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 // For 64-bit file access (off_t = off64_t, lseek64, etc). 5 // For 64-bit file access (off_t = off64_t, lseek64, etc).
6 #define _FILE_OFFSET_BITS 64 6 #define _FILE_OFFSET_BITS 64
7 7
8 #include "net/base/file_stream.h" 8 #include "net/base/file_stream_posix.h"
9 9
10 #include <sys/types.h> 10 #include <sys/types.h>
11 #include <sys/stat.h> 11 #include <sys/stat.h>
12 #include <fcntl.h> 12 #include <fcntl.h>
13 #include <unistd.h> 13 #include <unistd.h>
14 #include <errno.h> 14 #include <errno.h>
15 15
16 #include "base/basictypes.h" 16 #include "base/basictypes.h"
17 #include "base/bind.h" 17 #include "base/bind.h"
18 #include "base/bind_helpers.h" 18 #include "base/bind_helpers.h"
19 #include "base/callback.h" 19 #include "base/callback.h"
20 #include "base/eintr_wrapper.h" 20 #include "base/eintr_wrapper.h"
21 #include "base/file_path.h" 21 #include "base/file_path.h"
22 #include "base/location.h"
22 #include "base/logging.h" 23 #include "base/logging.h"
23 #include "base/message_loop.h"
24 #include "base/metrics/histogram.h" 24 #include "base/metrics/histogram.h"
25 #include "base/string_util.h" 25 #include "base/task_runner_util.h"
26 #include "base/threading/thread_restrictions.h"
27 #include "base/threading/worker_pool.h" 26 #include "base/threading/worker_pool.h"
28 #include "base/synchronization/waitable_event.h"
29 #include "net/base/file_stream_metrics.h"
30 #include "net/base/file_stream_net_log_parameters.h"
31 #include "net/base/io_buffer.h" 27 #include "net/base/io_buffer.h"
32 #include "net/base/net_errors.h" 28 #include "net/base/net_errors.h"
33 29
34 #if defined(OS_ANDROID) 30 #if defined(OS_ANDROID)
35 // Android's bionic libc only supports the LFS transitional API. 31 // Android's bionic libc only supports the LFS transitional API.
36 #define off_t off64_t 32 #define off_t off64_t
37 #define lseek lseek64 33 #define lseek lseek64
38 #define stat stat64 34 #define stat stat64
39 #define fstat fstat64 35 #define fstat fstat64
40 #endif 36 #endif
41 37
42 namespace net { 38 namespace net {
43 39
44 // We cast back and forth, so make sure it's the size we're expecting. 40 // We cast back and forth, so make sure it's the size we're expecting.
45 COMPILE_ASSERT(sizeof(int64) == sizeof(off_t), off_t_64_bit); 41 COMPILE_ASSERT(sizeof(int64) == sizeof(off_t), off_t_64_bit);
46 42
47 // Make sure our Whence mappings match the system headers. 43 // Make sure our Whence mappings match the system headers.
48 COMPILE_ASSERT(FROM_BEGIN == SEEK_SET && 44 COMPILE_ASSERT(FROM_BEGIN == SEEK_SET &&
49 FROM_CURRENT == SEEK_CUR && 45 FROM_CURRENT == SEEK_CUR &&
50 FROM_END == SEEK_END, whence_matches_system); 46 FROM_END == SEEK_END, whence_matches_system);
51 47
52 namespace { 48 FileStream::Context::Context(const BoundNetLog& bound_net_log)
53 49 : file_(base::kInvalidPlatformFileValue),
54 int RecordAndMapError(int error, 50 record_uma_(false),
55 FileErrorSource source, 51 async_in_progress_(false),
56 bool record_uma, 52 orphaned_(false),
57 const net::BoundNetLog& bound_net_log) { 53 bound_net_log_(bound_net_log) {
58 net::Error net_error = MapSystemError(error);
59
60 bound_net_log.AddEvent(
61 net::NetLog::TYPE_FILE_STREAM_ERROR,
62 base::Bind(&NetLogFileStreamErrorCallback,
63 source, error, net_error));
64
65 RecordFileError(error, source, record_uma);
66
67 return net_error;
68 } 54 }
69 55
70 // Opens a file with some network logging. 56 FileStream::Context::Context(base::PlatformFile file,
71 // The opened file and the result code are written to |file| and |result|. 57 const BoundNetLog& bound_net_log,
72 void OpenFile(const FilePath& path, 58 int /* open_flags */)
73 int open_flags, 59 : file_(file),
74 bool record_uma, 60 record_uma_(false),
75 base::PlatformFile* file, 61 async_in_progress_(false),
76 int* result, 62 orphaned_(false),
77 const net::BoundNetLog& bound_net_log) { 63 bound_net_log_(bound_net_log) {
78 std::string file_name = path.AsUTF8Unsafe();
79 bound_net_log.BeginEvent(
80 net::NetLog::TYPE_FILE_STREAM_OPEN,
81 NetLog::StringCallback("file_name", &file_name));
82
83 *result = OK;
84 *file = base::CreatePlatformFile(path, open_flags, NULL, NULL);
85 if (*file == base::kInvalidPlatformFileValue) {
86 bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
87 *result = RecordAndMapError(errno, FILE_ERROR_SOURCE_OPEN, record_uma,
88 bound_net_log);
89 }
90 } 64 }
91 65
92 // Opens a file using OpenFile() and then signals the completion. 66 FileStream::Context::~Context() {
93 void OpenFileAndSignal(const FilePath& path,
94 int open_flags,
95 bool record_uma,
96 base::PlatformFile* file,
97 int* result,
98 base::WaitableEvent* on_io_complete,
99 const net::BoundNetLog& bound_net_log) {
100 OpenFile(path, open_flags, record_uma, file, result, bound_net_log);
101 on_io_complete->Signal();
102 } 67 }
103 68
104 // Closes a file with some network logging. 69 int64 FileStream::Context::GetFileSize() const {
105 void CloseFile(base::PlatformFile file, 70 struct stat info;
106 const net::BoundNetLog& bound_net_log) { 71 if (fstat(file_, &info) != 0)
107 bound_net_log.AddEvent(net::NetLog::TYPE_FILE_STREAM_CLOSE); 72 return RecordAndMapError(errno, FILE_ERROR_SOURCE_GET_SIZE);
108 if (file == base::kInvalidPlatformFileValue)
109 return;
110 73
111 if (!base::ClosePlatformFile(file)) 74 return static_cast<int64>(info.st_size);
112 NOTREACHED();
113 bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
114 } 75 }
115 76
116 // Closes a file with CloseFile() and signals the completion. 77 int FileStream::Context::ReadAsync(IOBuffer* in_buf,
117 void CloseFileAndSignal(base::PlatformFile* file, 78 int buf_len,
118 base::WaitableEvent* on_io_complete, 79 const CompletionCallback& callback) {
119 const net::BoundNetLog& bound_net_log) { 80 DCHECK(!async_in_progress_);
120 CloseFile(*file, bound_net_log); 81
121 *file = base::kInvalidPlatformFileValue; 82 scoped_refptr<IOBuffer> buf = in_buf;
122 on_io_complete->Signal(); 83 const bool posted = base::PostTaskAndReplyWithResult(
84 base::WorkerPool::GetTaskRunner(true /* task is slow */),
85 FROM_HERE,
86 base::Bind(&Context::ReadFileImpl,
87 base::Unretained(this), buf, buf_len),
88 base::Bind(&Context::ProcessAsyncResult,
89 base::Unretained(this), IntToInt64(callback),
90 FILE_ERROR_SOURCE_READ));
91 DCHECK(posted);
92
93 async_in_progress_ = true;
94 return ERR_IO_PENDING;
123 } 95 }
124 96
125 // Adjusts the position from where the data is read. 97 int FileStream::Context::ReadSync(char* in_buf, int buf_len) {
126 void SeekFile(base::PlatformFile file, 98 scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(in_buf);
127 Whence whence, 99 int64 result = ReadFileImpl(buf, buf_len);
128 int64 offset, 100 CheckForIOError(&result, FILE_ERROR_SOURCE_READ);
129 int64* result, 101 return result;
130 bool record_uma,
131 const net::BoundNetLog& bound_net_log) {
132 off_t res = lseek(file, static_cast<off_t>(offset),
133 static_cast<int>(whence));
134 if (res == static_cast<off_t>(-1)) {
135 *result = RecordAndMapError(errno,
136 FILE_ERROR_SOURCE_SEEK,
137 record_uma,
138 bound_net_log);
139 return;
140 }
141 *result = res;
142 } 102 }
143 103
144 // Seeks a file by calling SeekSync() and signals the completion. 104 int FileStream::Context::WriteAsync(IOBuffer* in_buf,
145 void SeekFileAndSignal(base::PlatformFile file, 105 int buf_len,
146 Whence whence, 106 const CompletionCallback& callback) {
147 int64 offset, 107 DCHECK(!async_in_progress_);
148 int64* result, 108
149 bool record_uma, 109 scoped_refptr<IOBuffer> buf = in_buf;
150 base::WaitableEvent* on_io_complete, 110 const bool posted = base::PostTaskAndReplyWithResult(
151 const net::BoundNetLog& bound_net_log) { 111 base::WorkerPool::GetTaskRunner(true /* task is slow */),
152 SeekFile(file, whence, offset, result, record_uma, bound_net_log); 112 FROM_HERE,
153 on_io_complete->Signal(); 113 base::Bind(&Context::WriteFileImpl,
114 base::Unretained(this), buf, buf_len),
115 base::Bind(&Context::ProcessAsyncResult,
116 base::Unretained(this), IntToInt64(callback),
117 FILE_ERROR_SOURCE_WRITE));
118 DCHECK(posted);
119
120 async_in_progress_ = true;
121 return ERR_IO_PENDING;
154 } 122 }
155 123
156 // ReadFile() is a simple wrapper around read() that handles EINTR signals and 124 int FileStream::Context::WriteSync(const char* in_buf, int buf_len) {
157 // calls MapSystemError() to map errno to net error codes. 125 scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(in_buf);
158 void ReadFile(base::PlatformFile file, 126 int64 result = WriteFileImpl(buf, buf_len);
159 char* buf, 127 CheckForIOError(&result, FILE_ERROR_SOURCE_WRITE);
160 int buf_len, 128 return result;
161 bool record_uma,
162 int* result,
163 const net::BoundNetLog& bound_net_log) {
164 base::ThreadRestrictions::AssertIOAllowed();
165 // read(..., 0) returns 0 to indicate end-of-file.
166
167 // Loop in the case of getting interrupted by a signal.
168 ssize_t res = HANDLE_EINTR(read(file, buf, static_cast<size_t>(buf_len)));
169 if (res == -1) {
170 res = RecordAndMapError(errno, FILE_ERROR_SOURCE_READ,
171 record_uma, bound_net_log);
172 }
173 *result = res;
174 } 129 }
175 130
176 // Reads a file using ReadFile() and signals the completion. 131 int FileStream::Context::Flush() {
177 void ReadFileAndSignal(base::PlatformFile file, 132 ssize_t res = HANDLE_EINTR(fsync(file_));
178 scoped_refptr<IOBuffer> buf, 133 if (res == -1)
179 int buf_len, 134 res = RecordAndMapError(errno, FILE_ERROR_SOURCE_FLUSH);
180 bool record_uma,
181 int* result,
182 base::WaitableEvent* on_io_complete,
183 const net::BoundNetLog& bound_net_log) {
184 ReadFile(file, buf->data(), buf_len, record_uma, result, bound_net_log);
185 on_io_complete->Signal();
186 }
187
188 // WriteFile() is a simple wrapper around write() that handles EINTR signals and
189 // calls MapSystemError() to map errno to net error codes. It tries to write to
190 // completion.
191 void WriteFile(base::PlatformFile file,
192 const char* buf,
193 int buf_len,
194 bool record_uma,
195 int* result,
196 const net::BoundNetLog& bound_net_log) {
197 base::ThreadRestrictions::AssertIOAllowed();
198
199 ssize_t res = HANDLE_EINTR(write(file, buf, buf_len));
200 if (res == -1) {
201 res = RecordAndMapError(errno, FILE_ERROR_SOURCE_WRITE, record_uma,
202 bound_net_log);
203 }
204 *result = res;
205 }
206
207 // Writes a file using WriteFile() and signals the completion.
208 void WriteFileAndSignal(base::PlatformFile file,
209 scoped_refptr<IOBuffer> buf,
210 int buf_len,
211 bool record_uma,
212 int* result,
213 base::WaitableEvent* on_io_complete,
214 const net::BoundNetLog& bound_net_log) {
215 WriteFile(file, buf->data(), buf_len, record_uma, result, bound_net_log);
216 on_io_complete->Signal();
217 }
218
219 // FlushFile() is a simple wrapper around fsync() that handles EINTR signals and
220 // calls MapSystemError() to map errno to net error codes. It tries to flush to
221 // completion.
222 int FlushFile(base::PlatformFile file,
223 bool record_uma,
224 const net::BoundNetLog& bound_net_log) {
225 base::ThreadRestrictions::AssertIOAllowed();
226 ssize_t res = HANDLE_EINTR(fsync(file));
227 if (res == -1) {
228 res = RecordAndMapError(errno, FILE_ERROR_SOURCE_FLUSH, record_uma,
229 bound_net_log);
230 }
231 return res; 135 return res;
232 } 136 }
233 137
234 // Called when Read(), Write() or Seek() is completed. 138 int FileStream::Context::Truncate(int64 bytes) {
235 // |result| contains the result or a network error code. 139 int result = ftruncate(file_, bytes);
236 template <typename R> 140 if (result == 0)
237 void OnIOComplete(const base::WeakPtr<FileStreamPosix>& stream, 141 return bytes;
238 const base::Callback<void(R)>& callback,
239 R* result) {
240 if (!stream.get())
241 return;
242 142
243 // Reset this before Run() as Run() may issue a new async operation. 143 return RecordAndMapError(errno, FILE_ERROR_SOURCE_SET_EOF);
244 stream->ResetOnIOComplete();
245 callback.Run(*result);
246 } 144 }
247 145
248 } // namespace 146 int64 FileStream::Context::SeekFileImpl(Whence whence, int64 offset) {
147 off_t res = lseek(file_, static_cast<off_t>(offset),
148 static_cast<int>(whence));
149 if (res == static_cast<off_t>(-1))
150 return errno;
249 151
250 // FileStreamPosix ------------------------------------------------------------ 152 return res;
251
252 FileStreamPosix::FileStreamPosix(net::NetLog* net_log)
253 : file_(base::kInvalidPlatformFileValue),
254 open_flags_(0),
255 auto_closed_(true),
256 record_uma_(false),
257 bound_net_log_(net::BoundNetLog::Make(net_log,
258 net::NetLog::SOURCE_FILESTREAM)),
259 weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
260 bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
261 } 153 }
262 154
263 FileStreamPosix::FileStreamPosix( 155 int64 FileStream::Context::ReadFileImpl(scoped_refptr<IOBuffer> buf,
264 base::PlatformFile file, int flags, net::NetLog* net_log) 156 int buf_len) {
265 : file_(file), 157 // Loop in the case of getting interrupted by a signal.
266 open_flags_(flags), 158 ssize_t res = HANDLE_EINTR(read(file_, buf->data(),
267 auto_closed_(false), 159 static_cast<size_t>(buf_len)));
268 record_uma_(false), 160 if (res == -1)
269 bound_net_log_(net::BoundNetLog::Make(net_log, 161 return errno;
270 net::NetLog::SOURCE_FILESTREAM)), 162
271 weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { 163 return res;
272 bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
273 } 164 }
274 165
275 FileStreamPosix::~FileStreamPosix() { 166 int64 FileStream::Context::WriteFileImpl(scoped_refptr<IOBuffer> buf,
276 if (open_flags_ & base::PLATFORM_FILE_ASYNC) { 167 int buf_len) {
277 // Block until the last open/close/read/write operation is complete. 168 ssize_t res = HANDLE_EINTR(write(file_, buf->data(), buf_len));
278 // TODO(satorux): Ideally we should not block. crbug.com/115067 169 if (res == -1)
279 WaitForIOCompletion(); 170 return errno;
280 }
281 171
282 if (auto_closed_) { 172 return res;
283 if (open_flags_ & base::PLATFORM_FILE_ASYNC) {
284 // Close the file in the background.
285 if (IsOpen()) {
286 const bool posted = base::WorkerPool::PostTask(
287 FROM_HERE,
288 base::Bind(&CloseFile, file_, bound_net_log_),
289 true /* task_is_slow */);
290 DCHECK(posted);
291 }
292 } else {
293 CloseSync();
294 }
295 }
296
297 bound_net_log_.EndEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
298 }
299
300 void FileStreamPosix::Close(const CompletionCallback& callback) {
301 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
302
303 DCHECK(!weak_ptr_factory_.HasWeakPtrs());
304 DCHECK(!on_io_complete_.get());
305 on_io_complete_.reset(new base::WaitableEvent(
306 false /* manual_reset */, false /* initially_signaled */));
307
308 // Passing &file_ to a thread pool looks unsafe but it's safe here as the
309 // destructor ensures that the close operation is complete with
310 // WaitForIOCompletion(). See also the destructor.
311 const bool posted = base::WorkerPool::PostTaskAndReply(
312 FROM_HERE,
313 base::Bind(&CloseFileAndSignal, &file_, on_io_complete_.get(),
314 bound_net_log_),
315 base::Bind(&FileStreamPosix::OnClosed,
316 weak_ptr_factory_.GetWeakPtr(),
317 callback),
318 true /* task_is_slow */);
319
320 DCHECK(posted);
321 }
322
323 void FileStreamPosix::CloseSync() {
324 // TODO(satorux): Replace the following async stuff with a
325 // DCHECK(open_flags & ASYNC) once once all async clients are migrated to
326 // use Close(). crbug.com/114783
327
328 // Abort any existing asynchronous operations.
329 weak_ptr_factory_.InvalidateWeakPtrs();
330 // Block until the last open/read/write operation is complete.
331 // TODO(satorux): Ideally we should not block. crbug.com/115067
332 WaitForIOCompletion();
333
334 CloseFile(file_, bound_net_log_);
335 file_ = base::kInvalidPlatformFileValue;
336 }
337
338 int FileStreamPosix::Open(const FilePath& path, int open_flags,
339 const CompletionCallback& callback) {
340 if (IsOpen()) {
341 DLOG(FATAL) << "File is already open!";
342 return ERR_UNEXPECTED;
343 }
344
345 open_flags_ = open_flags;
346 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
347
348 DCHECK(!weak_ptr_factory_.HasWeakPtrs());
349 DCHECK(!on_io_complete_.get());
350 on_io_complete_.reset(new base::WaitableEvent(
351 false /* manual_reset */, false /* initially_signaled */));
352
353 // Passing &file_ to a thread pool looks unsafe but it's safe here as the
354 // destructor ensures that the open operation is complete with
355 // WaitForIOCompletion(). See also the destructor.
356 int* result = new int(OK);
357 const bool posted = base::WorkerPool::PostTaskAndReply(
358 FROM_HERE,
359 base::Bind(&OpenFileAndSignal,
360 path, open_flags, record_uma_, &file_, result,
361 on_io_complete_.get(), bound_net_log_),
362 base::Bind(&OnIOComplete<int>, weak_ptr_factory_.GetWeakPtr(),
363 callback, base::Owned(result)),
364 true /* task_is_slow */);
365 DCHECK(posted);
366 return ERR_IO_PENDING;
367 }
368
369 int FileStreamPosix::OpenSync(const FilePath& path, int open_flags) {
370 if (IsOpen()) {
371 DLOG(FATAL) << "File is already open!";
372 return ERR_UNEXPECTED;
373 }
374
375 open_flags_ = open_flags;
376 // TODO(satorux): Put a DCHECK once once all async clients are migrated
377 // to use Open(). crbug.com/114783
378 //
379 // DCHECK(!(open_flags_ & base::PLATFORM_FILE_ASYNC));
380
381 int result = OK;
382 OpenFile(path, open_flags_, record_uma_, &file_, &result, bound_net_log_);
383 return result;
384 }
385
386 bool FileStreamPosix::IsOpen() const {
387 return file_ != base::kInvalidPlatformFileValue;
388 }
389
390 int FileStreamPosix::Seek(Whence whence, int64 offset,
391 const Int64CompletionCallback& callback) {
392 if (!IsOpen())
393 return ERR_UNEXPECTED;
394
395 // Make sure we're async and we have no other in-flight async operations.
396 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
397 DCHECK(!weak_ptr_factory_.HasWeakPtrs());
398 DCHECK(!on_io_complete_.get());
399
400 on_io_complete_.reset(new base::WaitableEvent(
401 false /* manual_reset */, false /* initially_signaled */));
402
403 int64* result = new int64(-1);
404 const bool posted = base::WorkerPool::PostTaskAndReply(
405 FROM_HERE,
406 base::Bind(&SeekFileAndSignal, file_, whence, offset, result,
407 record_uma_, on_io_complete_.get(), bound_net_log_),
408 base::Bind(&OnIOComplete<int64>,
409 weak_ptr_factory_.GetWeakPtr(),
410 callback, base::Owned(result)),
411 true /* task is slow */);
412 DCHECK(posted);
413 return ERR_IO_PENDING;
414 }
415
416 int64 FileStreamPosix::SeekSync(Whence whence, int64 offset) {
417 base::ThreadRestrictions::AssertIOAllowed();
418
419 if (!IsOpen())
420 return ERR_UNEXPECTED;
421
422 // If we're in async, make sure we don't have a request in flight.
423 DCHECK(!(open_flags_ & base::PLATFORM_FILE_ASYNC) ||
424 !on_io_complete_.get());
425
426 off_t result = -1;
427 SeekFile(file_, whence, offset, &result, record_uma_, bound_net_log_);
428 return result;
429 }
430
431 int64 FileStreamPosix::Available() {
432 base::ThreadRestrictions::AssertIOAllowed();
433
434 if (!IsOpen())
435 return ERR_UNEXPECTED;
436
437 int64 cur_pos = SeekSync(FROM_CURRENT, 0);
438 if (cur_pos < 0)
439 return cur_pos;
440
441 struct stat info;
442 if (fstat(file_, &info) != 0) {
443 return RecordAndMapError(errno,
444 FILE_ERROR_SOURCE_GET_SIZE,
445 record_uma_,
446 bound_net_log_);
447 }
448
449 int64 size = static_cast<int64>(info.st_size);
450 DCHECK_GT(size, cur_pos);
451
452 return size - cur_pos;
453 }
454
455 int FileStreamPosix::Read(
456 IOBuffer* in_buf, int buf_len, const CompletionCallback& callback) {
457 if (!IsOpen())
458 return ERR_UNEXPECTED;
459
460 // read(..., 0) will return 0, which indicates end-of-file.
461 DCHECK_GT(buf_len, 0);
462 DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
463 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
464
465 // Make sure we don't have a request in flight.
466 DCHECK(!weak_ptr_factory_.HasWeakPtrs());
467 DCHECK(!on_io_complete_.get());
468
469 on_io_complete_.reset(new base::WaitableEvent(
470 false /* manual_reset */, false /* initially_signaled */));
471
472 int* result = new int(OK);
473 scoped_refptr<IOBuffer> buf = in_buf;
474 const bool posted = base::WorkerPool::PostTaskAndReply(
475 FROM_HERE,
476 base::Bind(&ReadFileAndSignal, file_, buf, buf_len,
477 record_uma_, result, on_io_complete_.get(), bound_net_log_),
478 base::Bind(&OnIOComplete<int>,
479 weak_ptr_factory_.GetWeakPtr(),
480 callback, base::Owned(result)),
481 true /* task is slow */);
482 DCHECK(posted);
483 return ERR_IO_PENDING;
484 }
485
486 int FileStreamPosix::ReadSync(char* buf, int buf_len) {
487 if (!IsOpen())
488 return ERR_UNEXPECTED;
489
490 DCHECK(!(open_flags_ & base::PLATFORM_FILE_ASYNC));
491 // read(..., 0) will return 0, which indicates end-of-file.
492 DCHECK_GT(buf_len, 0);
493 DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
494
495 int result = OK;
496 ReadFile(file_, buf, buf_len, record_uma_, &result, bound_net_log_);
497 return result;
498 }
499
500 int FileStreamPosix::ReadUntilComplete(char *buf, int buf_len) {
501 int to_read = buf_len;
502 int bytes_total = 0;
503
504 do {
505 int bytes_read = ReadSync(buf, to_read);
506 if (bytes_read <= 0) {
507 if (bytes_total == 0)
508 return bytes_read;
509
510 return bytes_total;
511 }
512
513 bytes_total += bytes_read;
514 buf += bytes_read;
515 to_read -= bytes_read;
516 } while (bytes_total < buf_len);
517
518 return bytes_total;
519 }
520
521 int FileStreamPosix::Write(
522 IOBuffer* in_buf, int buf_len, const CompletionCallback& callback) {
523 if (!IsOpen())
524 return ERR_UNEXPECTED;
525
526 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
527 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
528 // write(..., 0) will return 0, which indicates end-of-file.
529 DCHECK_GT(buf_len, 0);
530
531 // Make sure we don't have a request in flight.
532 DCHECK(!weak_ptr_factory_.HasWeakPtrs());
533 DCHECK(!on_io_complete_.get());
534 on_io_complete_.reset(new base::WaitableEvent(
535 false /* manual_reset */, false /* initially_signaled */));
536
537 int* result = new int(OK);
538 scoped_refptr<IOBuffer> buf = in_buf;
539 const bool posted = base::WorkerPool::PostTaskAndReply(
540 FROM_HERE,
541 base::Bind(&WriteFileAndSignal, file_, buf, buf_len,
542 record_uma_, result, on_io_complete_.get(), bound_net_log_),
543 base::Bind(&OnIOComplete<int>,
544 weak_ptr_factory_.GetWeakPtr(),
545 callback, base::Owned(result)),
546 true /* task is slow */);
547 DCHECK(posted);
548 return ERR_IO_PENDING;
549 }
550
551 int FileStreamPosix::WriteSync(
552 const char* buf, int buf_len) {
553 if (!IsOpen())
554 return ERR_UNEXPECTED;
555
556 DCHECK(!(open_flags_ & base::PLATFORM_FILE_ASYNC));
557 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
558 // write(..., 0) will return 0, which indicates end-of-file.
559 DCHECK_GT(buf_len, 0);
560
561 int result = OK;
562 WriteFile(file_, buf, buf_len, record_uma_, &result, bound_net_log_);
563 return result;
564 }
565
566 int64 FileStreamPosix::Truncate(int64 bytes) {
567 base::ThreadRestrictions::AssertIOAllowed();
568
569 if (!IsOpen())
570 return ERR_UNEXPECTED;
571
572 // We'd better be open for writing.
573 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
574
575 // Seek to the position to truncate from.
576 int64 seek_position = SeekSync(FROM_BEGIN, bytes);
577 if (seek_position != bytes)
578 return ERR_UNEXPECTED;
579
580 // And truncate the file.
581 int result = ftruncate(file_, bytes);
582 if (result == 0)
583 return seek_position;
584
585 return RecordAndMapError(errno,
586 FILE_ERROR_SOURCE_SET_EOF,
587 record_uma_,
588 bound_net_log_);
589 }
590
591 int FileStreamPosix::Flush() {
592 if (!IsOpen())
593 return ERR_UNEXPECTED;
594
595 return FlushFile(file_, record_uma_, bound_net_log_);
596 }
597
598 void FileStreamPosix::EnableErrorStatistics() {
599 record_uma_ = true;
600 }
601
602 void FileStreamPosix::SetBoundNetLogSource(
603 const net::BoundNetLog& owner_bound_net_log) {
604 if ((owner_bound_net_log.source().id == net::NetLog::Source::kInvalidId) &&
605 (bound_net_log_.source().id == net::NetLog::Source::kInvalidId)) {
606 // Both |BoundNetLog|s are invalid.
607 return;
608 }
609
610 // Should never connect to itself.
611 DCHECK_NE(bound_net_log_.source().id, owner_bound_net_log.source().id);
612
613 bound_net_log_.AddEvent(
614 net::NetLog::TYPE_FILE_STREAM_BOUND_TO_OWNER,
615 owner_bound_net_log.source().ToEventParametersCallback());
616
617 owner_bound_net_log.AddEvent(
618 net::NetLog::TYPE_FILE_STREAM_SOURCE,
619 bound_net_log_.source().ToEventParametersCallback());
620 }
621
622 base::PlatformFile FileStreamPosix::GetPlatformFileForTesting() {
623 return file_;
624 }
625
626 void FileStreamPosix::ResetOnIOComplete() {
627 on_io_complete_.reset();
628 weak_ptr_factory_.InvalidateWeakPtrs();
629 }
630
631 void FileStreamPosix::OnClosed(const CompletionCallback& callback) {
632 file_ = base::kInvalidPlatformFileValue;
633
634 // Reset this before Run() as Run() may issue a new async operation.
635 ResetOnIOComplete();
636 callback.Run(OK);
637 }
638
639 void FileStreamPosix::WaitForIOCompletion() {
640 // http://crbug.com/115067
641 base::ThreadRestrictions::ScopedAllowWait allow_wait;
642 if (on_io_complete_.get()) {
643 on_io_complete_->Wait();
644 on_io_complete_.reset();
645 }
646 } 173 }
647 174
648 } // namespace net 175 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698