Add fileManagerPrivate.onCopyError event.

content/browser/fileapi/recursive_operation_delegate_unittest.cc

 // Copyright 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/recursive_operation_delegate.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 35 matching lines @@
         root_(root),
         callback_(callback),
         weak_factory_(this) {}
   ~LoggingRecursiveOperation() override {}
 
   const std::vector<LogEntry>& log_entries() const { return log_entries_; }
 
   // RecursiveOperationDelegate overrides.
   void Run() override { NOTREACHED(); }
 
-  void RunRecursively() override { StartRecursiveOperation(root_, callback_); }
+  void RunRecursively() override {
+    StartRecursiveOperation(
+        root_, storage::FileSystemOperation::ERROR_BEHAVIOR_TERMINATE,
+        callback_);
+  }
 
-  void RunRecursivelyWithIgnoringError(const ErrorCallback& error_callback) {
-    StartRecursiveOperationWithIgnoringError(root_, error_callback, callback_);
+  void RunRecursivelyWithIgnoringError() {
+    StartRecursiveOperation(
+        root_, storage::FileSystemOperation::ERROR_BEHAVIOR_CONTINUE,
+        callback_);
   }
 
   void ProcessFile(const FileSystemURL& url,
                    const StatusCallback& callback) override {
     RecordLogEntry(LogEntry::PROCESS_FILE, url);
 
     if (error_url_.is_valid() && error_url_ == url) {
       callback.Run(base::File::FILE_ERROR_FAILED);
       return;
     }
@@ skipping 47 matching lines @@
   base::WeakPtrFactory<LoggingRecursiveOperation> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(LoggingRecursiveOperation);
 };
 
 void ReportStatus(base::File::Error* out_error,
                   base::File::Error error) {
   DCHECK(out_error);
   *out_error = error;
 }
 
-typedef std::pair<FileSystemURL, base::File::Error> ErrorEntry;
-
-void ReportError(std::vector<ErrorEntry>* out_errors,
-                 const FileSystemURL& url,
-                 base::File::Error error) {
-  DCHECK(out_errors);
-  out_errors->push_back(std::make_pair(url, error));
-}
-
 // To test the Cancel() during operation, calls Cancel() of |operation|
 // after |counter| times message posting.
 void CallCancelLater(storage::RecursiveOperationDelegate* operation,
                      int counter) {
   if (counter > 0) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&CallCancelLater, base::Unretained(operation), counter - 1));
     return;
   }
@@ skipping 181 matching lines @@
 
   EXPECT_EQ(LoggingRecursiveOperation::LogEntry::PROCESS_DIRECTORY,
             log_entries[1].type);
   EXPECT_EQ(src_root, log_entries[1].url);
 
   EXPECT_EQ(LoggingRecursiveOperation::LogEntry::PROCESS_FILE,
             log_entries[2].type);
   EXPECT_EQ(src_file1, log_entries[2].url);
 }
 
 TEST_F(RecursiveOperationDelegateTest, ContinueWithError) {

[mtomasz, 2015/06/24 03:36:17]

Can we add a similar test for ERROR_BEHAVIOR_TERMINATE to be sure that we don't
continue on error?

[yawano, 2015/06/24 03:38:48]

We have one with the name of AbortWithError. It's above this method.

[mtomasz, 2015/06/24 03:44:30]

Ah, sorry I missed it! lgtm!

   FileSystemURL src_root(CreateDirectory("src"));
   FileSystemURL src_dir1(CreateDirectory("src/dir1"));
   FileSystemURL src_file1(CreateFile("src/file1"));
   FileSystemURL src_file2(CreateFile("src/dir1/file2"));
   FileSystemURL src_file3(CreateFile("src/dir1/file3"));
 
   base::File::Error error = base::File::FILE_ERROR_FAILED;
-  std::vector<ErrorEntry> errors;
   scoped_ptr<FileSystemOperationContext> context = NewContext();
   scoped_ptr<LoggingRecursiveOperation> operation(
       new LoggingRecursiveOperation(context->file_system_context(), src_root,
                                     base::Bind(&ReportStatus, &error)));
   operation->SetEntryToFail(src_file1);
-  operation->RunRecursivelyWithIgnoringError(base::Bind(&ReportError, &errors));
+  operation->RunRecursivelyWithIgnoringError();
   base::RunLoop().RunUntilIdle();
 
   // Error code should be base::File::FILE_ERROR_FAILED.
   ASSERT_EQ(base::File::FILE_ERROR_FAILED, error);
 
-  // Error callback should be called.
-  ASSERT_EQ(1U, errors.size());
-  ASSERT_EQ(src_file1, errors[0].first);
-  ASSERT_EQ(base::File::FILE_ERROR_FAILED, errors[0].second);
-
   // Confirm that operation continues after the error.
   const std::vector<LoggingRecursiveOperation::LogEntry>& log_entries =
       operation->log_entries();
   ASSERT_EQ(8U, log_entries.size());
 
   EXPECT_EQ(LoggingRecursiveOperation::LogEntry::PROCESS_FILE,
             log_entries[0].type);
   EXPECT_EQ(src_root, log_entries[0].url);
 
   EXPECT_EQ(LoggingRecursiveOperation::LogEntry::PROCESS_DIRECTORY,
@@ skipping 19 matching lines @@
   EXPECT_EQ(LoggingRecursiveOperation::LogEntry::POST_PROCESS_DIRECTORY,
             log_entries[6].type);
   EXPECT_EQ(src_dir1, log_entries[6].url);
 
   EXPECT_EQ(LoggingRecursiveOperation::LogEntry::POST_PROCESS_DIRECTORY,
             log_entries[7].type);
   EXPECT_EQ(src_root, log_entries[7].url);
 }
 
 }  // namespace content