Convert Media Galleries to use base::File

chrome/browser/sync_file_system/local/local_file_sync_context.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 "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/platform_file.h"
@@ skipping 316 matching lines @@
 void LocalFileSyncContext::HandleRemoteAddOrUpdate(
     FileSystemContext* file_system_context,
     const FileChange& change,
     const base::FilePath& local_path,
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, url);
 
   if (fileapi::VirtualPath::IsRootPath(url.path())) {
-    DidApplyRemoteChange(url, callback, base::PLATFORM_FILE_OK);
+    DidApplyRemoteChange(url, callback, base::File::FILE_OK);
     return;
   }
 
   file_system_context->operation_runner()->Remove(
       url_for_sync, true /* recursive */,
       base::Bind(
           &LocalFileSyncContext::DidRemoveExistingEntryForRemoteAddOrUpdate,
           this,
           make_scoped_refptr(file_system_context),
           change,
           local_path,
           url,
           callback));
 }
 
 void LocalFileSyncContext::DidRemoveExistingEntryForRemoteAddOrUpdate(
     FileSystemContext* file_system_context,
     const FileChange& change,
     const base::FilePath& local_path,
     const FileSystemURL& url,
     const SyncStatusCallback& callback,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   // Remove() may fail if the target entry does not exist (which is ok),
   // so we ignore |error| here.
 
   if (shutdown_on_io_) {
     callback.Run(SYNC_FILE_ERROR_ABORT);
     return;
   }
 
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!sync_status()->IsWritable(url));
@@ skipping 245 matching lines @@
   root_delete_helper_.reset();
   sync_status_.reset();
   timer_on_io_.reset();
 }
 
 void LocalFileSyncContext::InitializeFileSystemContextOnIOThread(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     const GURL& /* root */,
     const std::string& /* name */,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
-    error = base::PLATFORM_FILE_ERROR_ABORT;
-  if (error != base::PLATFORM_FILE_OK) {
+    error = base::File::FILE_ERROR_ABORT;
+  if (error != base::File::FILE_OK) {
     DidInitialize(source_url, file_system_context,
-                  PlatformFileErrorToSyncStatusCode(error));
+                  FileErrorToSyncStatusCode(error));
     return;
   }
   DCHECK(file_system_context);
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   if (!backend->change_tracker()) {
     // Create and initialize LocalFileChangeTracker and call back this method
     // later again.
     std::set<GURL>* origins_with_changes = new std::set<GURL>;
@@ skipping 76 matching lines @@
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   backend->SetLocalFileChangeTracker(tracker_ptr->Pass());
 
   origins_with_pending_changes_.insert(origins_with_changes->begin(),
                                        origins_with_changes->end());
   ScheduleNotifyChangesUpdatedOnIOThread();
 
   InitializeFileSystemContextOnIOThread(source_url, file_system_context,
                                         GURL(), std::string(),
-                                        base::PLATFORM_FILE_OK);
+                                        base::File::FILE_OK);
 }
 
 void LocalFileSyncContext::DidInitialize(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     SyncStatusCode status) {
   if (!ui_task_runner_->RunsTasksOnCurrentThread()) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::DidInitialize,
@@ skipping 107 matching lines @@
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   FileChangeList changes;
   backend->change_tracker()->GetChangesForURL(url, &changes);
 
   base::FilePath platform_path;
-  base::PlatformFileInfo file_info;
+  base::File::Info file_info;
   FileSystemFileUtil* file_util =
       file_system_context->sandbox_delegate()->sync_file_util();
   DCHECK(file_util);
 
-  base::PlatformFileError file_error = file_util->GetFileInfo(
+  base::File::Error file_error = file_util->GetFileInfo(
       make_scoped_ptr(
           new FileSystemOperationContext(file_system_context)).get(),
       url,
       &file_info,
       &platform_path);
 
   webkit_blob::ScopedFile snapshot;
-  if (file_error == base::PLATFORM_FILE_OK && sync_mode == SYNC_SNAPSHOT) {
+  if (file_error == base::File::FILE_OK && sync_mode == SYNC_SNAPSHOT) {
     base::FilePath snapshot_path;
     base::CreateTemporaryFileInDir(local_base_path_.Append(kSnapshotDir),
                                    &snapshot_path);
     if (base::CopyFile(platform_path, snapshot_path)) {
       platform_path = snapshot_path;
       snapshot = webkit_blob::ScopedFile(
           snapshot_path,
           webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT,
           file_system_context->default_file_task_runner());
     }
   }
 
   if (status == SYNC_STATUS_OK &&
-      file_error != base::PLATFORM_FILE_OK &&
-      file_error != base::PLATFORM_FILE_ERROR_NOT_FOUND)
-    status = PlatformFileErrorToSyncStatusCode(file_error);
+      file_error != base::File::FILE_OK &&
+      file_error != base::File::FILE_ERROR_NOT_FOUND) {
+    status = FileErrorToSyncStatusCode(file_error);
+}
 
   DCHECK(!file_info.is_symbolic_link);
 
   SyncFileType file_type = SYNC_FILE_TYPE_FILE;
-  if (file_error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
+  if (file_error == base::File::FILE_ERROR_NOT_FOUND)
     file_type = SYNC_FILE_TYPE_UNKNOWN;
   else if (file_info.is_directory)
     file_type = SYNC_FILE_TYPE_DIRECTORY;
 
   LocalFileSyncInfo sync_file_info;
   sync_file_info.url = url;
   sync_file_info.local_file_path = platform_path;
   sync_file_info.metadata.file_type = file_type;
   sync_file_info.metadata.size = file_info.size;
   sync_file_info.metadata.last_modified = file_info.last_modified;
@@ skipping 46 matching lines @@
     return;
   sync_status()->EndWriting(url);
 
   // Since a sync has finished the number of changes must have been updated.
   UpdateChangesForOrigin(url.origin());
 }
 
 void LocalFileSyncContext::DidApplyRemoteChange(
     const FileSystemURL& url,
     const SyncStatusCallback& callback_on_ui,
-    base::PlatformFileError file_error) {
+    base::File::Error file_error) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   root_delete_helper_.reset();
   ui_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(callback_on_ui,
-                 PlatformFileErrorToSyncStatusCode(file_error)));
+      base::Bind(callback_on_ui, FileErrorToSyncStatusCode(file_error)));
 }
 
 void LocalFileSyncContext::DidGetFileMetadata(
     const SyncFileMetadataCallback& callback,
-    base::PlatformFileError file_error,
-    const base::PlatformFileInfo& file_info) {
+    base::File::Error file_error,
+    const base::File::Info& file_info) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   SyncFileMetadata metadata;
-  if (file_error == base::PLATFORM_FILE_OK) {
+  if (file_error == base::File::FILE_OK) {
     metadata.file_type = file_info.is_directory ?
         SYNC_FILE_TYPE_DIRECTORY : SYNC_FILE_TYPE_FILE;
     metadata.size = file_info.size;
     metadata.last_modified = file_info.last_modified;
   }
   ui_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(callback,
-                 PlatformFileErrorToSyncStatusCode(file_error),
-                 metadata));
+      base::Bind(callback, FileErrorToSyncStatusCode(file_error), metadata));
 }
 
 base::TimeDelta LocalFileSyncContext::NotifyChangesDuration() {
   if (mock_notify_changes_duration_in_sec_ >= 0)
     return base::TimeDelta::FromSeconds(mock_notify_changes_duration_in_sec_);
   return base::TimeDelta::FromSeconds(kNotifyChangesDurationInSec);
 }
 
 void LocalFileSyncContext::DidCreateDirectoryForCopyIn(
     FileSystemContext* file_system_context,
     const base::FilePath& local_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback,
-    base::PlatformFileError error) {
-  if (error != base::PLATFORM_FILE_OK) {
+    base::File::Error error) {
+  if (error != base::File::FILE_OK) {
     callback.Run(error);
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
       local_path, url_for_sync, callback);
 }
 
 }  // namespace sync_file_system