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

webkit/fileapi/local_file_stream_writer.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 "webkit/fileapi/local_file_stream_writer.h"
 
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
@@ skipping 46 matching lines @@
 
 int LocalFileStreamWriter::Cancel(const net::CompletionCallback& callback) {
   if (!has_pending_operation_)
     return net::ERR_UNEXPECTED;
 
   DCHECK(!callback.is_null());
   cancel_callback_ = callback;
   return net::ERR_IO_PENDING;
 }
 
+int LocalFileStreamWriter::Flush(const net::CompletionCallback& callback) {
+  DCHECK(!has_pending_operation_);
+  DCHECK(cancel_callback_.is_null());
+
+  // Write() is not called yet, so there's nothing to flush.
+  if (!stream_impl_.get())
+    return net::OK;
+
+  has_pending_operation_ = true;
+  int result = InitiateFlush(callback);
+  if (result != net::ERR_IO_PENDING)
+    has_pending_operation_ = false;
+  return result;
+}
+
 int LocalFileStreamWriter::InitiateOpen(
     const net::CompletionCallback& error_callback,
     const base::Closure& main_operation) {
   DCHECK(has_pending_operation_);
   DCHECK(!stream_impl_.get());
 
   stream_impl_.reset(new net::FileStream(NULL));
   return stream_impl_->Open(file_path_,
                             kOpenFlagsForWrite,
                             base::Bind(&LocalFileStreamWriter::DidOpen,
@@ skipping 95 matching lines @@
 void LocalFileStreamWriter::DidWrite(const net::CompletionCallback& callback,
                                      int result) {
   DCHECK(has_pending_operation_);
 
   if (CancelIfRequested())
     return;
   has_pending_operation_ = false;
   callback.Run(result);
 }
 
+int LocalFileStreamWriter::InitiateFlush(
+    const net::CompletionCallback& callback) {
+  DCHECK(has_pending_operation_);
+  DCHECK(stream_impl_.get());
+
+  return stream_impl_->Flush(base::Bind(&LocalFileStreamWriter::DidFlush,
+                                        weak_factory_.GetWeakPtr(),
+                                        callback));
+}
+
+void LocalFileStreamWriter::DidFlush(const net::CompletionCallback& callback,
+                                     int result) {
+  DCHECK(has_pending_operation_);
+
+  if (CancelIfRequested())
+    return;
+  has_pending_operation_ = false;
+  callback.Run(result);
+}
+
 bool LocalFileStreamWriter::CancelIfRequested() {
   DCHECK(has_pending_operation_);
 
   if (cancel_callback_.is_null())
     return false;
 
   net::CompletionCallback pending_cancel = cancel_callback_;
   has_pending_operation_ = false;
   cancel_callback_.Reset();
   pending_cancel.Run(net::OK);
   return true;
 }
 
 }  // namespace fileapi