[Blink-FileAPI] Add the notification of update observer.

storage/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 "storage/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"
@@ skipping 28 matching lines @@
 
 namespace {
 
 // Copies a file on a (same) file system. Just delegate the operation to
 // |operation_runner|.
 class CopyOrMoveOnSameFileSystemImpl
     : public CopyOrMoveOperationDelegate::CopyOrMoveImpl {
  public:
   CopyOrMoveOnSameFileSystemImpl(
       FileSystemOperationRunner* operation_runner,
+      FileSystemContext* file_system_context,
       CopyOrMoveOperationDelegate::OperationType operation_type,
       const FileSystemURL& src_url,
       const FileSystemURL& dest_url,
       CopyOrMoveOperationDelegate::CopyOrMoveOption option,
       const FileSystemOperation::CopyFileProgressCallback&
           file_progress_callback)
       : operation_runner_(operation_runner),
+        file_system_context_(file_system_context),
         operation_type_(operation_type),
         src_url_(src_url),
         dest_url_(dest_url),
         option_(option),
-        file_progress_callback_(file_progress_callback) {
-  }
+        file_progress_callback_(file_progress_callback),
+        weak_factory_(this) {}
 
   virtual void Run(
       const CopyOrMoveOperationDelegate::StatusCallback& callback) OVERRIDE {
+    NotifyOnStartUpdate(dest_url_);

[tzik, 2014/09/17 04:10:19]

Since the notification is already sent by FileSystemOperationRunner in
PrepareForWrite, this NotifyOnStartUpdate seem not needed for the top level URL.
Could you revert this?

[tzik, 2014/09/17 05:03:05]

Sorry, I misunderstood the structure.
This notification is needed.

But, since the actual operation is done via FileSystemOperationRunner,
FileSystemOperationRunner::{Move,Copy}FileLocal are better place to put the
notification.

[iseki, 2014/09/17 06:21:45]

Done.

[iseki, 2014/09/17 06:21:45]

Done.

     if (operation_type_ == CopyOrMoveOperationDelegate::OPERATION_MOVE) {
-      operation_runner_->MoveFileLocal(src_url_, dest_url_, option_, callback);
+      NotifyOnStartUpdate(src_url_);
+      operation_runner_->MoveFileLocal(
+          src_url_,
+          dest_url_,
+          option_,
+          base::Bind(&CopyOrMoveOnSameFileSystemImpl::DidCopyOrMove,
+                     weak_factory_.GetWeakPtr(),
+                     callback));
     } else {
       operation_runner_->CopyFileLocal(
-          src_url_, dest_url_, option_, file_progress_callback_, callback);
+          src_url_,
+          dest_url_,
+          option_,
+          file_progress_callback_,
+          base::Bind(&CopyOrMoveOnSameFileSystemImpl::DidCopyOrMove,
+                     weak_factory_.GetWeakPtr(),
+                     callback));
     }
   }
 
+  void DidCopyOrMove(
+      const CopyOrMoveOperationDelegate::StatusCallback& callback,
+      base::File::Error error) {
+    if (operation_type_ == CopyOrMoveOperationDelegate::OPERATION_MOVE) {
+      NotifyOnEndUpdate(src_url_);
+    }
+    NotifyOnEndUpdate(dest_url_);
+    callback.Run(error);
+  }
+
   virtual void Cancel() OVERRIDE {
     // We can do nothing for the copy/move operation on a local file system.
     // Assuming the operation is quickly done, it should be ok to just wait
     // for the completion.
   }
 
  private:
+  void NotifyOnStartUpdate(const FileSystemURL& url) {
+    if (file_system_context_->GetUpdateObservers(url.type())) {
+      file_system_context_->GetUpdateObservers(url.type())
+          ->Notify(&FileUpdateObserver::OnStartUpdate, MakeTuple(url));
+    }
+  }
+
+  void NotifyOnEndUpdate(const FileSystemURL& url) {
+    if (file_system_context_->GetUpdateObservers(url.type())) {
+      file_system_context_->GetUpdateObservers(url.type())
+          ->Notify(&FileUpdateObserver::OnEndUpdate, MakeTuple(url));
+    }
+  }
+
   FileSystemOperationRunner* operation_runner_;
+  scoped_refptr<FileSystemContext> file_system_context_;
   CopyOrMoveOperationDelegate::OperationType operation_type_;
   FileSystemURL src_url_;
   FileSystemURL dest_url_;
   CopyOrMoveOperationDelegate::CopyOrMoveOption option_;
   FileSystemOperation::CopyFileProgressCallback file_progress_callback_;
+  base::WeakPtrFactory<CopyOrMoveOnSameFileSystemImpl> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(CopyOrMoveOnSameFileSystemImpl);
 };
 
 // Specifically for cross file system copy/move operation, this class creates
 // a snapshot file, validates it if necessary, runs copying process,
 // validates the created file, and removes source file for move (noop for
 // copy).
 class SnapshotCopyOrMoveImpl
     : public CopyOrMoveOperationDelegate::CopyOrMoveImpl {
  public:
@@ skipping 698 matching lines @@
   }
 
   FileSystemURL dest_url = CreateDestURL(src_url);
   CopyOrMoveImpl* impl = NULL;
   if (same_file_system_ &&
       (file_system_context()
            ->GetFileSystemBackend(src_url.type())
            ->HasInplaceCopyImplementation(src_url.type()) ||
        operation_type_ == OPERATION_MOVE)) {
     impl = new CopyOrMoveOnSameFileSystemImpl(
-        operation_runner(), operation_type_, src_url, dest_url, option_,
+        operation_runner(),
+        file_system_context(),
+        operation_type_,
+        src_url,
+        dest_url,
+        option_,
         base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
-                   weak_factory_.GetWeakPtr(), src_url));
+                   weak_factory_.GetWeakPtr(),
+                   src_url));
   } else {
     // Cross filesystem case.
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     CopyOrMoveFileValidatorFactory* validator_factory =
         file_system_context()->GetCopyOrMoveFileValidatorFactory(
             dest_root_.type(), &error);
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
@@ skipping 208 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 storage