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

Unified Diff: net/base/file_stream_context_win.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, 1 month 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 side-by-side diff with in-line comments
Download patch
Index: net/base/file_stream_context_win.cc
diff --git a/net/base/file_stream_context_win.cc b/net/base/file_stream_context_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a514ab0391682a4cdd140edfe31d7e48d63caf7d
--- /dev/null
+++ b/net/base/file_stream_context_win.cc
@@ -0,0 +1,237 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/base/file_stream_context.h"
+
+#include <windows.h>
+
+#include "base/file_path.h"
+#include "base/logging.h"
+#include "base/metrics/histogram.h"
+#include "base/task_runner_util.h"
+#include "base/threading/worker_pool.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+
+namespace net {
+
+// Ensure that we can just use our Whence values directly.
+COMPILE_ASSERT(FROM_BEGIN == FILE_BEGIN, bad_whence_begin);
+COMPILE_ASSERT(FROM_CURRENT == FILE_CURRENT, bad_whence_current);
+COMPILE_ASSERT(FROM_END == FILE_END, bad_whence_end);
+
+namespace {
+
+void SetOffset(OVERLAPPED* overlapped, const LARGE_INTEGER& offset) {
+ overlapped->Offset = offset.LowPart;
+ overlapped->OffsetHigh = offset.HighPart;
+}
+
+void IncrementOffset(OVERLAPPED* overlapped, DWORD count) {
+ LARGE_INTEGER offset;
+ offset.LowPart = overlapped->Offset;
+ offset.HighPart = overlapped->OffsetHigh;
+ offset.QuadPart += static_cast<LONGLONG>(count);
+ SetOffset(overlapped, offset);
+}
+
+} // namespace
+
+FileStream::Context::Context(const BoundNetLog& bound_net_log)
+ : io_context_(),
+ file_(base::kInvalidPlatformFileValue),
+ record_uma_(false),
+ async_in_progress_(false),
+ orphaned_(false),
+ bound_net_log_(bound_net_log),
+ error_source_(FILE_ERROR_SOURCE_COUNT) {
+ io_context_.handler = this;
+}
+
+FileStream::Context::Context(base::PlatformFile file,
+ const BoundNetLog& bound_net_log,
+ int open_flags)
+ : io_context_(),
+ file_(file),
+ record_uma_(false),
+ async_in_progress_(false),
+ orphaned_(false),
+ bound_net_log_(bound_net_log),
+ error_source_(FILE_ERROR_SOURCE_COUNT) {
+ io_context_.handler = this;
+ if (file_ != base::kInvalidPlatformFileValue &&
+ (open_flags & base::PLATFORM_FILE_ASYNC)) {
+ OnAsyncFileOpened();
+ }
+}
+
+FileStream::Context::~Context() {
+}
+
+int64 FileStream::Context::GetFileSize() const {
+ LARGE_INTEGER file_size;
+ if (!GetFileSizeEx(file_, &file_size)) {
+ DWORD error = GetLastError();
+ LOG(WARNING) << "GetFileSizeEx failed: " << error;
+ return RecordAndMapError(error, FILE_ERROR_SOURCE_GET_SIZE);
+ }
+
+ return file_size.QuadPart;
+}
+
+int FileStream::Context::ReadAsync(IOBuffer* buf,
+ int buf_len,
+ const CompletionCallback& callback) {
+ DCHECK(!async_in_progress_);
+ error_source_ = FILE_ERROR_SOURCE_READ;
+
+ int rv = 0;
+
+ DWORD bytes_read;
+ if (!ReadFile(file_, buf->data(), buf_len,
+ &bytes_read, &io_context_.overlapped)) {
+ DWORD error = GetLastError();
+ if (error == ERROR_IO_PENDING) {
+ IOCompletionIsPending(callback, buf);
+ rv = ERR_IO_PENDING;
+ } else if (error == ERROR_HANDLE_EOF) {
+ rv = 0; // Report EOF by returning 0 bytes read.
+ } else {
+ LOG(WARNING) << "ReadFile failed: " << error;
+ rv = RecordAndMapError(error, FILE_ERROR_SOURCE_READ);
+ }
+ } else {
+ IOCompletionIsPending(callback, buf);
+ rv = ERR_IO_PENDING;
+ }
+ return rv;
+}
+
+int FileStream::Context::ReadSync(char* buf, int buf_len) {
+ int rv = 0;
+
+ DWORD bytes_read;
+ if (!ReadFile(file_, buf, buf_len, &bytes_read, NULL)) {
+ DWORD error = GetLastError();
+ if (error == ERROR_HANDLE_EOF) {
+ rv = 0; // Report EOF by returning 0 bytes read.
+ } else {
+ LOG(WARNING) << "ReadFile failed: " << error;
+ rv = RecordAndMapError(error, FILE_ERROR_SOURCE_READ);
+ }
+ } else {
+ rv = static_cast<int>(bytes_read);
+ }
+ return rv;
+}
+
+int FileStream::Context::WriteAsync(IOBuffer* buf,
+ int buf_len,
+ const CompletionCallback& callback) {
+ error_source_ = FILE_ERROR_SOURCE_WRITE;
+
+ int rv = 0;
+ DWORD bytes_written = 0;
+ if (!WriteFile(file_, buf->data(), buf_len,
+ &bytes_written, &io_context_.overlapped)) {
+ DWORD error = GetLastError();
+ if (error == ERROR_IO_PENDING) {
+ IOCompletionIsPending(callback, buf);
+ rv = ERR_IO_PENDING;
+ } else {
+ LOG(WARNING) << "WriteFile failed: " << error;
+ rv = RecordAndMapError(error, FILE_ERROR_SOURCE_WRITE);
+ }
+ } else {
+ IOCompletionIsPending(callback, buf);
+ rv = ERR_IO_PENDING;
+ }
+ return rv;
+}
+
+int FileStream::Context::WriteSync(const char* buf, int buf_len) {
+ int rv = 0;
+ DWORD bytes_written = 0;
+ if (!WriteFile(file_, buf, buf_len, &bytes_written, NULL)) {
+ DWORD error = GetLastError();
+ LOG(WARNING) << "WriteFile failed: " << error;
+ rv = RecordAndMapError(error, FILE_ERROR_SOURCE_WRITE);
+ } else {
+ rv = static_cast<int>(bytes_written);
+ }
+ return rv;
+}
+
+int FileStream::Context::Truncate(int64 bytes) {
+ BOOL result = SetEndOfFile(file_);
+ if (result)
+ return bytes;
+
+ DWORD error = GetLastError();
+ LOG(WARNING) << "SetEndOfFile failed: " << error;
+ return RecordAndMapError(error, FILE_ERROR_SOURCE_SET_EOF);
+}
+
+void FileStream::Context::OnAsyncFileOpened() {
+ MessageLoopForIO::current()->RegisterIOHandler(file_, this);
+}
+
+int64 FileStream::Context::SeekFileImpl(Whence whence, int64 offset) {
+ LARGE_INTEGER distance, res;
+ distance.QuadPart = offset;
+ DWORD move_method = static_cast<DWORD>(whence);
+ if (SetFilePointerEx(file_, distance, &res, move_method)) {
+ SetOffset(&io_context_.overlapped, res);
+ return res.QuadPart;
+ }
+
+ return -static_cast<int>(GetLastError());
+}
+
+int64 FileStream::Context::FlushFileImpl() {
+ if (FlushFileBuffers(file_))
+ return OK;
+
+ return -static_cast<int>(GetLastError());
+}
+
+void FileStream::Context::IOCompletionIsPending(
+ const CompletionCallback& callback,
+ IOBuffer* buf) {
+ DCHECK(callback_.is_null());
+ callback_ = callback;
+ in_flight_buf_ = buf; // Hold until the async operation ends.
+ async_in_progress_ = true;
+}
+
+void FileStream::Context::OnIOCompleted(MessageLoopForIO::IOContext* context,
+ DWORD bytes_read,
+ DWORD error) {
+ DCHECK_EQ(&io_context_, context);
+ DCHECK(!callback_.is_null());
+ DCHECK(async_in_progress_);
+
+ async_in_progress_ = false;
+ if (orphaned_) {
+ callback_.Reset();
+ in_flight_buf_ = NULL;
+ CloseAndDelete();
+ return;
+ }
+
+ int result = static_cast<int>(bytes_read);
+ if (error && error != ERROR_HANDLE_EOF)
+ result = RecordAndMapError(error, error_source_);
+
+ if (bytes_read)
+ IncrementOffset(&io_context_.overlapped, bytes_read);
+
+ CompletionCallback temp_callback = callback_;
+ callback_.Reset();
+ scoped_refptr<IOBuffer> temp_buf = in_flight_buf_;
+ in_flight_buf_ = NULL;
+ temp_callback.Run(result);
+}
+
+} // namespace net

Powered by Google App Engine
This is Rietveld 408576698