Recursive operation delegate continues operations with ignoring errors.

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) {
+      canceled_(false),
+      ignore_error_(false),
+      failed_some_operations_(false) {
 }
 
 RecursiveOperationDelegate::~RecursiveOperationDelegate() {
 }
 
 void RecursiveOperationDelegate::Cancel() {
   canceled_ = true;
   OnCancel();
 }
 
 void RecursiveOperationDelegate::StartRecursiveOperation(
     const FileSystemURL& root,
     const StatusCallback& callback) {
   DCHECK(pending_directory_stack_.empty());
   DCHECK(pending_files_.empty());
   DCHECK_EQ(0, inflight_operations_);
 
   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));
+  ProcessFile(root, base::Bind(&RecursiveOperationDelegate::DidTryProcessFile,
+                               AsWeakPtr(), root));
 }
 
 FileSystemOperationRunner* RecursiveOperationDelegate::operation_runner() {
   return file_system_context_->operation_runner();
 }
 
 void RecursiveOperationDelegate::OnCancel() {
 }
 
 void RecursiveOperationDelegate::DidTryProcessFile(
@@ skipping 94 matching lines @@
     return;
 
   // Run ProcessFile in parallel (upto kMaxInflightOperations).
   scoped_refptr<base::SingleThreadTaskRunner> current_task_runner =
       base::ThreadTaskRunnerHandle::Get();
   while (!pending_files_.empty() &&
          inflight_operations_ < kMaxInflightOperations) {
     ++inflight_operations_;
     current_task_runner->PostTask(
         FROM_HERE,
-        base::Bind(&RecursiveOperationDelegate::ProcessFile,
-                   AsWeakPtr(), pending_files_.front(),
+        base::Bind(&RecursiveOperationDelegate::ProcessFile, AsWeakPtr(),
+                   pending_files_.front(),
                    base::Bind(&RecursiveOperationDelegate::DidProcessFile,
-                              AsWeakPtr())));
+                              AsWeakPtr(), pending_files_.front())));
     pending_files_.pop();
   }
 }
 
-void RecursiveOperationDelegate::DidProcessFile(
-    base::File::Error error) {
+void RecursiveOperationDelegate::DidProcessFile(const FileSystemURL& url,
+                                                base::File::Error error) {
   --inflight_operations_;
+
   if (error != base::File::FILE_OK) {
-    // 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;
+    if (!ignore_error_) {
+      // 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);
+    }
   }
 
   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 {
-    callback_.Run(error);
+    if (ignore_error_ && failed_some_operations_)
+      callback_.Run(base::File::FILE_ERROR_FAILED);
+    else
+      callback_.Run(error);
   }
 }
 
 }  // namespace storage