Add fileManagerPrivate.onCopyError event.

storage/browser/fileapi/file_system_operation.h

 // 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.
 
 #ifndef STORAGE_BROWSER_FILEAPI_FILE_SYSTEM_OPERATION_H_
 #define STORAGE_BROWSER_FILEAPI_FILE_SYSTEM_OPERATION_H_
 
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 50 matching lines @@
   STORAGE_EXPORT static FileSystemOperation* Create(
       const FileSystemURL& url,
       FileSystemContext* file_system_context,
       scoped_ptr<FileSystemOperationContext> operation_context);
 
   virtual ~FileSystemOperation() {}
 
   // Used for CreateFile(), etc. |result| is the return code of the operation.
   typedef base::Callback<void(base::File::Error result)> StatusCallback;
 
-  // Called when an error had happened during operation.
-  // |url| is the url of processed entry.
-  // |error| is the error code of the failed operation.
-  typedef base::Callback<void(const FileSystemURL& url,
-                              base::File::Error error)> ErrorCallback;
-
   // Used for GetMetadata(). |result| is the return code of the operation,
   // |file_info| is the obtained file info.
   typedef base::Callback<
       void(base::File::Error result,
            const base::File::Info& file_info)> GetMetadataCallback;
 
   // Used for OpenFile(). |on_close_callback| will be called after the file is
   // closed in the child process. It can be null, if no operation is needed on
   // closing a file.
   typedef base::Callback<
@@ skipping 32 matching lines @@
   // longer necessary in the javascript world.
   // Please see the comment for ShareableFileReference for details.
   //
   typedef base::Callback<
       void(base::File::Error result,
            const base::File::Info& file_info,
            const base::FilePath& platform_path,
            const scoped_refptr<storage::ShareableFileReference>& file_ref)>
       SnapshotFileCallback;
 
+  // Used to specify how recursive operation delegate behaves for errors.
+  // With ERROR_BEHAVIOR_TERMINATE, it stops following operation when it fails
+  // an operation.
+  // With ERROR_BEHAVIOR_CONTINUE, it continues following operation even when it
+  // fails some of the operations.
+  enum ErrorBehavior { ERROR_BEHAVIOR_TERMINATE, ERROR_BEHAVIOR_CONTINUE };
+
   // Used for progress update callback for Copy().
   //
   // BEGIN_COPY_ENTRY is fired for each copy creation beginning (for both
   // file and directory).
   // The |source_url| is the URL of the source entry. |size| should not be
   // used.
   //
   // END_COPY_ENTRY is fired for each copy creation finishing (for both
   // file and directory).
   // The |source_url| is the URL of the source entry. The |destination_url| is
@@ skipping 53 matching lines @@
   // for root directory.
   // For 2)'s case, we can add BEGIN_DELETE_ENTRY and END_DELETE_ENTRY for each
   // entry.
   // For both cases, we probably won't need to use PROGRESS event because
   // these operations should be done quickly (at least much faster than copying
   // usually).
   enum CopyProgressType {
     BEGIN_COPY_ENTRY,
     END_COPY_ENTRY,
     PROGRESS,
+    ERROR
   };
   typedef base::Callback<void(CopyProgressType type,
                               const FileSystemURL& source_url,
                               const FileSystemURL& destination_url,
                               int64 size)>
       CopyProgressCallback;
 
   // Used for CopyFileLocal() to report progress update.
   // |size| is the cumulative copied bytes for the copy.
   // At the beginning the progress callback should be called with |size| = 0,
@@ skipping 32 matching lines @@
                                bool exclusive,
                                bool recursive,
                                const StatusCallback& callback) = 0;
 
   // Copies a file or directory from |src_path| to |dest_path|. If
   // |src_path| is a directory, the contents of |src_path| are copied to
   // |dest_path| recursively. A new file or directory is created at
   // |dest_path| as needed.
   // |option| specifies the minor behavior of Copy(). See CopyOrMoveOption's
   // comment for details.
+  // |error_behavior| specifies whether this continues operation after it
+  // failed an operation or not.
   // |progress_callback| is periodically called to report the progress
   // update. See also the comment of CopyProgressCallback. This callback is
   // optional.
   //
   // For recursive case this internally creates new FileSystemOperations and
   // calls:
   // - ReadDirectory, CopyFileLocal and CreateDirectory
   //   for same-filesystem case, or
   // - ReadDirectory and CreateSnapshotFile on source filesystem and
   //   CopyInForeignFile and CreateDirectory on dest filesystem
   //   for cross-filesystem case.
   //
   virtual void Copy(const FileSystemURL& src_path,
                     const FileSystemURL& dest_path,
                     CopyOrMoveOption option,
+                    const ErrorBehavior error_behavior,
                     const CopyProgressCallback& progress_callback,
                     const StatusCallback& callback) = 0;
 
   // Moves a file or directory from |src_path| to |dest_path|. A new file
   // or directory is created at |dest_path| as needed.
   // |option| specifies the minor behavior of Copy(). See CopyOrMoveOption's
   // comment for details.
   //
   // For recursive case this internally creates new FileSystemOperations and
   // calls:
@@ skipping 203 matching lines @@
     kOperationOpenFile,
     kOperationCloseFile,
     kOperationGetLocalPath,
     kOperationCancel,
   };
 };
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_FILEAPI_FILE_SYSTEM_OPERATION_H_