Send OnModifyFile Notification when File Write Finishes

webkit/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/fileapi/file_writer_delegate.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
@@ skipping 20 matching lines @@
     case net::ERR_ACCESS_DENIED:
       return base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
     default:
       return base::PLATFORM_FILE_ERROR_FAILED;
   }
 }
 
 }  // namespace
 
 FileWriterDelegate::FileWriterDelegate(
-    const FileSystemOperation::WriteCallback& write_callback,
+    const DelegateWriteCallback& write_callback,
     scoped_ptr<FileStreamWriter> file_stream_writer)
     : write_callback_(write_callback),
       file_stream_writer_(file_stream_writer.Pass()),
+      writing_started_(false),
       bytes_written_backlog_(0),
       bytes_written_(0),
       bytes_read_(0),
       io_buffer_(new net::IOBufferWithSize(kReadBufSize)),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 FileWriterDelegate::~FileWriterDelegate() {
 }
 
@@ skipping 83 matching lines @@
   } else {
     // This could easily be optimized to rotate between a pool of buffers, so
     // that we could read and write at the same time.  It's not yet clear that
     // it's necessary.
     cursor_ = new net::DrainableIOBuffer(io_buffer_, bytes_read_);
     Write();
   }
 }
 
 void FileWriterDelegate::Write() {
+  writing_started_ = true;
   int64 bytes_to_write = bytes_read_ - bytes_written_;
   int write_response =
       file_stream_writer_->Write(cursor_,
                                  static_cast<int>(bytes_to_write),
                                  base::Bind(&FileWriterDelegate::OnDataWritten,
                                             weak_factory_.GetWeakPtr()));
   if (write_response > 0)
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&FileWriterDelegate::OnDataWritten,
                    weak_factory_.GetWeakPtr(), write_response));
   else if (net::ERR_IO_PENDING != write_response)
     OnError(NetErrorToPlatformFileError(write_response));
 }
 
 void FileWriterDelegate::OnDataWritten(int write_response) {
   if (write_response > 0) {
     OnProgress(write_response, false);
     cursor_->DidConsume(write_response);
     bytes_written_ += write_response;
     if (bytes_written_ == bytes_read_)
       Read();
     else
       Write();
   } else {
     OnError(NetErrorToPlatformFileError(write_response));
   }
 }
 
+FileWriterDelegate::WriteProgressStatus
+FileWriterDelegate::GetCompletionStatusOnError() const {
+  return writing_started_ ? ERROR_WRITE_STARTED : ERROR_WRITE_NOT_STARTED;
+}
+
 void FileWriterDelegate::OnError(base::PlatformFileError error) {
   if (request_.get()) {
     request_->set_delegate(NULL);
     request_->Cancel();
   }
 
-  write_callback_.Run(error, 0, true);
+  write_callback_.Run(error, 0, GetCompletionStatusOnError());
 }
 
 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;
-    write_callback_.Run(
-        base::PLATFORM_FILE_OK, bytes_written, done);
+
+    WriteProgressStatus status = done ? SUCCESS_COMPLETED : SUCCESS_IO_PENDING;
+    write_callback_.Run(base::PLATFORM_FILE_OK, bytes_written, status);
     return;
   }
   bytes_written_backlog_ += bytes_written;
 }
 
 void FileWriterDelegate::OnWriteCancelled(int status) {
-  write_callback_.Run(base::PLATFORM_FILE_ERROR_ABORT, 0, true);
+  write_callback_.Run(base::PLATFORM_FILE_ERROR_ABORT, 0,
+                      GetCompletionStatusOnError());
 }
 
 }  // namespace fileapi