net: FileStream cleanup

net/base/file_stream_context_win.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.
 
 #include "net/base/file_stream_context.h"
 
 #include <windows.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/task_runner.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;
@@ skipping 16 matching lines @@
 FileStream::Context::Context(base::File file,
                              const scoped_refptr<base::TaskRunner>& task_runner)
     : io_context_(),
       file_(file.Pass()),
       async_in_progress_(false),
       orphaned_(false),
       task_runner_(task_runner) {
   io_context_.handler = this;
   memset(&io_context_.overlapped, 0, sizeof(io_context_.overlapped));
   if (file_.IsValid()) {
     // TODO(hashimoto): Check that file_ is async.

[wtc, 2014/06/19 18:20:49]

Should we remove this TODO comment? It makes more sense with the original code
(OnAsyncFileOpened).

[rvargas (doing something else), 2014/06/19 18:46:43]

I thought about it, but this is really related to what flags were used to create
the file that we are receiving, and not to the presence of a synchronous
implementation in this class.

I think users are still divided, with some of them adding FLAG_ASYNC only for
Windows and others for any platform.

-    OnAsyncFileOpened();
+    OnFileOpened();
   }
 }
 
 FileStream::Context::~Context() {
 }
 
-int FileStream::Context::ReadAsync(IOBuffer* buf,
-                                   int buf_len,
-                                   const CompletionCallback& callback) {
+int FileStream::Context::Read(IOBuffer* buf,
+                              int buf_len,
+                              const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   DWORD bytes_read;
   if (!ReadFile(file_.GetPlatformFile(), buf->data(), buf_len,
                 &bytes_read, &io_context_.overlapped)) {
     IOResult error = IOResult::FromOSError(GetLastError());
     if (error.os_error == ERROR_IO_PENDING) {
       IOCompletionIsPending(callback, buf);
     } else if (error.os_error == ERROR_HANDLE_EOF) {
       return 0;  // Report EOF by returning 0 bytes read.
     } else {
       LOG(WARNING) << "ReadFile failed: " << error.os_error;
     }
     return error.result;
   }
 
   IOCompletionIsPending(callback, buf);
   return ERR_IO_PENDING;
 }
 
-int FileStream::Context::WriteAsync(IOBuffer* buf,
-                                    int buf_len,
-                                    const CompletionCallback& callback) {
+int FileStream::Context::Write(IOBuffer* buf,
+                               int buf_len,
+                               const CompletionCallback& callback) {
   DWORD bytes_written = 0;
   if (!WriteFile(file_.GetPlatformFile(), buf->data(), buf_len,
                  &bytes_written, &io_context_.overlapped)) {
     IOResult error = IOResult::FromOSError(GetLastError());
     if (error.os_error == ERROR_IO_PENDING) {
       IOCompletionIsPending(callback, buf);
     } else {
       LOG(WARNING) << "WriteFile failed: " << error.os_error;
     }
     return error.result;
   }
 
   IOCompletionIsPending(callback, buf);
   return ERR_IO_PENDING;
 }
 
-void FileStream::Context::OnAsyncFileOpened() {
-  base::MessageLoopForIO::current()->RegisterIOHandler(file_.GetPlatformFile(),
-                                                       this);
-}
-
-FileStream::Context::IOResult FileStream::Context::SeekFileImpl(Whence whence,
-                                                                int64 offset) {
-  LARGE_INTEGER distance, res;
-  distance.QuadPart = offset;
-  DWORD move_method = static_cast<DWORD>(whence);
-  if (SetFilePointerEx(file_.GetPlatformFile(), distance, &res, move_method)) {
-    SetOffset(&io_context_.overlapped, res);
-    return IOResult(res.QuadPart, 0);
+FileStream::Context::IOResult FileStream::Context::SeekFileImpl(
+    base::File::Whence whence,
+    int64 offset) {
+  LARGE_INTEGER result;
+  result.QuadPart = file_.Seek(whence, offset);
+  if (result.QuadPart >= 0) {
+    SetOffset(&io_context_.overlapped, result);
+    return IOResult(result.QuadPart, 0);
   }
 
   return IOResult::FromOSError(GetLastError());
 }
 
-FileStream::Context::IOResult FileStream::Context::FlushFileImpl() {
-  if (FlushFileBuffers(file_.GetPlatformFile()))
-    return IOResult(OK, 0);
-
-  return IOResult::FromOSError(GetLastError());
+void FileStream::Context::OnFileOpened() {
+  base::MessageLoopForIO::current()->RegisterIOHandler(file_.GetPlatformFile(),
+                                                       this);
 }
 
 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;
 }
@@ skipping 26 matching lines @@
   }
 
   CompletionCallback temp_callback = callback_;
   callback_.Reset();
   scoped_refptr<IOBuffer> temp_buf = in_flight_buf_;
   in_flight_buf_ = NULL;
   temp_callback.Run(result);
 }
 
 }  // namespace net