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

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, 5 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.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/logging.h" 22 #include "base/logging.h"
23 #include "base/memory/ref_counted.h"
23 #include "base/message_loop.h" 24 #include "base/message_loop.h"
24 #include "base/metrics/histogram.h" 25 #include "base/metrics/histogram.h"
25 #include "base/string_util.h" 26 #include "base/string_util.h"
26 #include "base/threading/thread_restrictions.h" 27 #include "base/threading/thread_restrictions.h"
27 #include "base/threading/worker_pool.h" 28 #include "base/threading/worker_pool.h"
28 #include "base/synchronization/waitable_event.h"
29 #include "net/base/file_stream_metrics.h" 29 #include "net/base/file_stream_metrics.h"
30 #include "net/base/file_stream_net_log_parameters.h" 30 #include "net/base/file_stream_net_log_parameters.h"
31 #include "net/base/io_buffer.h" 31 #include "net/base/io_buffer.h"
32 #include "net/base/net_errors.h" 32 #include "net/base/net_errors.h"
33 33
34 #if defined(OS_ANDROID) 34 #if defined(OS_ANDROID)
35 // Android's bionic libc only supports the LFS transitional API. 35 // Android's bionic libc only supports the LFS transitional API.
36 #define off_t off64_t 36 #define off_t off64_t
37 #define lseek lseek64 37 #define lseek lseek64
38 #define stat stat64 38 #define stat stat64
39 #define fstat fstat64 39 #define fstat fstat64
40 #endif 40 #endif
41 41
42 namespace net { 42 namespace net {
43 43
44 // We cast back and forth, so make sure it's the size we're expecting. 44 // 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); 45 COMPILE_ASSERT(sizeof(int64) == sizeof(off_t), off_t_64_bit);
46 46
47 // Make sure our Whence mappings match the system headers. 47 // Make sure our Whence mappings match the system headers.
48 COMPILE_ASSERT(FROM_BEGIN == SEEK_SET && 48 COMPILE_ASSERT(FROM_BEGIN == SEEK_SET &&
49 FROM_CURRENT == SEEK_CUR && 49 FROM_CURRENT == SEEK_CUR &&
50 FROM_END == SEEK_END, whence_matches_system); 50 FROM_END == SEEK_END, whence_matches_system);
51 51
52 namespace { 52
wtc 2012/07/13 23:40:21 Nit: delete a blank line.
53 53 class FileStreamPosix::AsyncContext {
54 int RecordAndMapError(int error, 54 public:
55 FileErrorSource source, 55 explicit AsyncContext(const BoundNetLog& bound_net_log);
56 bool record_uma, 56 AsyncContext(base::PlatformFile file, const BoundNetLog& bound_net_log);
57 const net::BoundNetLog& bound_net_log) { 57
58 net::Error net_error = MapSystemError(error); 58 // Destroys the context. It can be deleted in the method or deletion can be
59 59 // deferred to WorkerPool if some asynchronous operation is now in progress
60 bound_net_log.AddEvent( 60 // or if auto-closing is needed.
61 net::NetLog::TYPE_FILE_STREAM_ERROR, 61 void Destroy();
62 base::Bind(&NetLogFileStreamErrorCallback, 62
63 source, error, net_error)); 63 bool record_uma() { return record_uma_; }
64 64 void set_record_uma(bool value) { record_uma_ = value; }
65 RecordFileError(error, source, record_uma); 65 base::PlatformFile file() { return file_; }
66 66 bool auto_closed() { return auto_closed_; }
67 void set_auto_closed(bool value) { auto_closed_ = value; }
68 bool async_in_progress() { return async_in_progress_; }
69
70 int RecordAndMapError(int error, FileErrorSource source);
71
72 // Sync and async versions of all operations
73 void OpenAsync(const FilePath& path,
74 int open_flags,
75 const CompletionCallback& callback);
76 int OpenSync(const FilePath& path, int open_flags);
77
78 void CloseAsync(const CompletionCallback& callback);
79 void CloseSync();
80
81 void SeekAsync(Whence whence,
82 int64 offset,
83 const Int64CompletionCallback& callback);
84 int64 SeekSync(Whence whence, int64 offset);
85
86 void ReadAsync(IOBuffer* buf,
87 int buf_len,
88 const CompletionCallback& callback);
89 int ReadSync(char* buf, int buf_len);
90
91 void WriteAsync(IOBuffer* in_buf,
92 int buf_len,
93 const CompletionCallback& callback);
94 int WriteSync(const char* in_buf, int buf_len);
95
96 private:
97 // Map system error into network error code and log it with |bound_net_log_|.
98 // Method should be called with |net_log_lock_| locked.
99 int MapAndLogError(int error, FileErrorSource source);
100
101 // Opens a file with some network logging.
102 // The result code is written to |result|.
103 void OpenFileImpl(const FilePath& path, int open_flags, int* result);
104
105 // Closes a file with some network logging.
106 void CloseFileImpl();
107
108 // Adjusts the position from where the data is read.
109 void SeekFileImpl(Whence whence, int64 offset, int64* result);
110
111 // ReadFile() is a simple wrapper around read() that handles EINTR signals
112 // and calls RecordAndMapError() to map errno to net error codes.
113 void ReadFileImpl(scoped_refptr<IOBuffer> buf, int buf_len, int* result);
114
115 // WriteFile() is a simple wrapper around write() that handles EINTR signals
116 // and calls MapSystemError() to map errno to net error codes. It tries
117 // to write to completion.
118 void WriteFileImpl(scoped_refptr<IOBuffer> buf, int buf_len, int* result);
119
120 // Called when asynchronous Close(), Open(), Read(), Write() or Seek()
121 // is completed. |result| contains the result or a network error code.
122 template <typename R>
123 void OnAsyncCompleted(const base::Callback<void(R)>& callback, R* result);
wtc 2012/07/13 23:40:21 Since OnAsyncCompleted is only instantianted with
pivanof 2012/07/14 00:13:58 No, this can't be done because value of result is
124
125 // Delete the context with asynchronous closing if necessary.
126 void DeleteAbandoned();
127
128 base::PlatformFile file_;
129 bool auto_closed_;
130 bool record_uma_;
131 bool async_in_progress_;
132 bool destroyed_;
133 base::Lock net_log_lock_;
134 BoundNetLog bound_net_log_;
135 };
136
137
138 FileStreamPosix::AsyncContext::AsyncContext(const BoundNetLog& bound_net_log)
139 : file_(base::kInvalidPlatformFileValue),
140 auto_closed_(true),
141 record_uma_(false),
142 async_in_progress_(false),
143 destroyed_(false),
144 bound_net_log_(bound_net_log) {
145 }
146
147 FileStreamPosix::AsyncContext::AsyncContext(base::PlatformFile file,
148 const BoundNetLog& bound_net_log)
149 : file_(file),
150 auto_closed_(false),
151 record_uma_(false),
152 async_in_progress_(false),
153 destroyed_(false),
154 bound_net_log_(bound_net_log) {
155 }
156
157 void FileStreamPosix::AsyncContext::Destroy() {
158 {
159 // By locking we don't allow any operation with |bound_net_log_| to be
160 // in progress while this method is executed. Attempt to do something
161 // with |bound_net_log_| will be done either before this method or after
162 // we switch |context_->destroyed_| which will prohibit any operation on
163 // |bound_net_log_|.
164 base::AutoLock locked(net_log_lock_);
165 destroyed_ = true;
166 }
167 if (!async_in_progress_)
168 DeleteAbandoned();
169 }
170
171 int FileStreamPosix::AsyncContext::RecordAndMapError(int error,
172 FileErrorSource source) {
173 int net_error;
174 {
175 base::AutoLock locked(net_log_lock_);
176 net_error = MapAndLogError(error, source);
177 }
178 RecordFileError(error, source, record_uma_);
67 return net_error; 179 return net_error;
68 } 180 }
69 181
70 // Opens a file with some network logging. 182 void FileStreamPosix::AsyncContext::OpenAsync(
71 // The opened file and the result code are written to |file| and |result|. 183 const FilePath& path,
72 void OpenFile(const FilePath& path, 184 int open_flags,
73 int open_flags, 185 const CompletionCallback& callback) {
74 bool record_uma, 186 DCHECK(!async_in_progress_);
75 base::PlatformFile* file, 187
76 int* result, 188 int* result = new int(OK);
77 const net::BoundNetLog& 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 }
91
92 // Opens a file using OpenFile() and then signals the completion.
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 }
103
104 // Closes a file with some network logging.
105 void CloseFile(base::PlatformFile file,
106 const net::BoundNetLog& bound_net_log) {
107 bound_net_log.AddEvent(net::NetLog::TYPE_FILE_STREAM_CLOSE);
108 if (file == base::kInvalidPlatformFileValue)
109 return;
110
111 if (!base::ClosePlatformFile(file))
112 NOTREACHED();
113 bound_net_log.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
114 }
115
116 // Closes a file with CloseFile() and signals the completion.
117 void CloseFileAndSignal(base::PlatformFile* file,
118 base::WaitableEvent* on_io_complete,
119 const net::BoundNetLog& bound_net_log) {
120 CloseFile(*file, bound_net_log);
121 *file = base::kInvalidPlatformFileValue;
122 on_io_complete->Signal();
123 }
124
125 // Adjusts the position from where the data is read.
126 void SeekFile(base::PlatformFile file,
127 Whence whence,
128 int64 offset,
129 int64* 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 }
143
144 // Seeks a file by calling SeekSync() and signals the completion.
145 void SeekFileAndSignal(base::PlatformFile file,
146 Whence whence,
147 int64 offset,
148 int64* result,
149 bool record_uma,
150 base::WaitableEvent* on_io_complete,
151 const net::BoundNetLog& bound_net_log) {
152 SeekFile(file, whence, offset, result, record_uma, bound_net_log);
153 on_io_complete->Signal();
154 }
155
156 // ReadFile() is a simple wrapper around read() that handles EINTR signals and
157 // calls MapSystemError() to map errno to net error codes.
158 void ReadFile(base::PlatformFile file,
159 char* buf,
160 int buf_len,
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 }
175
176 // Reads a file using ReadFile() and signals the completion.
177 void ReadFileAndSignal(base::PlatformFile file,
178 scoped_refptr<IOBuffer> buf,
179 int buf_len,
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;
232 }
233
234 // Called when Read(), Write() or Seek() is completed.
235 // |result| contains the result or a network error code.
236 template <typename R>
237 void OnIOComplete(const base::WeakPtr<FileStreamPosix>& stream,
238 const base::Callback<void(R)>& callback,
239 R* result) {
240 if (!stream.get())
241 return;
242
243 // Reset this before Run() as Run() may issue a new async operation.
244 stream->ResetOnIOComplete();
245 callback.Run(*result);
246 }
247
248 } // namespace
249
250 // FileStreamPosix ------------------------------------------------------------
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 }
262
263 FileStreamPosix::FileStreamPosix(
264 base::PlatformFile file, int flags, net::NetLog* net_log)
265 : file_(file),
266 open_flags_(flags),
267 auto_closed_(false),
268 record_uma_(false),
269 bound_net_log_(net::BoundNetLog::Make(net_log,
270 net::NetLog::SOURCE_FILESTREAM)),
271 weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
272 bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
273 }
274
275 FileStreamPosix::~FileStreamPosix() {
276 if (open_flags_ & base::PLATFORM_FILE_ASYNC) {
277 // Block until the last open/close/read/write operation is complete.
278 // TODO(satorux): Ideally we should not block. crbug.com/115067
279 WaitForIOCompletion();
280 }
281
282 if (auto_closed_) {
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( 189 const bool posted = base::WorkerPool::PostTaskAndReply(
312 FROM_HERE, 190 FROM_HERE,
313 base::Bind(&CloseFileAndSignal, &file_, on_io_complete_.get(), 191 base::Bind(&AsyncContext::OpenFileImpl, base::Unretained(this),
314 bound_net_log_), 192 path, open_flags, result),
315 base::Bind(&FileStreamPosix::OnClosed, 193 base::Bind(&AsyncContext::OnAsyncCompleted<int>,
316 weak_ptr_factory_.GetWeakPtr(), 194 base::Unretained(this),
317 callback), 195 callback, base::Owned(result)),
318 true /* task_is_slow */); 196 true /* task_is_slow */);
319
320 DCHECK(posted); 197 DCHECK(posted);
198
199 async_in_progress_ = true;
200 }
201
202 int FileStreamPosix::AsyncContext::OpenSync(const FilePath& path,
203 int open_flags) {
204 int result = OK;
205 OpenFileImpl(path, open_flags, &result);
206 return result;
207 }
208
209 void FileStreamPosix::AsyncContext::CloseAsync(
210 const CompletionCallback& callback) {
211 DCHECK(!async_in_progress_);
212
213 // Value OK will never be changed in AsyncContext::CloseFile() and is needed
214 // here just to use the same AsyncContext::OnAsyncCompleted().
215 int* result = new int(OK);
216 const bool posted = base::WorkerPool::PostTaskAndReply(
217 FROM_HERE,
218 base::Bind(&AsyncContext::CloseFileImpl, base::Unretained(this)),
219 base::Bind(&AsyncContext::OnAsyncCompleted<int>,
220 base::Unretained(this),
221 callback, base::Owned(result)),
222 true /* task_is_slow */);
223 DCHECK(posted);
224
225 async_in_progress_ = true;
226 }
227
228 void FileStreamPosix::AsyncContext::CloseSync() {
229 DCHECK(!async_in_progress_);
230 CloseFileImpl();
231 }
232
233 void FileStreamPosix::AsyncContext::SeekAsync(
234 Whence whence,
235 int64 offset,
236 const Int64CompletionCallback& callback) {
237 DCHECK(!async_in_progress_);
238
239 int64* result = new int64(-1);
240 const bool posted = base::WorkerPool::PostTaskAndReply(
241 FROM_HERE,
242 base::Bind(&AsyncContext::SeekFileImpl, base::Unretained(this),
243 whence, offset, result),
244 base::Bind(&AsyncContext::OnAsyncCompleted<int64>,
245 base::Unretained(this),
246 callback, base::Owned(result)),
247 true /* task is slow */);
248 DCHECK(posted);
249
250 async_in_progress_ = true;
251 }
252
253 int64 FileStreamPosix::AsyncContext::SeekSync(Whence whence, int64 offset) {
254 off_t result = -1;
255 SeekFileImpl(whence, offset, &result);
256 return result;
257 }
258
259 void FileStreamPosix::AsyncContext::ReadAsync(
260 IOBuffer* in_buf,
261 int buf_len,
262 const CompletionCallback& callback) {
263 DCHECK(!async_in_progress_);
264
265 int* result = new int(OK);
266 scoped_refptr<IOBuffer> buf = in_buf;
267 const bool posted = base::WorkerPool::PostTaskAndReply(
268 FROM_HERE,
269 base::Bind(&AsyncContext::ReadFileImpl, base::Unretained(this),
270 buf, buf_len, result),
271 base::Bind(&AsyncContext::OnAsyncCompleted<int>,
272 base::Unretained(this),
273 callback, base::Owned(result)),
274 true /* task is slow */);
275 DCHECK(posted);
276
277 async_in_progress_ = true;
278 }
279
280 int FileStreamPosix::AsyncContext::ReadSync(char* in_buf, int buf_len) {
281 int result = OK;
282 scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(in_buf);
283 ReadFileImpl(buf, buf_len, &result);
284 return result;
285 }
286
287 void FileStreamPosix::AsyncContext::WriteAsync(
288 IOBuffer* in_buf,
289 int buf_len,
290 const CompletionCallback& callback) {
291 DCHECK(!async_in_progress_);
292
293 int* result = new int(OK);
294 scoped_refptr<IOBuffer> buf = in_buf;
295 const bool posted = base::WorkerPool::PostTaskAndReply(
296 FROM_HERE,
297 base::Bind(&AsyncContext::WriteFileImpl, base::Unretained(this),
298 buf, buf_len, result),
299 base::Bind(&AsyncContext::OnAsyncCompleted<int>,
300 base::Unretained(this),
301 callback, base::Owned(result)),
302 true /* task is slow */);
303 DCHECK(posted);
304
305 async_in_progress_ = true;
306 }
307
308 int FileStreamPosix::AsyncContext::WriteSync(const char* in_buf, int buf_len) {
309 int result = OK;
310 scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(in_buf);
311 WriteFileImpl(buf, buf_len, &result);
312 return result;
313 }
314
315 int FileStreamPosix::AsyncContext::MapAndLogError(int error,
316 FileErrorSource source) {
317 net_log_lock_.AssertAcquired();
318 // The following check is against incorrect use or bug. File descriptor
319 // shouldn't ever be closed outside of FileStream while it still tries to do
320 // something with it.
321 DCHECK(error != EBADF);
322 net::Error net_error = MapSystemError(error);
323
324 if (!destroyed_) {
325 bound_net_log_.AddEvent(
326 net::NetLog::TYPE_FILE_STREAM_ERROR,
327 base::Bind(&NetLogFileStreamErrorCallback,
328 source, error, net_error));
329 }
330
331 return net_error;
332 }
333
334 void FileStreamPosix::AsyncContext::OpenFileImpl(const FilePath& path,
335 int open_flags,
336 int* result) {
337 std::string file_name = path.AsUTF8Unsafe();
338 {
339 base::AutoLock locked(net_log_lock_);
340 // Bail out quickly if operation was already canceled
341 if (destroyed_)
342 return;
343
344 bound_net_log_.BeginEvent(
345 net::NetLog::TYPE_FILE_STREAM_OPEN,
346 NetLog::StringCallback("file_name", &file_name));
347 }
348
349 *result = OK;
350 file_ = base::CreatePlatformFile(path, open_flags, NULL, NULL);
351 if (file_ == base::kInvalidPlatformFileValue) {
352 int error = errno;
353 {
354 base::AutoLock locked(net_log_lock_);
355 if (!destroyed_)
356 bound_net_log_.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
357 *result = MapAndLogError(error, FILE_ERROR_SOURCE_OPEN);
358 }
359 RecordFileError(error, FILE_ERROR_SOURCE_OPEN, record_uma_);
360 }
361 }
362
363 void FileStreamPosix::AsyncContext::CloseFileImpl() {
364 {
365 base::AutoLock locked(net_log_lock_);
366 if (!destroyed_)
367 bound_net_log_.AddEvent(net::NetLog::TYPE_FILE_STREAM_CLOSE);
368 }
369
370 if (file_ == base::kInvalidPlatformFileValue)
371 return;
372 if (!base::ClosePlatformFile(file_))
373 NOTREACHED();
374 file_ = base::kInvalidPlatformFileValue;
375
376 {
377 base::AutoLock locked(net_log_lock_);
378 if (!destroyed_)
379 bound_net_log_.EndEvent(net::NetLog::TYPE_FILE_STREAM_OPEN);
380 }
381 }
382
383 void FileStreamPosix::AsyncContext::SeekFileImpl(Whence whence,
384 int64 offset,
385 int64* result) {
386 base::ThreadRestrictions::AssertIOAllowed();
387
388 // If context has been already destroyed nobody waits for operation results.
389 if (destroyed_)
390 return;
391
392 off_t res = lseek(file_, static_cast<off_t>(offset),
393 static_cast<int>(whence));
394 if (res == static_cast<off_t>(-1))
395 res = RecordAndMapError(errno, FILE_ERROR_SOURCE_SEEK);
396 *result = res;
397 }
398
399 void FileStreamPosix::AsyncContext::ReadFileImpl(scoped_refptr<IOBuffer> buf,
400 int buf_len,
401 int* result) {
402 base::ThreadRestrictions::AssertIOAllowed();
403
404 // If context has been already destroyed nobody waits for operation results.
405 if (destroyed_)
406 return;
407
408 // Loop in the case of getting interrupted by a signal.
409 ssize_t res = HANDLE_EINTR(read(file_, buf->data(),
410 static_cast<size_t>(buf_len)));
411 if (res == -1)
412 res = RecordAndMapError(errno, FILE_ERROR_SOURCE_READ);
413 *result = res;
414 }
415
416 void FileStreamPosix::AsyncContext::WriteFileImpl(scoped_refptr<IOBuffer> buf,
417 int buf_len,
418 int* result) {
419 base::ThreadRestrictions::AssertIOAllowed();
420
421 // If context has been already destroyed nobody waits for operation results.
422 if (destroyed_)
423 return;
424
425 ssize_t res = HANDLE_EINTR(write(file_, buf->data(), buf_len));
426 if (res == -1)
427 res = RecordAndMapError(errno, FILE_ERROR_SOURCE_WRITE);
428 *result = res;
429 }
430
431 template <typename R>
432 void FileStreamPosix::AsyncContext::OnAsyncCompleted(
433 const base::Callback<void(R)>& callback,
434 R* result) {
435 if (destroyed_) {
436 DeleteAbandoned();
437 } else {
438 // Reset this before Run() as Run() may issue a new async operation.
439 async_in_progress_ = false;
440 callback.Run(*result);
441 }
442 }
443
444 void FileStreamPosix::AsyncContext::DeleteAbandoned() {
445 if (auto_closed_ && file_ != base::kInvalidPlatformFileValue) {
446 const bool posted = base::WorkerPool::PostTask(
447 FROM_HERE,
448 // Context should be deleted after closing, thus Owned().
449 base::Bind(&AsyncContext::CloseFileImpl, base::Owned(this)),
450 true /* task_is_slow */);
451 DCHECK(posted);
452 } else {
453 delete this;
454 }
455 }
456
457
458 // FileStreamPosix ------------------------------------------------------------
459
460 FileStreamPosix::FileStreamPosix(net::NetLog* net_log)
461 : context_(NULL),
462 open_flags_(0),
463 bound_net_log_(net::BoundNetLog::Make(net_log,
464 net::NetLog::SOURCE_FILESTREAM)) {
465 context_ = new AsyncContext(bound_net_log_);
466
467 bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
468 }
469
470 FileStreamPosix::FileStreamPosix(base::PlatformFile file,
471 int flags,
472 net::NetLog* net_log)
473 : context_(NULL),
474 open_flags_(flags),
475 bound_net_log_(net::BoundNetLog::Make(net_log,
476 net::NetLog::SOURCE_FILESTREAM)) {
477 context_ = new AsyncContext(file, bound_net_log_);
478
479 bound_net_log_.BeginEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
480 }
481
482 FileStreamPosix::~FileStreamPosix() {
483 if (context_->auto_closed() && !is_async())
484 CloseSync();
485 context_->Destroy();
486
487 bound_net_log_.EndEvent(net::NetLog::TYPE_FILE_STREAM_ALIVE);
488 }
489
490 void FileStreamPosix::Close(const CompletionCallback& callback) {
491 DCHECK(is_async());
492 context_->CloseAsync(callback);
321 } 493 }
322 494
323 void FileStreamPosix::CloseSync() { 495 void FileStreamPosix::CloseSync() {
496 // CloseSync() should be called on the correct thread even if it eventually
497 // ends up inside CloseAndCancelAsync().
498 base::ThreadRestrictions::AssertIOAllowed();
499
324 // TODO(satorux): Replace the following async stuff with a 500 // TODO(satorux): Replace the following async stuff with a
325 // DCHECK(open_flags & ASYNC) once once all async clients are migrated to 501 // DCHECK(open_flags & ASYNC) once all async clients are migrated to
326 // use Close(). crbug.com/114783 502 // use Close(). crbug.com/114783
327 503 if (context_->async_in_progress())
328 // Abort any existing asynchronous operations. 504 CloseAndCancelAsync();
329 weak_ptr_factory_.InvalidateWeakPtrs(); 505 else
330 // Block until the last open/read/write operation is complete. 506 context_->CloseSync();
331 // TODO(satorux): Ideally we should not block. crbug.com/115067 507 }
332 WaitForIOCompletion(); 508
333 509 void FileStreamPosix::CloseAndCancelAsync() {
334 CloseFile(file_, bound_net_log_); 510 if (!IsOpen())
335 file_ = base::kInvalidPlatformFileValue; 511 return;
336 } 512
337 513 DCHECK(is_async());
338 int FileStreamPosix::Open(const FilePath& path, int open_flags, 514
339 const CompletionCallback& callback) { 515 AsyncContext* old_ctx = context_;
516 context_ = new AsyncContext(bound_net_log_);
517 context_->set_record_uma(old_ctx->record_uma());
518 old_ctx->set_auto_closed(true);
519 old_ctx->Destroy();
520 }
521
522 int FileStreamPosix::Open(const FilePath& path,
523 int open_flags,
524 const CompletionCallback& callback) {
340 if (IsOpen()) { 525 if (IsOpen()) {
341 DLOG(FATAL) << "File is already open!"; 526 DLOG(FATAL) << "File is already open!";
342 return ERR_UNEXPECTED; 527 return ERR_UNEXPECTED;
343 } 528 }
344 529
345 open_flags_ = open_flags; 530 open_flags_ = open_flags;
346 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC); 531 DCHECK(is_async());
347 532 context_->OpenAsync(path, open_flags, callback);
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; 533 return ERR_IO_PENDING;
367 } 534 }
368 535
369 int FileStreamPosix::OpenSync(const FilePath& path, int open_flags) { 536 int FileStreamPosix::OpenSync(const FilePath& path, int open_flags) {
370 if (IsOpen()) { 537 if (IsOpen()) {
371 DLOG(FATAL) << "File is already open!"; 538 DLOG(FATAL) << "File is already open!";
372 return ERR_UNEXPECTED; 539 return ERR_UNEXPECTED;
373 } 540 }
374 541
375 open_flags_ = open_flags; 542 open_flags_ = open_flags;
376 // TODO(satorux): Put a DCHECK once once all async clients are migrated 543 // TODO(satorux): Put a DCHECK once all async clients are migrated
377 // to use Open(). crbug.com/114783 544 // to use Open(). crbug.com/114783
378 // 545 //
379 // DCHECK(!(open_flags_ & base::PLATFORM_FILE_ASYNC)); 546 // DCHECK(!is_async());
380 547 return context_->OpenSync(path, open_flags_);
381 int result = OK;
382 OpenFile(path, open_flags_, record_uma_, &file_, &result, bound_net_log_);
383 return result;
384 } 548 }
385 549
386 bool FileStreamPosix::IsOpen() const { 550 bool FileStreamPosix::IsOpen() const {
387 return file_ != base::kInvalidPlatformFileValue; 551 return context_->file() != base::kInvalidPlatformFileValue;
388 } 552 }
389 553
390 int FileStreamPosix::Seek(Whence whence, int64 offset, 554 int FileStreamPosix::Seek(Whence whence,
555 int64 offset,
391 const Int64CompletionCallback& callback) { 556 const Int64CompletionCallback& callback) {
392 if (!IsOpen()) 557 if (!IsOpen())
393 return ERR_UNEXPECTED; 558 return ERR_UNEXPECTED;
394 559
395 // Make sure we're async and we have no other in-flight async operations. 560 // Make sure we're async.
396 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC); 561 DCHECK(is_async());
397 DCHECK(!weak_ptr_factory_.HasWeakPtrs()); 562 context_->SeekAsync(whence, offset, callback);
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; 563 return ERR_IO_PENDING;
414 } 564 }
415 565
416 int64 FileStreamPosix::SeekSync(Whence whence, int64 offset) { 566 int64 FileStreamPosix::SeekSync(Whence whence, int64 offset) {
417 base::ThreadRestrictions::AssertIOAllowed();
418
419 if (!IsOpen()) 567 if (!IsOpen())
420 return ERR_UNEXPECTED; 568 return ERR_UNEXPECTED;
421 569
422 // If we're in async, make sure we don't have a request in flight. 570 // If we're in async, make sure we don't have a request in flight.
423 DCHECK(!(open_flags_ & base::PLATFORM_FILE_ASYNC) || 571 DCHECK(!is_async() || !context_->async_in_progress());
424 !on_io_complete_.get()); 572 return context_->SeekSync(whence, offset);
425
426 off_t result = -1;
427 SeekFile(file_, whence, offset, &result, record_uma_, bound_net_log_);
428 return result;
429 } 573 }
430 574
431 int64 FileStreamPosix::Available() { 575 int64 FileStreamPosix::Available() {
432 base::ThreadRestrictions::AssertIOAllowed(); 576 base::ThreadRestrictions::AssertIOAllowed();
433 577
434 if (!IsOpen()) 578 if (!IsOpen())
435 return ERR_UNEXPECTED; 579 return ERR_UNEXPECTED;
436 580
437 int64 cur_pos = SeekSync(FROM_CURRENT, 0); 581 int64 cur_pos = SeekSync(FROM_CURRENT, 0);
438 if (cur_pos < 0) 582 if (cur_pos < 0)
439 return cur_pos; 583 return cur_pos;
440 584
441 struct stat info; 585 struct stat info;
442 if (fstat(file_, &info) != 0) { 586 if (fstat(context_->file(), &info) != 0)
443 return RecordAndMapError(errno, 587 return context_->RecordAndMapError(errno, FILE_ERROR_SOURCE_GET_SIZE);
444 FILE_ERROR_SOURCE_GET_SIZE,
445 record_uma_,
446 bound_net_log_);
447 }
448 588
449 int64 size = static_cast<int64>(info.st_size); 589 int64 size = static_cast<int64>(info.st_size);
450 DCHECK_GT(size, cur_pos); 590 DCHECK_GT(size, cur_pos);
451 591
452 return size - cur_pos; 592 return size - cur_pos;
453 } 593 }
454 594
455 int FileStreamPosix::Read( 595 int FileStreamPosix::Read(IOBuffer* buf,
456 IOBuffer* in_buf, int buf_len, const CompletionCallback& callback) { 596 int buf_len,
597 const CompletionCallback& callback) {
457 if (!IsOpen()) 598 if (!IsOpen())
458 return ERR_UNEXPECTED; 599 return ERR_UNEXPECTED;
459 600
460 // read(..., 0) will return 0, which indicates end-of-file. 601 // read(..., 0) will return 0, which indicates end-of-file.
461 DCHECK_GT(buf_len, 0); 602 DCHECK_GT(buf_len, 0);
462 DCHECK(open_flags_ & base::PLATFORM_FILE_READ); 603 DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
463 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC); 604 DCHECK(is_async());
464 605
465 // Make sure we don't have a request in flight. 606 context_->ReadAsync(buf, buf_len, callback);
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; 607 return ERR_IO_PENDING;
484 } 608 }
485 609
486 int FileStreamPosix::ReadSync(char* buf, int buf_len) { 610 int FileStreamPosix::ReadSync(char* buf, int buf_len) {
487 if (!IsOpen()) 611 if (!IsOpen())
488 return ERR_UNEXPECTED; 612 return ERR_UNEXPECTED;
489 613
490 DCHECK(!(open_flags_ & base::PLATFORM_FILE_ASYNC)); 614 DCHECK(!is_async());
491 // read(..., 0) will return 0, which indicates end-of-file. 615 // read(..., 0) will return 0, which indicates end-of-file.
492 DCHECK_GT(buf_len, 0); 616 DCHECK_GT(buf_len, 0);
493 DCHECK(open_flags_ & base::PLATFORM_FILE_READ); 617 DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
494 618
495 int result = OK; 619 return context_->ReadSync(buf, buf_len);
496 ReadFile(file_, buf, buf_len, record_uma_, &result, bound_net_log_);
497 return result;
498 } 620 }
499 621
500 int FileStreamPosix::ReadUntilComplete(char *buf, int buf_len) { 622 int FileStreamPosix::ReadUntilComplete(char *buf, int buf_len) {
501 int to_read = buf_len; 623 int to_read = buf_len;
502 int bytes_total = 0; 624 int bytes_total = 0;
503 625
504 do { 626 do {
505 int bytes_read = ReadSync(buf, to_read); 627 int bytes_read = ReadSync(buf, to_read);
506 if (bytes_read <= 0) { 628 if (bytes_read <= 0) {
507 if (bytes_total == 0) 629 if (bytes_total == 0)
508 return bytes_read; 630 return bytes_read;
509 631
510 return bytes_total; 632 return bytes_total;
511 } 633 }
512 634
513 bytes_total += bytes_read; 635 bytes_total += bytes_read;
514 buf += bytes_read; 636 buf += bytes_read;
515 to_read -= bytes_read; 637 to_read -= bytes_read;
516 } while (bytes_total < buf_len); 638 } while (bytes_total < buf_len);
517 639
518 return bytes_total; 640 return bytes_total;
519 } 641 }
520 642
521 int FileStreamPosix::Write( 643 int FileStreamPosix::Write(IOBuffer* buf,
522 IOBuffer* in_buf, int buf_len, const CompletionCallback& callback) { 644 int buf_len,
645 const CompletionCallback& callback) {
523 if (!IsOpen()) 646 if (!IsOpen())
524 return ERR_UNEXPECTED; 647 return ERR_UNEXPECTED;
525 648
526 DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC); 649 DCHECK(is_async());
527 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE); 650 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
528 // write(..., 0) will return 0, which indicates end-of-file. 651 // write(..., 0) will return 0, which indicates end-of-file.
529 DCHECK_GT(buf_len, 0); 652 DCHECK_GT(buf_len, 0);
530 653
531 // Make sure we don't have a request in flight. 654 context_->WriteAsync(buf, buf_len, callback);
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; 655 return ERR_IO_PENDING;
549 } 656 }
550 657
551 int FileStreamPosix::WriteSync( 658 int FileStreamPosix::WriteSync(const char* buf, int buf_len) {
552 const char* buf, int buf_len) {
553 if (!IsOpen()) 659 if (!IsOpen())
554 return ERR_UNEXPECTED; 660 return ERR_UNEXPECTED;
555 661
556 DCHECK(!(open_flags_ & base::PLATFORM_FILE_ASYNC)); 662 DCHECK(!is_async());
557 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE); 663 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
558 // write(..., 0) will return 0, which indicates end-of-file. 664 // write(..., 0) will return 0, which indicates end-of-file.
559 DCHECK_GT(buf_len, 0); 665 DCHECK_GT(buf_len, 0);
560 666
561 int result = OK; 667 return context_->WriteSync(buf, buf_len);
562 WriteFile(file_, buf, buf_len, record_uma_, &result, bound_net_log_);
563 return result;
564 } 668 }
565 669
566 int64 FileStreamPosix::Truncate(int64 bytes) { 670 int64 FileStreamPosix::Truncate(int64 bytes) {
567 base::ThreadRestrictions::AssertIOAllowed(); 671 base::ThreadRestrictions::AssertIOAllowed();
568 672
569 if (!IsOpen()) 673 if (!IsOpen())
570 return ERR_UNEXPECTED; 674 return ERR_UNEXPECTED;
571 675
572 // We'd better be open for writing. 676 // We'd better be open for writing.
573 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE); 677 DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
574 678
575 // Seek to the position to truncate from. 679 // Seek to the position to truncate from.
576 int64 seek_position = SeekSync(FROM_BEGIN, bytes); 680 int64 seek_position = SeekSync(FROM_BEGIN, bytes);
577 if (seek_position != bytes) 681 if (seek_position != bytes)
578 return ERR_UNEXPECTED; 682 return ERR_UNEXPECTED;
579 683
580 // And truncate the file. 684 // And truncate the file.
581 int result = ftruncate(file_, bytes); 685 int result = ftruncate(context_->file(), bytes);
582 if (result == 0) 686 if (result == 0)
583 return seek_position; 687 return seek_position;
584 688
585 return RecordAndMapError(errno, 689 return context_->RecordAndMapError(errno, FILE_ERROR_SOURCE_SET_EOF);
586 FILE_ERROR_SOURCE_SET_EOF,
587 record_uma_,
588 bound_net_log_);
589 } 690 }
590 691
591 int FileStreamPosix::Flush() { 692 int FileStreamPosix::Flush() {
693 base::ThreadRestrictions::AssertIOAllowed();
694
592 if (!IsOpen()) 695 if (!IsOpen())
593 return ERR_UNEXPECTED; 696 return ERR_UNEXPECTED;
594 697
595 return FlushFile(file_, record_uma_, bound_net_log_); 698 ssize_t res = HANDLE_EINTR(fsync(context_->file()));
699 if (res == -1)
700 res = context_->RecordAndMapError(errno, FILE_ERROR_SOURCE_FLUSH);
701 return res;
596 } 702 }
597 703
598 void FileStreamPosix::EnableErrorStatistics() { 704 void FileStreamPosix::EnableErrorStatistics() {
599 record_uma_ = true; 705 context_->set_record_uma(true);
600 } 706 }
601 707
602 void FileStreamPosix::SetBoundNetLogSource( 708 void FileStreamPosix::SetBoundNetLogSource(
603 const net::BoundNetLog& owner_bound_net_log) { 709 const net::BoundNetLog& owner_bound_net_log) {
604 if ((owner_bound_net_log.source().id == net::NetLog::Source::kInvalidId) && 710 if ((owner_bound_net_log.source().id == net::NetLog::Source::kInvalidId) &&
605 (bound_net_log_.source().id == net::NetLog::Source::kInvalidId)) { 711 (bound_net_log_.source().id == net::NetLog::Source::kInvalidId)) {
606 // Both |BoundNetLog|s are invalid. 712 // Both |BoundNetLog|s are invalid.
607 return; 713 return;
608 } 714 }
609 715
610 // Should never connect to itself. 716 // Should never connect to itself.
611 DCHECK_NE(bound_net_log_.source().id, owner_bound_net_log.source().id); 717 DCHECK_NE(bound_net_log_.source().id, owner_bound_net_log.source().id);
612 718
613 bound_net_log_.AddEvent( 719 bound_net_log_.AddEvent(
614 net::NetLog::TYPE_FILE_STREAM_BOUND_TO_OWNER, 720 net::NetLog::TYPE_FILE_STREAM_BOUND_TO_OWNER,
615 owner_bound_net_log.source().ToEventParametersCallback()); 721 owner_bound_net_log.source().ToEventParametersCallback());
616 722
617 owner_bound_net_log.AddEvent( 723 owner_bound_net_log.AddEvent(
618 net::NetLog::TYPE_FILE_STREAM_SOURCE, 724 net::NetLog::TYPE_FILE_STREAM_SOURCE,
619 bound_net_log_.source().ToEventParametersCallback()); 725 bound_net_log_.source().ToEventParametersCallback());
620 } 726 }
621 727
622 base::PlatformFile FileStreamPosix::GetPlatformFileForTesting() { 728 base::PlatformFile FileStreamPosix::GetPlatformFileForTesting() {
623 return file_; 729 return context_->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 } 730 }
647 731
648 } // namespace net 732 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698