[FileAPI] Remove Flush() on write completion on SandboxFileSystems

webkit/browser/fileapi/file_writer_delegate.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/browser/fileapi/file_writer_delegate.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util_proxy.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/net_errors.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 namespace fileapi {
 
 static const int kReadBufSize = 32768;
 
 FileWriterDelegate::FileWriterDelegate(
-    scoped_ptr<FileStreamWriter> file_stream_writer)
+    scoped_ptr<FileStreamWriter> file_stream_writer,
+    FlushPolicy flush_policy)
     : file_stream_writer_(file_stream_writer.Pass()),
       writing_started_(false),
+      flush_policy_(flush_policy),
       bytes_written_backlog_(0),
       bytes_written_(0),
       bytes_read_(0),
       io_buffer_(new net::IOBufferWithSize(kReadBufSize)),
       weak_factory_(this) {
 }
 
 FileWriterDelegate::~FileWriterDelegate() {
 }
 
@@ skipping 131 matching lines @@
   return writing_started_ ? ERROR_WRITE_STARTED : ERROR_WRITE_NOT_STARTED;
 }
 
 void FileWriterDelegate::OnError(base::File::Error error) {
   if (request_) {
     request_->set_delegate(NULL);
     request_->Cancel();
   }
 
   if (writing_started_)
-    FlushForCompletion(error, 0, ERROR_WRITE_STARTED);
+    MaybeFlushForCompletion(error, 0, ERROR_WRITE_STARTED);
   else
     write_callback_.Run(error, 0, ERROR_WRITE_NOT_STARTED);
 }
 
 void FileWriterDelegate::OnProgress(int bytes_written, bool done) {
   DCHECK(bytes_written + bytes_written_backlog_ >= bytes_written_backlog_);
   static const int kMinProgressDelayMS = 200;
   base::Time currentTime = base::Time::Now();
   if (done || last_progress_event_time_.is_null() ||
       (currentTime - last_progress_event_time_).InMilliseconds() >
           kMinProgressDelayMS) {
     bytes_written += bytes_written_backlog_;
     last_progress_event_time_ = currentTime;
     bytes_written_backlog_ = 0;
 
     if (done) {
-      FlushForCompletion(base::File::FILE_OK, bytes_written,
-                         SUCCESS_COMPLETED);
+      MaybeFlushForCompletion(base::File::FILE_OK, bytes_written,
+                              SUCCESS_COMPLETED);
     } else {
       write_callback_.Run(base::File::FILE_OK, bytes_written,
                           SUCCESS_IO_PENDING);
     }
     return;
   }
   bytes_written_backlog_ += bytes_written;
 }
 
 void FileWriterDelegate::OnWriteCancelled(int status) {
   write_callback_.Run(base::File::FILE_ERROR_ABORT, 0,
                       GetCompletionStatusOnError());
 }
 
-void FileWriterDelegate::FlushForCompletion(
+void FileWriterDelegate::MaybeFlushForCompletion(
     base::File::Error error,
     int bytes_written,
     WriteProgressStatus progress_status) {
+  if (flush_policy_ == NO_FLUSH_ON_COMPLETION) {
+    write_callback_.Run(error, bytes_written, progress_status);
+    return;
+  }
+  DCHECK_EQ(FLUSH_ON_COMPLETION, flush_policy_);
+
   int flush_error = file_stream_writer_->Flush(
       base::Bind(&FileWriterDelegate::OnFlushed, weak_factory_.GetWeakPtr(),
                  error, bytes_written, progress_status));
   if (flush_error != net::ERR_IO_PENDING)
     OnFlushed(error, bytes_written, progress_status, flush_error);
 }
 
 void FileWriterDelegate::OnFlushed(base::File::Error error,
                                    int bytes_written,
                                    WriteProgressStatus progress_status,
                                    int flush_error) {
   if (error == base::File::FILE_OK && flush_error != net::OK) {
     // If the Flush introduced an error, overwrite the status.
     // Otherwise, keep the original error status.
     error = NetErrorToFileError(flush_error);
     progress_status = GetCompletionStatusOnError();
   }
   write_callback_.Run(error, bytes_written, progress_status);
 }
 
 }  // namespace fileapi