Convert Media Galleries to use base::File

webkit/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 "webkit/browser/fileapi/recursive_operation_delegate.h"
 
 #include "base/bind.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 
@@ skipping 36 matching lines @@
 
 FileSystemOperationRunner* RecursiveOperationDelegate::operation_runner() {
   return file_system_context_->operation_runner();
 }
 
 void RecursiveOperationDelegate::OnCancel() {
 }
 
 void RecursiveOperationDelegate::DidTryProcessFile(
     const FileSystemURL& root,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(pending_directory_stack_.empty());
   DCHECK(pending_files_.empty());
   DCHECK_EQ(1, inflight_operations_);
 
   --inflight_operations_;
-  if (canceled_ || error != base::PLATFORM_FILE_ERROR_NOT_A_FILE) {
+  if (canceled_ || error != base::File::FILE_ERROR_NOT_A_FILE) {
     Done(error);
     return;
   }
 
   pending_directory_stack_.push(std::queue<FileSystemURL>());
   pending_directory_stack_.top().push(root);
   ProcessNextDirectory();
 }
 
 void RecursiveOperationDelegate::ProcessNextDirectory() {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK(!pending_directory_stack_.top().empty());
   DCHECK_EQ(0, inflight_operations_);
 
   const FileSystemURL& url = pending_directory_stack_.top().front();
 
   ++inflight_operations_;
   ProcessDirectory(
       url,
       base::Bind(
           &RecursiveOperationDelegate::DidProcessDirectory, AsWeakPtr()));
 }
 
 void RecursiveOperationDelegate::DidProcessDirectory(
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK(!pending_directory_stack_.top().empty());
   DCHECK_EQ(1, inflight_operations_);
 
   --inflight_operations_;
-  if (canceled_ || error != base::PLATFORM_FILE_OK) {
+  if (canceled_ || error != base::File::FILE_OK) {
     Done(error);
     return;
   }
 
   const FileSystemURL& parent = pending_directory_stack_.top().front();
   pending_directory_stack_.push(std::queue<FileSystemURL>());
   operation_runner()->ReadDirectory(
       parent,
       base::Bind(&RecursiveOperationDelegate::DidReadDirectory,
                  AsWeakPtr(), parent));
 }
 
 void RecursiveOperationDelegate::DidReadDirectory(
     const FileSystemURL& parent,
-    base::PlatformFileError error,
+    base::File::Error error,
     const FileEntryList& entries,
     bool has_more) {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK_EQ(0, inflight_operations_);
 
-  if (canceled_ || error != base::PLATFORM_FILE_OK) {
+  if (canceled_ || error != base::File::FILE_OK) {
     Done(error);
     return;
   }
 
   for (size_t i = 0; i < entries.size(); i++) {
     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
         parent.origin(),
         parent.mount_type(),
         parent.virtual_path().Append(entries[i].name));
     if (entries[i].is_directory)
@@ skipping 31 matching lines @@
         FROM_HERE,
         base::Bind(&RecursiveOperationDelegate::ProcessFile,
                    AsWeakPtr(), pending_files_.front(),
                    base::Bind(&RecursiveOperationDelegate::DidProcessFile,
                               AsWeakPtr())));
     pending_files_.pop();
   }
 }
 
 void RecursiveOperationDelegate::DidProcessFile(
-    base::PlatformFileError error) {
+    base::File::Error error) {
   --inflight_operations_;
-  if (error != base::PLATFORM_FILE_OK) {
+  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;
   }
 
   ProcessPendingFiles();
 }
 
 void RecursiveOperationDelegate::ProcessSubDirectory() {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK_EQ(0, inflight_operations_);
 
   if (canceled_) {
-    Done(base::PLATFORM_FILE_ERROR_ABORT);
+    Done(base::File::FILE_ERROR_ABORT);
     return;
   }
 
   if (!pending_directory_stack_.top().empty()) {
     // There remain some sub directories. Process them first.
     ProcessNextDirectory();
     return;
   }
 
   // All subdirectories are processed.
   pending_directory_stack_.pop();
   if (pending_directory_stack_.empty()) {
     // All files/directories are processed.
-    Done(base::PLATFORM_FILE_OK);
+    Done(base::File::FILE_OK);
     return;
   }
 
   DCHECK(!pending_directory_stack_.top().empty());
   ++inflight_operations_;
   PostProcessDirectory(
       pending_directory_stack_.top().front(),
       base::Bind(&RecursiveOperationDelegate::DidPostProcessDirectory,
                  AsWeakPtr()));
 }
 
 void RecursiveOperationDelegate::DidPostProcessDirectory(
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(pending_files_.empty());
   DCHECK(!pending_directory_stack_.empty());
   DCHECK(!pending_directory_stack_.top().empty());
   DCHECK_EQ(1, inflight_operations_);
 
   --inflight_operations_;
   pending_directory_stack_.top().pop();
-  if (canceled_ || error != base::PLATFORM_FILE_OK) {
+  if (canceled_ || error != base::File::FILE_OK) {
     Done(error);
     return;
   }
 
   ProcessSubDirectory();
 }
 
-void RecursiveOperationDelegate::Done(base::PlatformFileError error) {
-  if (canceled_ && error == base::PLATFORM_FILE_OK) {
-    callback_.Run(base::PLATFORM_FILE_ERROR_ABORT);
+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);
   }
 }
 
 }  // namespace fileapi