Fix net::FileStream to handle all errors correctly.

net/base/file_stream_context_posix.cc

 // 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.
 
 // For 64-bit file access (off_t = off64_t, lseek64, etc).
 #define _FILE_OFFSET_BITS 64
 
 #include "net/base/file_stream_context.h"
 
 #include <errno.h>
@@ skipping 50 matching lines @@
       async_in_progress_(false),
       orphaned_(false),
       bound_net_log_(bound_net_log) {
 }
 
 FileStream::Context::~Context() {
 }
 
 int64 FileStream::Context::GetFileSize() const {
   struct stat info;
-  if (fstat(file_, &info) != 0)
-    return RecordAndMapError(errno, FILE_ERROR_SOURCE_GET_SIZE);
+  if (fstat(file_, &info) != 0) {
+    IOResult result = IOResult::FromOSError(errno);
+    RecordError(result, FILE_ERROR_SOURCE_GET_SIZE);
+    return result.result;
+  }
 
   return static_cast<int64>(info.st_size);
 }
 
 int FileStream::Context::ReadAsync(IOBuffer* in_buf,
                                    int buf_len,
                                    const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   scoped_refptr<IOBuffer> buf = in_buf;
   const bool posted = base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true /* task is slow */),
       FROM_HERE,
       base::Bind(&Context::ReadFileImpl,
                  base::Unretained(this), buf, buf_len),
       base::Bind(&Context::ProcessAsyncResult,
                  base::Unretained(this), IntToInt64(callback),
                  FILE_ERROR_SOURCE_READ));
   DCHECK(posted);
 
   async_in_progress_ = true;
   return ERR_IO_PENDING;
 }
 
 int FileStream::Context::ReadSync(char* in_buf, int buf_len) {
   scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(in_buf);
-  int64 result = ReadFileImpl(buf, buf_len);
-  CheckForIOError(&result, FILE_ERROR_SOURCE_READ);
-  return result;
+  IOResult result = ReadFileImpl(buf, buf_len);
+  RecordError(result, FILE_ERROR_SOURCE_READ);
+  return result.result;
 }
 
 int FileStream::Context::WriteAsync(IOBuffer* in_buf,
                                     int buf_len,
                                     const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   scoped_refptr<IOBuffer> buf = in_buf;
   const bool posted = base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true /* task is slow */),
       FROM_HERE,
       base::Bind(&Context::WriteFileImpl,
                  base::Unretained(this), buf, buf_len),
       base::Bind(&Context::ProcessAsyncResult,
                  base::Unretained(this), IntToInt64(callback),
                  FILE_ERROR_SOURCE_WRITE));
   DCHECK(posted);
 
   async_in_progress_ = true;
   return ERR_IO_PENDING;
 }
 
 int FileStream::Context::WriteSync(const char* in_buf, int buf_len) {
   scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(in_buf);
-  int64 result = WriteFileImpl(buf, buf_len);
-  CheckForIOError(&result, FILE_ERROR_SOURCE_WRITE);
-  return result;
+  IOResult result = WriteFileImpl(buf, buf_len);
+  RecordError(result, FILE_ERROR_SOURCE_WRITE);
+  return result.result;
 }
 
 int FileStream::Context::Truncate(int64 bytes) {
-  int result = ftruncate(file_, bytes);
-  if (result == 0)
-    return bytes;
+  if (ftruncate(file_, bytes) != 0) {
+    IOResult result = IOResult::FromOSError(errno);
+    RecordError(result, FILE_ERROR_SOURCE_SET_EOF);
+    return result.result;
+  }
 
-  return RecordAndMapError(errno, FILE_ERROR_SOURCE_SET_EOF);
+  return bytes;
 }
 
-int64 FileStream::Context::SeekFileImpl(Whence whence, int64 offset) {
+FileStream::Context::IOResult FileStream::Context::SeekFileImpl(Whence whence,
+                                                                int64 offset) {
   off_t res = lseek(file_, static_cast<off_t>(offset),
                     static_cast<int>(whence));
   if (res == static_cast<off_t>(-1))
-    return errno;
+    return IOResult::FromOSError(errno);
 
-  return res;
+  return IOResult(res, 0);
 }
 
-int64 FileStream::Context::FlushFileImpl() {
+FileStream::Context::IOResult FileStream::Context::FlushFileImpl() {
   ssize_t res = HANDLE_EINTR(fsync(file_));
   if (res == -1)
-    return errno;
+    return IOResult::FromOSError(errno);
 
-  return res;
+  return IOResult(res, 0);
 }
 
-int64 FileStream::Context::ReadFileImpl(scoped_refptr<IOBuffer> buf,
-                                        int buf_len) {
+FileStream::Context::IOResult FileStream::Context::ReadFileImpl(
+    scoped_refptr<IOBuffer> buf,
+    int buf_len) {
   // Loop in the case of getting interrupted by a signal.
   ssize_t res = HANDLE_EINTR(read(file_, buf->data(),
                                   static_cast<size_t>(buf_len)));
   if (res == -1)
-    return errno;
+    return IOResult::FromOSError(errno);
 
-  return res;
+  return IOResult(res, 0);
 }
 
-int64 FileStream::Context::WriteFileImpl(scoped_refptr<IOBuffer> buf,
-                                         int buf_len) {
+FileStream::Context::IOResult FileStream::Context::WriteFileImpl(
+    scoped_refptr<IOBuffer> buf,
+    int buf_len) {
   ssize_t res = HANDLE_EINTR(write(file_, buf->data(), buf_len));
   if (res == -1)
-    return errno;
+    return IOResult::FromOSError(errno);
 
-  return res;
+  return IOResult(res, 0);
 }
 
 }  // namespace net