Cosmetic change for disk flush interval in Files.app file copying.

webkit/browser/fileapi/copy_or_move_operation_delegate.cc

 // Copyright (c) 2013 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/copy_or_move_operation_delegate.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/recursive_operation_delegate.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 namespace fileapi {
 
+const int64 kFlushIntervalInBytes = 10 << 20;  // 10MB.
+
 class CopyOrMoveOperationDelegate::CopyOrMoveImpl {
  public:
   virtual ~CopyOrMoveImpl() {}
   virtual void Run(
       const CopyOrMoveOperationDelegate::StatusCallback& callback) = 0;
   virtual void Cancel() = 0;
 
  protected:
   CopyOrMoveImpl() {}
 
@@ skipping 503 matching lines @@
     int buffer_size,
     const FileSystemOperation::CopyFileProgressCallback&
         file_progress_callback,
     const base::TimeDelta& min_progress_callback_invocation_span)
     : reader_(reader.Pass()),
       writer_(writer.Pass()),
       need_flush_(need_flush),
       file_progress_callback_(file_progress_callback),
       io_buffer_(new net::IOBufferWithSize(buffer_size)),
       num_copied_bytes_(0),
+      previous_flush_(0),
       min_progress_callback_invocation_span_(
           min_progress_callback_invocation_span),
       cancel_requested_(false),
       weak_factory_(this) {
 }
 
 CopyOrMoveOperationDelegate::StreamCopyHelper::~StreamCopyHelper() {
 }
 
 void CopyOrMoveOperationDelegate::StreamCopyHelper::Run(
@@ skipping 25 matching lines @@
   }
 
   if (result < 0) {
     callback.Run(NetErrorToPlatformFileError(result));
     return;
   }
 
   if (result == 0) {
     // Here is the EOF.
     if (need_flush_)
-      Flush(callback);
+      Flush(callback, true /* is_eof */);
     else
       callback.Run(base::PLATFORM_FILE_OK);
     return;
   }
 
   Write(callback, new net::DrainableIOBuffer(io_buffer_.get(), result));
 }
 
 void CopyOrMoveOperationDelegate::StreamCopyHelper::Write(
     const StatusCallback& callback,
@@ skipping 31 matching lines @@
       min_progress_callback_invocation_span_) {
     file_progress_callback_.Run(num_copied_bytes_);
     last_progress_callback_invocation_time_ = now;
   }
 
   if (buffer->BytesRemaining() > 0) {
     Write(callback, buffer);
     return;
   }
 
-  Read(callback);
+  if (need_flush_ &&
+      (num_copied_bytes_ - previous_flush_) > kFlushIntervalInBytes) {
+    Flush(callback, false /* not is_eof */);
+  } else {
+    Read(callback);
+  }
 }
 
 void CopyOrMoveOperationDelegate::StreamCopyHelper::Flush(
-    const StatusCallback& callback) {
+    const StatusCallback& callback, bool is_eof) {
   int result = writer_->Flush(
       base::Bind(&StreamCopyHelper::DidFlush,
-                 weak_factory_.GetWeakPtr(), callback));
+                 weak_factory_.GetWeakPtr(), callback, is_eof));
   if (result != net::ERR_IO_PENDING)
-    DidFlush(callback, result);
+    DidFlush(callback, is_eof, result);
 }
 
 void CopyOrMoveOperationDelegate::StreamCopyHelper::DidFlush(
-    const StatusCallback& callback,
-    int result) {
+    const StatusCallback& callback, bool is_eof, int result) {
   if (cancel_requested_) {
     callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
     return;
   }
 
-  callback.Run(NetErrorToPlatformFileError(result));
+  previous_flush_ = num_copied_bytes_;
+  if (is_eof)
+    callback.Run(NetErrorToPlatformFileError(result));
+  else
+    Read(callback);
 }
 
 CopyOrMoveOperationDelegate::CopyOrMoveOperationDelegate(
     FileSystemContext* file_system_context,
     const FileSystemURL& src_root,
     const FileSystemURL& dest_root,
     OperationType operation_type,
     CopyOrMoveOption option,
     const CopyProgressCallback& progress_callback,
     const StatusCallback& callback)
@@ skipping 268 matching lines @@
   base::FilePath relative = dest_root_.virtual_path();
   src_root_.virtual_path().AppendRelativePath(src_url.virtual_path(),
                                               &relative);
   return file_system_context()->CreateCrackedFileSystemURL(
       dest_root_.origin(),
       dest_root_.mount_type(),
       relative);
 }
 
 }  // namespace fileapi