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 #include "net/base/file_stream_context.h" 6 7 #include <windows.h> 8 9 #include "base/files/file_path.h" 10 #include "base/logging.h" 11 #include "base/metrics/histogram.h" 12 #include "base/task_runner_util.h" 13 #include "net/base/io_buffer.h" 14 #include "net/base/net_errors.h" 15 16 namespace net { 17 18 // Ensure that we can just use our Whence values directly. 19 COMPILE_ASSERT(FROM_BEGIN == FILE_BEGIN, bad_whence_begin); 20 COMPILE_ASSERT(FROM_CURRENT == FILE_CURRENT, bad_whence_current); 21 COMPILE_ASSERT(FROM_END == FILE_END, bad_whence_end); 22 23 namespace { 24 25 void SetOffset(OVERLAPPED* overlapped, const LARGE_INTEGER& offset) { 26 overlapped->Offset = offset.LowPart; 27 overlapped->OffsetHigh = offset.HighPart; 28 } 29 30 void IncrementOffset(OVERLAPPED* overlapped, DWORD count) { 31 LARGE_INTEGER offset; 32 offset.LowPart = overlapped->Offset; 33 offset.HighPart = overlapped->OffsetHigh; 34 offset.QuadPart += static_cast<LONGLONG>(count); 35 SetOffset(overlapped, offset); 36 } 37 38 } // namespace 39 40 FileStream::Context::Context(const BoundNetLog& bound_net_log, 41 const scoped_refptr<base::TaskRunner>& task_runner) 42 : io_context_(), 43 file_(base::kInvalidPlatformFileValue), 44 record_uma_(false), 45 async_in_progress_(false), 46 orphaned_(false), 47 bound_net_log_(bound_net_log), 48 error_source_(FILE_ERROR_SOURCE_COUNT), 49 task_runner_(task_runner) { 50 io_context_.handler = this; 51 memset(&io_context_.overlapped, 0, sizeof(io_context_.overlapped)); 52 } 53 54 FileStream::Context::Context(base::PlatformFile file, 55 const BoundNetLog& bound_net_log, 56 int open_flags, 57 const scoped_refptr<base::TaskRunner>& task_runner) 58 : io_context_(), 59 file_(file), 60 record_uma_(false), 61 async_in_progress_(false), 62 orphaned_(false), 63 bound_net_log_(bound_net_log), 64 error_source_(FILE_ERROR_SOURCE_COUNT), 65 task_runner_(task_runner) { 66 io_context_.handler = this; 67 memset(&io_context_.overlapped, 0, sizeof(io_context_.overlapped)); 68 if (file_ != base::kInvalidPlatformFileValue && 69 (open_flags & base::PLATFORM_FILE_ASYNC)) { 70 OnAsyncFileOpened(); 71 } 72 } 73 74 FileStream::Context::~Context() { 75 } 76 77 int64 FileStream::Context::GetFileSize() const { 78 LARGE_INTEGER file_size; 79 if (!GetFileSizeEx(file_, &file_size)) { 80 IOResult error = IOResult::FromOSError(GetLastError()); 81 LOG(WARNING) << "GetFileSizeEx failed: " << error.os_error; 82 RecordError(error, FILE_ERROR_SOURCE_GET_SIZE); 83 return error.result; 84 } 85 86 return file_size.QuadPart; 87 } 88 89 int FileStream::Context::ReadAsync(IOBuffer* buf, 90 int buf_len, 91 const CompletionCallback& callback) { 92 DCHECK(!async_in_progress_); 93 error_source_ = FILE_ERROR_SOURCE_READ; 94 95 DWORD bytes_read; 96 if (!ReadFile(file_, buf->data(), buf_len, 97 &bytes_read, &io_context_.overlapped)) { 98 IOResult error = IOResult::FromOSError(GetLastError()); 99 if (error.os_error == ERROR_IO_PENDING) { 100 IOCompletionIsPending(callback, buf); 101 } else if (error.os_error == ERROR_HANDLE_EOF) { 102 return 0; // Report EOF by returning 0 bytes read. 103 } else { 104 LOG(WARNING) << "ReadFile failed: " << error.os_error; 105 RecordError(error, FILE_ERROR_SOURCE_READ); 106 } 107 return error.result; 108 } 109 110 IOCompletionIsPending(callback, buf); 111 return ERR_IO_PENDING; 112 } 113 114 int FileStream::Context::ReadSync(char* buf, int buf_len) { 115 DWORD bytes_read; 116 if (!ReadFile(file_, buf, buf_len, &bytes_read, NULL)) { 117 IOResult error = IOResult::FromOSError(GetLastError()); 118 if (error.os_error == ERROR_HANDLE_EOF) { 119 return 0; // Report EOF by returning 0 bytes read. 120 } else { 121 LOG(WARNING) << "ReadFile failed: " << error.os_error; 122 RecordError(error, FILE_ERROR_SOURCE_READ); 123 } 124 return error.result; 125 } 126 127 return bytes_read; 128 } 129 130 int FileStream::Context::WriteAsync(IOBuffer* buf, 131 int buf_len, 132 const CompletionCallback& callback) { 133 error_source_ = FILE_ERROR_SOURCE_WRITE; 134 135 DWORD bytes_written = 0; 136 if (!WriteFile(file_, buf->data(), buf_len, 137 &bytes_written, &io_context_.overlapped)) { 138 IOResult error = IOResult::FromOSError(GetLastError()); 139 if (error.os_error == ERROR_IO_PENDING) { 140 IOCompletionIsPending(callback, buf); 141 } else { 142 LOG(WARNING) << "WriteFile failed: " << error.os_error; 143 RecordError(error, FILE_ERROR_SOURCE_WRITE); 144 } 145 return error.result; 146 } 147 148 IOCompletionIsPending(callback, buf); 149 return ERR_IO_PENDING; 150 } 151 152 int FileStream::Context::WriteSync(const char* buf, int buf_len) { 153 DWORD bytes_written = 0; 154 if (!WriteFile(file_, buf, buf_len, &bytes_written, NULL)) { 155 IOResult error = IOResult::FromOSError(GetLastError()); 156 LOG(WARNING) << "WriteFile failed: " << error.os_error; 157 RecordError(error, FILE_ERROR_SOURCE_WRITE); 158 return error.result; 159 } 160 161 return bytes_written; 162 } 163 164 int FileStream::Context::Truncate(int64 bytes) { 165 if (!SetEndOfFile(file_)) { 166 IOResult error = IOResult::FromOSError(GetLastError()); 167 LOG(WARNING) << "SetEndOfFile failed: " << error.os_error; 168 RecordError(error, FILE_ERROR_SOURCE_SET_EOF); 169 return error.result; 170 } 171 172 return bytes; 173 } 174 175 void FileStream::Context::OnAsyncFileOpened() { 176 base::MessageLoopForIO::current()->RegisterIOHandler(file_, this); 177 } 178 179 FileStream::Context::IOResult FileStream::Context::SeekFileImpl(Whence whence, 180 int64 offset) { 181 LARGE_INTEGER distance, res; 182 distance.QuadPart = offset; 183 DWORD move_method = static_cast<DWORD>(whence); 184 if (SetFilePointerEx(file_, distance, &res, move_method)) { 185 SetOffset(&io_context_.overlapped, res); 186 return IOResult(res.QuadPart, 0); 187 } 188 189 return IOResult::FromOSError(GetLastError()); 190 } 191 192 FileStream::Context::IOResult FileStream::Context::FlushFileImpl() { 193 if (FlushFileBuffers(file_)) 194 return IOResult(OK, 0); 195 196 return IOResult::FromOSError(GetLastError()); 197 } 198 199 void FileStream::Context::IOCompletionIsPending( 200 const CompletionCallback& callback, 201 IOBuffer* buf) { 202 DCHECK(callback_.is_null()); 203 callback_ = callback; 204 in_flight_buf_ = buf; // Hold until the async operation ends. 205 async_in_progress_ = true; 206 } 207 208 void FileStream::Context::OnIOCompleted( 209 base::MessageLoopForIO::IOContext* context, 210 DWORD bytes_read, 211 DWORD error) { 212 DCHECK_EQ(&io_context_, context); 213 DCHECK(!callback_.is_null()); 214 DCHECK(async_in_progress_); 215 216 async_in_progress_ = false; 217 if (orphaned_) { 218 callback_.Reset(); 219 in_flight_buf_ = NULL; 220 CloseAndDelete(); 221 return; 222 } 223 224 int result; 225 if (error == ERROR_HANDLE_EOF) { 226 result = 0; 227 } else if (error) { 228 IOResult error_result = IOResult::FromOSError(error); 229 RecordError(error_result, error_source_); 230 result = error_result.result; 231 } else { 232 result = bytes_read; 233 IncrementOffset(&io_context_.overlapped, bytes_read); 234 } 235 236 CompletionCallback temp_callback = callback_; 237 callback_.Reset(); 238 scoped_refptr<IOBuffer> temp_buf = in_flight_buf_; 239 in_flight_buf_ = NULL; 240 temp_callback.Run(result); 241 } 242 243 } // namespace net 244
