Send OnModifyFile Notification when File Write Finishes

webkit/fileapi/local_file_system_operation.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_system_operation.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 296 matching lines @@
   if (!writer.get()) {
     // Write is not supported.
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, 0, false);
     delete this;
     return;
   }
 
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(
       base::Bind(&LocalFileSystemOperation::DidWrite,
-                 weak_factory_.GetWeakPtr()),
+                 weak_factory_.GetWeakPtr(), url),
       writer.Pass()));
 
   set_write_callback(callback);
   scoped_ptr<net::URLRequest> blob_request(url_request_context->CreateRequest(
       blob_url, file_writer_delegate_.get()));
 
   file_writer_delegate_->Start(blob_request.Pass());
 }
 
 void LocalFileSystemOperation::Truncate(const FileSystemURL& url, int64 length,
@@ skipping 342 matching lines @@
 
 void LocalFileSystemOperation::DidReadDirectory(
     const ReadDirectoryCallback& callback,
     base::PlatformFileError rv,
     const std::vector<base::FileUtilProxy::Entry>& entries,
     bool has_more) {
   callback.Run(rv, entries, has_more);
 }
 
 void LocalFileSystemOperation::DidWrite(
+    const FileSystemURL& url,
     base::PlatformFileError rv,
     int64 bytes,
     bool complete) {
   if (write_callback_.is_null()) {
     // If cancelled, callback is already invoked and set to null in Cancel().
     // We must not call it twice. Just shut down this operation object.
     delete this;
     return;
   }
+
+  if (complete) {
+    operation_context_->change_observers()->Notify(
+        &FileChangeObserver::OnModifyFile, MakeTuple(url));

[kinuko, 2012/09/25 04:12:26]

On the second thought (and on the contrary to what I said), can we try not to
fire ModifyFile when we failed before starting to write anything?

I think we can keep a writing status in WriterDelegate, not necessarily as a
total_bytes_writtenbn format but may be a boolean or an enum status flag (we
generally prefer enum than boolean) which could be either
WRITER_DELEGATE_STATE_INIT or WRITING.

To propagate the delegate's status we could add another parameter to
WriterDelegate::DidWrite but just passing a special value (i.e -1) would also
work.

+  }
+
   write_callback_.Run(rv, bytes, complete);
   if (complete || rv != base::PLATFORM_FILE_OK)
     delete this;
 }
 
 void LocalFileSystemOperation::DidTouchFile(const StatusCallback& callback,
                                             base::PlatformFileError rv) {
   callback.Run(rv);
 }
 
@@ skipping 69 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi