Add fileManagerPrivate.onCopyError event.

storage/browser/fileapi/recursive_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/recursive_operation_delegate.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation_runner.h"
 
 namespace storage {
 
 namespace {
 // Don't start too many inflight operations.
 const int kMaxInflightOperations = 5;
 }
 
 RecursiveOperationDelegate::RecursiveOperationDelegate(
     FileSystemContext* file_system_context)
     : file_system_context_(file_system_context),
       inflight_operations_(0),
       canceled_(false),
-      ignore_error_(false),
+      error_behavior_(FileSystemOperation::ERROR_BEHAVIOR_TERMINATE),
       failed_some_operations_(false) {
 }
 
 RecursiveOperationDelegate::~RecursiveOperationDelegate() {
 }
 
 void RecursiveOperationDelegate::Cancel() {
   canceled_ = true;
   OnCancel();
 }
 
 void RecursiveOperationDelegate::StartRecursiveOperation(
     const FileSystemURL& root,
+    const ErrorBehavior error_behavior,
     const StatusCallback& callback) {
   DCHECK(pending_directory_stack_.empty());
   DCHECK(pending_files_.empty());
   DCHECK_EQ(0, inflight_operations_);
 
+  error_behavior_ = error_behavior;
   callback_ = callback;
 
   TryProcessFile(root);
 }
 
-void RecursiveOperationDelegate::StartRecursiveOperationWithIgnoringError(
-    const FileSystemURL& root,
-    const ErrorCallback& error_callback,
-    const StatusCallback& status_callback) {
-  DCHECK(pending_directory_stack_.empty());
-  DCHECK(pending_files_.empty());
-  DCHECK_EQ(0, inflight_operations_);
-
-  error_callback_ = error_callback;
-  callback_ = status_callback;
-  ignore_error_ = true;
-
-  TryProcessFile(root);
-}
-
 void RecursiveOperationDelegate::TryProcessFile(const FileSystemURL& root) {
   ++inflight_operations_;
   ProcessFile(root, base::Bind(&RecursiveOperationDelegate::DidTryProcessFile,
                                AsWeakPtr(), root));
 }
 
 FileSystemOperationRunner* RecursiveOperationDelegate::operation_runner() {
   return file_system_context_->operation_runner();
 }
 
@@ skipping 111 matching lines @@
                               AsWeakPtr(), pending_files_.front())));
     pending_files_.pop();
   }
 }
 
 void RecursiveOperationDelegate::DidProcessFile(const FileSystemURL& url,
                                                 base::File::Error error) {
   --inflight_operations_;
 
   if (error != base::File::FILE_OK) {
-    if (!ignore_error_) {
+    if (error_behavior_ == FileSystemOperation::ERROR_BEHAVIOR_TERMINATE) {
       // If an error occurs, invoke Done immediately (even if there remain
       // running operations). It is because in the callback, this instance is
       // deleted.
       Done(error);
       return;
-    } else {
-      failed_some_operations_ = true;
+    }
 
-      if (!error_callback_.is_null())
-        error_callback_.Run(url, error);
-    }
+    failed_some_operations_ = true;
   }
 
   ProcessPendingFiles();
 }
 
 void RecursiveOperationDelegate::ProcessSubDirectory() {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK_EQ(0, inflight_operations_);
 
@@ skipping 38 matching lines @@
     return;
   }
 
   ProcessSubDirectory();
 }
 
 void RecursiveOperationDelegate::Done(base::File::Error error) {
   if (canceled_ && error == base::File::FILE_OK) {
     callback_.Run(base::File::FILE_ERROR_ABORT);
   } else {
-    if (ignore_error_ && failed_some_operations_)
+    if (error_behavior_ == FileSystemOperation::ERROR_BEHAVIOR_CONTINUE &&
+        failed_some_operations_)
       callback_.Run(base::File::FILE_ERROR_FAILED);
     else
       callback_.Run(error);
   }
 }
 
 }  // namespace storage