| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // For 64-bit file access (off_t = off64_t, lseek64, etc). | |
| 6 #define _FILE_OFFSET_BITS 64 | |
| 7 | |
| 8 #include "net/base/file_stream.h" | |
| 9 | |
| 10 #include <sys/types.h> | |
| 11 #include <sys/stat.h> | |
| 12 #include <fcntl.h> | |
| 13 #include <unistd.h> | |
| 14 #include <errno.h> | |
| 15 | |
| 16 #include "base/basictypes.h" | |
| 17 #include "base/bind.h" | |
| 18 #include "base/bind_helpers.h" | |
| 19 #include "base/callback.h" | |
| 20 #include "base/eintr_wrapper.h" | |
| 21 #include "base/file_path.h" | |
| 22 #include "base/logging.h" | |
| 23 #include "base/message_loop.h" | |
| 24 #include "base/metrics/histogram.h" | |
| 25 #include "base/string_util.h" | |
| 26 #include "base/threading/thread_restrictions.h" | |
| 27 #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" | |
| 32 #include "net/base/net_errors.h" | |
| 33 | |
| 34 #if defined(OS_ANDROID) | |
| 35 // Android's bionic libc only supports the LFS transitional API. | |
| 36 #define off_t off64_t | |
| 37 #define lseek lseek64 | |
| 38 #define stat stat64 | |
| 39 #define fstat fstat64 | |
| 40 #endif | |
| 41 | |
| 42 namespace net { | |
| 43 | |
| 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); | |
| 46 | |
| 47 // Make sure our Whence mappings match the system headers. | |
| 48 COMPILE_ASSERT(FROM_BEGIN == SEEK_SET && | |
| 49 FROM_CURRENT == SEEK_CUR && | |
| 50 FROM_END == SEEK_END, whence_matches_system); | |
| 51 | |
| 52 namespace { | |
| 53 | |
| 54 int RecordAndMapError(int error, | |
| 55 FileErrorSource source, | |
| 56 bool record_uma, | |
| 57 const net::BoundNetLog& 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 } | |
| 69 | |
| 70 // Opens a file with some network logging. | |
| 71 // The opened file and the result code are written to |file| and |result|. | |
| 72 void OpenFile(const FilePath& path, | |
| 73 int open_flags, | |
| 74 bool record_uma, | |
| 75 base::PlatformFile* file, | |
| 76 int* result, | |
| 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( | |
| 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 } | |
| 647 | |
| 648 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10701050:
net: Implement canceling of all async operations in FileStream. (Closed)
Base URL: https://src.chromium.org/chrome/trunk/src/