Modify test case to support streaming operation in sandbox file system.

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_observers.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 storage {
 
@@ skipping 336 matching lines @@
 const int kMinProgressCallbackInvocationSpanInMilliseconds = 50;
 
 // Specifically for cross file system copy/move operation, this class uses
 // stream reader and writer for copying. Validator is not supported, so if
 // necessary SnapshotCopyOrMoveImpl should be used.
 class StreamCopyOrMoveImpl
     : public CopyOrMoveOperationDelegate::CopyOrMoveImpl {
  public:
   StreamCopyOrMoveImpl(
       FileSystemOperationRunner* operation_runner,
+      FileSystemContext* file_system_context,
       CopyOrMoveOperationDelegate::OperationType operation_type,
       const FileSystemURL& src_url,
       const FileSystemURL& dest_url,
       CopyOrMoveOperationDelegate::CopyOrMoveOption option,
       scoped_ptr<storage::FileStreamReader> reader,
       scoped_ptr<FileStreamWriter> writer,
       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),
         reader_(reader.Pass()),
         writer_(writer.Pass()),
         file_progress_callback_(file_progress_callback),
         cancel_requested_(false),
         weak_factory_(this) {}
 
   virtual void Run(
       const CopyOrMoveOperationDelegate::StatusCallback& callback) OVERRIDE {
     // Reader can be created even if the entry does not exist or the entry is
     // a directory. To check errors before destination file creation,
     // check metadata first.
     operation_runner_->GetMetadata(
         src_url_,
         base::Bind(&StreamCopyOrMoveImpl::RunAfterGetMetadataForSource,
                    weak_factory_.GetWeakPtr(), callback));
   }
 
   virtual void Cancel() OVERRIDE {
     cancel_requested_ = true;
     if (copy_helper_)
       copy_helper_->Cancel();
   }
 
  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 NotifyOnModifyFile(const FileSystemURL& url) {
+    if (file_system_context_->GetChangeObservers(url.type())) {
+      file_system_context_->GetChangeObservers(url.type())
+          ->Notify(&FileChangeObserver::OnModifyFile, 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));
+    }
+  }
+
   void RunAfterGetMetadataForSource(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       base::File::Error error,
       const base::File::Info& file_info) {
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
@@ skipping 14 matching lines @@
                    callback,
                    file_info.last_modified));
   }
 
   void RunAfterCreateFileForDestination(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       const base::Time& last_modified,
       base::File::Error error) {
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
+    // This conversion it to avoid redundant creation and deletion and

[tzik, 2014/09/04 06:05:23]

s/it/is/?
Plus, the extra creation/deletion is the bug that is fixed by this CL.
So that part of comment doesn't help the reader to understand the behavior.

Could you remove "to avoid" part?

[iseki, 2014/09/04 06:09:09]

Done.

+    // return the consistent status code with FileSystemFileUtil::Copy.
+    if (error == base::File::FILE_ERROR_NOT_A_FILE)
+      error = base::File::FILE_ERROR_INVALID_OPERATION;
 
     if (error != base::File::FILE_OK &&
         error != base::File::FILE_ERROR_EXISTS) {
       callback.Run(error);
       return;
     }
 
     if (error == base::File::FILE_ERROR_EXISTS) {
       operation_runner_->Truncate(
           dest_url_,
@@ skipping 16 matching lines @@
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     const bool need_flush = dest_url_.mount_option().copy_sync_option() ==
                             storage::COPY_SYNC_OPTION_SYNC;
 
+    NotifyOnStartUpdate(dest_url_);
     DCHECK(!copy_helper_);
     copy_helper_.reset(
         new CopyOrMoveOperationDelegate::StreamCopyHelper(
             reader_.Pass(), writer_.Pass(),
             need_flush,
             kReadBufferSize,
             file_progress_callback_,
             base::TimeDelta::FromMilliseconds(
                 kMinProgressCallbackInvocationSpanInMilliseconds)));
     copy_helper_->Run(
         base::Bind(&StreamCopyOrMoveImpl::RunAfterStreamCopy,
                    weak_factory_.GetWeakPtr(), callback, last_modified));
   }
 
   void RunAfterStreamCopy(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       const base::Time& last_modified,
       base::File::Error error) {
+    NotifyOnModifyFile(dest_url_);
+    NotifyOnEndUpdate(dest_url_);
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     if (option_ == FileSystemOperation::OPTION_NONE) {
       RunAfterTouchFile(callback, base::File::FILE_OK);
@@ skipping 33 matching lines @@
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       base::File::Error error) {
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
     if (error == base::File::FILE_ERROR_NOT_FOUND)
       error = base::File::FILE_OK;
     callback.Run(error);
   }
 
   FileSystemOperationRunner* operation_runner_;
+  scoped_refptr<FileSystemContext> file_system_context_;
   CopyOrMoveOperationDelegate::OperationType operation_type_;
   FileSystemURL src_url_;
   FileSystemURL dest_url_;
   CopyOrMoveOperationDelegate::CopyOrMoveOption option_;
   scoped_ptr<storage::FileStreamReader> reader_;
   scoped_ptr<FileStreamWriter> writer_;
   FileSystemOperation::CopyFileProgressCallback file_progress_callback_;
   scoped_ptr<CopyOrMoveOperationDelegate::StreamCopyHelper> copy_helper_;
   bool cancel_requested_;
   base::WeakPtrFactory<StreamCopyOrMoveImpl> weak_factory_;
@@ skipping 227 matching lines @@
     }
 
     if (!validator_factory) {
       scoped_ptr<storage::FileStreamReader> reader =
           file_system_context()->CreateFileStreamReader(
               src_url, 0, base::Time());
       scoped_ptr<FileStreamWriter> writer =
           file_system_context()->CreateFileStreamWriter(dest_url, 0);
       if (reader && writer) {
         impl = new StreamCopyOrMoveImpl(
-            operation_runner(), operation_type_, src_url, dest_url, option_,
-            reader.Pass(), writer.Pass(),
+            operation_runner(),
+            file_system_context(),
+            operation_type_,
+            src_url,
+            dest_url,
+            option_,
+            reader.Pass(),
+            writer.Pass(),
             base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
-                       weak_factory_.GetWeakPtr(), src_url));
+                       weak_factory_.GetWeakPtr(),
+                       src_url));
       }
     }
 
     if (!impl) {
       impl = new SnapshotCopyOrMoveImpl(
           operation_runner(), operation_type_, src_url, dest_url, option_,
           validator_factory,
           base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
                      weak_factory_.GetWeakPtr(), src_url));
     }
@@ skipping 178 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