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

net/base/file_stream_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.h"
 
 #include <sys/types.h>
@@ skipping 213 matching lines @@
               const net::BoundNetLog& bound_net_log) {
   base::ThreadRestrictions::AssertIOAllowed();
   ssize_t res = HANDLE_EINTR(fsync(file));
   if (res == -1) {
     res = RecordAndMapError(errno, FILE_ERROR_SOURCE_FLUSH, record_uma,
                             bound_net_log);
   }
   return res;
 }
 
+// Flushes a file using FlushFile() and signals the completion.
+void FlushFileAndSignal(base::PlatformFile file,
+                        int* result,
+                        bool record_uma,
+                        base::WaitableEvent* on_io_complete,
+                        const net::BoundNetLog& bound_net_log) {
+  *result = FlushFile(file, record_uma, bound_net_log);
+  on_io_complete->Signal();
+}
+
 // Called when Read(), Write() or Seek() is completed.
 // |result| contains the result or a network error code.
 template <typename R>
 void OnIOComplete(const base::WeakPtr<FileStreamPosix>& stream,
                   const base::Callback<void(R)>& callback,
                   R* result) {
   if (!stream.get())
     return;
 
   // Reset this before Run() as Run() may issue a new async operation.
@@ skipping 337 matching lines @@
   int result = ftruncate(file_, bytes);
   if (result == 0)
     return seek_position;
 
   return RecordAndMapError(errno,
                            FILE_ERROR_SOURCE_SET_EOF,
                            record_uma_,
                            bound_net_log_);
 }
 
-int FileStreamPosix::Flush() {
+int FileStreamPosix::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(!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(&FlushFileAndSignal, file_, result,
+                 record_uma_, on_io_complete_.get(), bound_net_log_),
+      base::Bind(&OnIOComplete<int>,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback, base::Owned(result)),
+      true /* task is slow */);
+  DCHECK(posted);
+  return ERR_IO_PENDING;
+}
+
+int FileStreamPosix::FlushSync() {
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   return FlushFile(file_, record_uma_, bound_net_log_);
 }
 
 void FileStreamPosix::EnableErrorStatistics() {
   record_uma_ = true;
 }
 
@@ skipping 37 matching lines @@
 void FileStreamPosix::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