net: Update FileStream to use base::File instead of PlatformFile.

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 28 matching lines @@
 // We cast back and forth, so make sure it's the size we're expecting.
 COMPILE_ASSERT(sizeof(int64) == sizeof(off_t), off_t_64_bit);
 
 // Make sure our Whence mappings match the system headers.
 COMPILE_ASSERT(FROM_BEGIN   == SEEK_SET &&
                FROM_CURRENT == SEEK_CUR &&
                FROM_END     == SEEK_END, whence_matches_system);
 
 FileStream::Context::Context(const BoundNetLog& bound_net_log,
                              const scoped_refptr<base::TaskRunner>& task_runner)
-    : file_(base::kInvalidPlatformFileValue),
-      record_uma_(false),
+    : record_uma_(false),
       async_in_progress_(false),
       orphaned_(false),
+      async_(false),
       bound_net_log_(bound_net_log),
       task_runner_(task_runner) {
 }
 
-FileStream::Context::Context(base::PlatformFile file,
+FileStream::Context::Context(base::File file,
                              const BoundNetLog& bound_net_log,
-                             int /* open_flags */,
                              const scoped_refptr<base::TaskRunner>& task_runner)
-    : file_(file),
+    : file_(file.Pass()),
       record_uma_(false),
       async_in_progress_(false),
       orphaned_(false),
+      async_(false),
       bound_net_log_(bound_net_log),
       task_runner_(task_runner) {
 }
+
+FileStream::Context::Context(base::File file,
+                             int flags,
+                             const BoundNetLog& bound_net_log,
+                             const scoped_refptr<base::TaskRunner>& task_runner)
+    : file_(file.Pass()),
+      record_uma_(false),
+      async_in_progress_(false),
+      orphaned_(false),
+      async_((flags & base::File::FLAG_ASYNC) == base::File::FLAG_ASYNC),
+      bound_net_log_(bound_net_log),
+      task_runner_(task_runner) {
+}
 
 FileStream::Context::~Context() {
 }
 
 int64 FileStream::Context::GetFileSize() const {
   struct stat info;
-  if (fstat(file_, &info) != 0) {
+  if (fstat(file_.GetPlatformFile(), &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,
@@ skipping 43 matching lines @@
 }
 
 int FileStream::Context::WriteSync(const char* in_buf, int buf_len) {
   scoped_refptr<IOBuffer> buf = new WrappedIOBuffer(in_buf);
   IOResult result = WriteFileImpl(buf, buf_len);
   RecordError(result, FILE_ERROR_SOURCE_WRITE);
   return result.result;
 }
 
 int FileStream::Context::Truncate(int64 bytes) {
-  if (ftruncate(file_, bytes) != 0) {
+  if (ftruncate(file_.GetPlatformFile(), bytes) != 0) {
     IOResult result = IOResult::FromOSError(errno);
     RecordError(result, FILE_ERROR_SOURCE_SET_EOF);
     return result.result;
   }
 
   return bytes;
 }
 
 FileStream::Context::IOResult FileStream::Context::SeekFileImpl(Whence whence,
                                                                 int64 offset) {
-  off_t res = lseek(file_, static_cast<off_t>(offset),
+  off_t res = lseek(file_.GetPlatformFile(), static_cast<off_t>(offset),
                     static_cast<int>(whence));
   if (res == static_cast<off_t>(-1))
     return IOResult::FromOSError(errno);
 
   return IOResult(res, 0);
 }
 
 FileStream::Context::IOResult FileStream::Context::FlushFileImpl() {
-  ssize_t res = HANDLE_EINTR(fsync(file_));
+  ssize_t res = HANDLE_EINTR(fsync(file_.GetPlatformFile()));
   if (res == -1)
     return IOResult::FromOSError(errno);
 
   return IOResult(res, 0);
 }
 
 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(),
+  ssize_t res = HANDLE_EINTR(read(file_.GetPlatformFile(), buf->data(),
                                   static_cast<size_t>(buf_len)));
   if (res == -1)
     return IOResult::FromOSError(errno);
 
   return IOResult(res, 0);
 }
 
 FileStream::Context::IOResult FileStream::Context::WriteFileImpl(
     scoped_refptr<IOBuffer> buf,
     int buf_len) {
-  ssize_t res = HANDLE_EINTR(write(file_, buf->data(), buf_len));
+  ssize_t res = HANDLE_EINTR(write(file_.GetPlatformFile(), buf->data(),
+                                   buf_len));
   if (res == -1)
     return IOResult::FromOSError(errno);
 
   return IOResult(res, 0);
 }
 
-FileStream::Context::IOResult FileStream::Context::CloseFileImpl() {
-  bool success = base::ClosePlatformFile(file_);
-  file_ = base::kInvalidPlatformFileValue;
-  if (!success)
-    return IOResult::FromOSError(errno);
-
-  return IOResult(OK, 0);
-}
-
 }  // namespace net