Merge 159454 - Flush at the end of local file writing in FileWriter API.

net/base/file_stream_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.h"
 
 #include <windows.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
@@ skipping 569 matching lines @@
     rv = RecordAndMapError(error,
                            FILE_ERROR_SOURCE_WRITE,
                            record_uma_,
                            bound_net_log_);
   } else {
     rv = static_cast<int>(bytes_written);
   }
   return rv;
 }
 
-int FileStreamWin::Flush() {
+int FileStreamWin::Flush(const CompletionCallback& callback) {
+  if (!IsOpen())
+    return ERR_UNEXPECTED;
+
+  // Make sure we're async and we have no other in-flight async operations.
+  DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
+  DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
+  DCHECK(!weak_ptr_factory_.HasWeakPtrs());
+  DCHECK(!on_io_complete_.get());
+
+  on_io_complete_.reset(new base::WaitableEvent(
+      false  /* manual_reset */, false  /* initially_signaled */));
+
+  int* result = new int(OK);
+  const bool posted = base::WorkerPool::PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&InvokeAndSignal,
+                 // Unretained should be fine as we wait for a signal on
+                 // on_io_complete_ at the destructor.
+                 base::Bind(&FileStreamWin::FlushFile, base::Unretained(this),
+                            result),
+                 on_io_complete_.get()),
+      base::Bind(&FileStreamWin::OnFlushed,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback, base::Owned(result)),
+      true /* task is slow */);
+  DCHECK(posted);
+  return ERR_IO_PENDING;
+}
+
+int FileStreamWin::FlushSync() {
   base::ThreadRestrictions::AssertIOAllowed();
 
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
   if (FlushFileBuffers(file_)) {
     return OK;
   }
 
@@ skipping 84 matching lines @@
                                 bound_net_log_);
     return;
   }
   if (async_context_.get()) {
     async_context_->set_error_source(FILE_ERROR_SOURCE_SEEK);
     SetOffset(async_context_->overlapped(), res);
   }
   *result = res.QuadPart;
 }
 
+void FileStreamWin::FlushFile(int* result) {
+  if (FlushFileBuffers(file_)) {
+    *result = OK;
+  } else {
+    *result = RecordAndMapError(GetLastError(),
+                                FILE_ERROR_SOURCE_FLUSH,
+                                record_uma_,
+                                bound_net_log_);
+  }
+}
+
 void FileStreamWin::OnOpened(const CompletionCallback& callback, int* result) {
   if (*result == OK) {
     async_context_.reset(new AsyncContext(bound_net_log_));
     if (record_uma_)
       async_context_->EnableErrorStatistics();
     MessageLoopForIO::current()->RegisterIOHandler(file_,
                                                    async_context_.get());
   }
 
   // Reset this before Run() as Run() may issue a new async operation.
   ResetOnIOComplete();
   callback.Run(*result);
 }
 
 void FileStreamWin::OnSeeked(
     const Int64CompletionCallback& callback,
     int64* result) {
   // Reset this before Run() as Run() may issue a new async operation.
   ResetOnIOComplete();
   callback.Run(*result);
 }
 
+void FileStreamWin::OnFlushed(const CompletionCallback& callback, int* result) {
+  // Reset this before Run() as Run() may issue a new async operation.
+  ResetOnIOComplete();
+  callback.Run(*result);
+}
+
 void FileStreamWin::ResetOnIOComplete() {
   on_io_complete_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void FileStreamWin::WaitForIOCompletion() {
   // http://crbug.com/115067
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   if (on_io_complete_.get()) {
     on_io_complete_->Wait();
     on_io_complete_.reset();
   }
 }
 
 }  // namespace net