net: FileStream cleanup

net/base/file_stream_context.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 "base/files/file_path.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/task_runner.h"
@@ skipping 60 matching lines @@
 // ---------------------------------------------------------------------
 
 void FileStream::Context::Orphan() {
   DCHECK(!orphaned_);
 
   orphaned_ = true;
 
   if (!async_in_progress_) {
     CloseAndDelete();
   } else if (file_.IsValid()) {
+#if defined(OS_WIN)
     CancelIo(file_.GetPlatformFile());
+#endif
   }
 }
 
-void FileStream::Context::OpenAsync(const base::FilePath& path,
-                                    int open_flags,
-                                    const CompletionCallback& callback) {
+void FileStream::Context::Open(const base::FilePath& path,
+                               int open_flags,
+                               const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   bool posted = base::PostTaskAndReplyWithResult(
       task_runner_.get(),
       FROM_HERE,
       base::Bind(
           &Context::OpenFileImpl, base::Unretained(this), path, open_flags),
       base::Bind(&Context::OnOpenCompleted, base::Unretained(this), callback));
   DCHECK(posted);
 
   async_in_progress_ = true;
 }
 
-void FileStream::Context::CloseAsync(const CompletionCallback& callback) {
+void FileStream::Context::Close(const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
   bool posted = base::PostTaskAndReplyWithResult(
       task_runner_.get(),
       FROM_HERE,
       base::Bind(&Context::CloseFileImpl, base::Unretained(this)),
       base::Bind(&Context::OnAsyncCompleted,
                  base::Unretained(this),
                  IntToInt64(callback)));
   DCHECK(posted);
 
   async_in_progress_ = true;
 }
 
-void FileStream::Context::SeekAsync(Whence whence,
-                                    int64 offset,
-                                    const Int64CompletionCallback& callback) {
+void FileStream::Context::Seek(base::File::Whence whence,
+                               int64 offset,
+                               const Int64CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   bool posted = base::PostTaskAndReplyWithResult(
       task_runner_.get(),
       FROM_HERE,
       base::Bind(
           &Context::SeekFileImpl, base::Unretained(this), whence, offset),
       base::Bind(&Context::OnAsyncCompleted,
                  base::Unretained(this),
                  callback));
   DCHECK(posted);
 
   async_in_progress_ = true;
 }
 
-void FileStream::Context::FlushAsync(const CompletionCallback& callback) {
+void FileStream::Context::Flush(const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   bool posted = base::PostTaskAndReplyWithResult(
       task_runner_.get(),
       FROM_HERE,
       base::Bind(&Context::FlushFileImpl, base::Unretained(this)),
       base::Bind(&Context::OnAsyncCompleted,
                  base::Unretained(this),
                  IntToInt64(callback)));
   DCHECK(posted);
@@ skipping 21 matching lines @@
     // users wanting to delete the file right after FileStream deletion. Thus
     // we are always adding SHARE_DELETE flag to accommodate such use case.
     // TODO(rvargas): This sounds like a bug, as deleting the file would
     // presumably happen on the wrong thread. There should be an async delete.
     open_flags |= base::File::FLAG_SHARE_DELETE;
     file.Initialize(path, open_flags);
 #if defined(OS_ANDROID)
   }
 #endif  // defined(OS_ANDROID)
   if (!file.IsValid())
-    return OpenResult(base::File(), IOResult::FromOSError(GetLastErrno()));
+    return OpenResult(base::File(),
+                      IOResult::FromOSError(logging::GetLastSystemErrorCode()));
 
   return OpenResult(file.Pass(), IOResult(OK, 0));
 }
 
 FileStream::Context::IOResult FileStream::Context::CloseFileImpl() {
   file_.Close();
   return IOResult(OK, 0);
 }
 
+FileStream::Context::IOResult FileStream::Context::FlushFileImpl() {
+  if (file_.Flush())
+    return IOResult(OK, 0);
+
+  return IOResult::FromOSError(logging::GetLastSystemErrorCode());
+}
+
 void FileStream::Context::OnOpenCompleted(const CompletionCallback& callback,
                                           OpenResult open_result) {
   file_ = open_result.file.Pass();
   if (file_.IsValid() && !orphaned_)
-    OnAsyncFileOpened();
+    OnFileOpened();
 
   OnAsyncCompleted(IntToInt64(callback), open_result.error_code);
 }
 
 void FileStream::Context::CloseAndDelete() {
   DCHECK(!async_in_progress_);
 
   if (file_.IsValid()) {
     bool posted = task_runner_.get()->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&Context::CloseFileImpl),
                    base::Owned(this)));
     DCHECK(posted);
   } else {
     delete this;
   }
 }
 
 Int64CompletionCallback FileStream::Context::IntToInt64(
     const CompletionCallback& callback) {
   return base::Bind(&CallInt64ToInt, callback);
 }
 
 void FileStream::Context::OnAsyncCompleted(
     const Int64CompletionCallback& callback,
     const IOResult& result) {
   // Reset this before Run() as Run() may issue a new async operation. Also it
-  // should be reset before CloseAsync() because it shouldn't run if any async
+  // should be reset before Close() because it shouldn't run if any async
   // operation is in progress.
   async_in_progress_ = false;
   if (orphaned_)
     CloseAndDelete();
   else
     callback.Run(result.result);
 }
 
 }  // namespace net