Convert Media Galleries to use base::File

chrome/browser/media_galleries/fileapi/device_media_async_file_util.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 "chrome/browser/media_galleries/fileapi/device_media_async_file_util.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
@@ skipping 61 matching lines @@
 }
 
 void DeviceMediaAsyncFileUtil::CreateOrOpen(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     int file_flags,
     const CreateOrOpenCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
   base::PlatformFile invalid_file = base::kInvalidPlatformFileValue;
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY,
+  callback.Run(base::File::FILE_ERROR_SECURITY,
                base::PassPlatformFile(&invalid_file),
                base::Closure());
 }
 
 void DeviceMediaAsyncFileUtil::EnsureFileExists(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const EnsureFileExistsCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, false);
+  callback.Run(base::File::FILE_ERROR_SECURITY, false);
 }
 
 void DeviceMediaAsyncFileUtil::CreateDirectory(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+  callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::GetFileInfo(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const GetFileInfoCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
-    OnGetFileInfoError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    OnGetFileInfoError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
   delegate->GetFileInfo(
       url.path(),
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidGetFileInfo,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback),
       base::Bind(&DeviceMediaAsyncFileUtil::OnGetFileInfoError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void DeviceMediaAsyncFileUtil::ReadDirectory(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
-    OnReadDirectoryError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    OnReadDirectoryError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
   delegate->ReadDirectory(
       url.path(),
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidReadDirectory,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback),
       base::Bind(&DeviceMediaAsyncFileUtil::OnReadDirectoryError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void DeviceMediaAsyncFileUtil::Touch(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+  callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::Truncate(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     int64 length,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+  callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::CopyFileLocal(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const CopyFileProgressCallback& progress_callback,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+  callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::MoveFileLocal(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+  callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::CopyInForeignFile(
     scoped_ptr<FileSystemOperationContext> context,
     const base::FilePath& src_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+  callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::DeleteFile(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+  callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::DeleteDirectory(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   NOTIMPLEMENTED();
-  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+  callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::DeleteRecursively(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+  callback.Run(base::File::FILE_ERROR_INVALID_OPERATION);
 }
 
 void DeviceMediaAsyncFileUtil::CreateSnapshotFile(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const CreateSnapshotFileCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
-    OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    OnCreateSnapshotFileError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
 
   scoped_refptr<base::SequencedTaskRunner> task_runner = context->task_runner();
 
   if (delegate->IsStreaming()) {
     GetFileInfo(
         context.Pass(),
         url,
         base::Bind(&DeviceMediaAsyncFileUtil::GetHeaderBytesForMIMESniffing,
@@ skipping 33 matching lines @@
 }
 
 DeviceMediaAsyncFileUtil::DeviceMediaAsyncFileUtil(
     const base::FilePath& profile_path)
     : profile_path_(profile_path),
       weak_ptr_factory_(this) {
 }
 
 void DeviceMediaAsyncFileUtil::OnDidGetFileInfo(
     const AsyncFileUtil::GetFileInfoCallback& callback,
-    const base::PlatformFileInfo& file_info) {
-  callback.Run(base::PLATFORM_FILE_OK, file_info);
+    const base::File::Info& file_info) {
+  callback.Run(base::File::FILE_OK, file_info);
 }
 
 void DeviceMediaAsyncFileUtil::OnGetFileInfoError(
     const AsyncFileUtil::GetFileInfoCallback& callback,
-    base::PlatformFileError error) {
-  callback.Run(error, base::PlatformFileInfo());
+    base::File::Error error) {
+  callback.Run(error, base::File::Info());
 }
 
 void DeviceMediaAsyncFileUtil::OnDidReadDirectory(
     const AsyncFileUtil::ReadDirectoryCallback& callback,
     const AsyncFileUtil::EntryList& file_list,
     bool has_more) {
-  callback.Run(base::PLATFORM_FILE_OK, file_list, has_more);
+  callback.Run(base::File::FILE_OK, file_list, has_more);
 }
 
 void DeviceMediaAsyncFileUtil::OnReadDirectoryError(
     const AsyncFileUtil::ReadDirectoryCallback& callback,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   callback.Run(error, AsyncFileUtil::EntryList(), false /*no more*/);
 }
 
 void DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     base::SequencedTaskRunner* media_task_runner,
-    const base::PlatformFileInfo& file_info,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path) {
   base::PostTaskAndReplyWithResult(
       media_task_runner,
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::IsMediaFile, platform_path),
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidCheckMedia,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  file_info,
                  ShareableFileReference::GetOrCreate(
                      platform_path,
                      ShareableFileReference::DELETE_ON_FINAL_RELEASE,
                      media_task_runner)));
 }
 
 void DeviceMediaAsyncFileUtil::OnDidCheckMedia(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
-    const base::PlatformFileInfo& file_info,
+    const base::File::Info& file_info,
     scoped_refptr<webkit_blob::ShareableFileReference> platform_file,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   base::FilePath platform_path(platform_file.get()->path());
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     platform_file = NULL;
   callback.Run(error, file_info, platform_path, platform_file);
 }
 
 void DeviceMediaAsyncFileUtil::GetHeaderBytesForMIMESniffing(
     const fileapi::FileSystemURL& url,
     base::SequencedTaskRunner* media_task_runner,
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
-    base::PlatformFileError error,
-    const base::PlatformFileInfo& file_info) {
+    base::File::Error error,
+    const base::File::Info& file_info) {
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
-    OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    OnCreateSnapshotFileError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(net::kMaxBytesToSniff));
   delegate->ReadBytes(
       url.path(),
       buffer,
       0,
       net::kMaxBytesToSniff,
       base::Bind(&DeviceMediaAsyncFileUtil::FinishStreamingSnapshotFile,
                  weak_ptr_factory_.GetWeakPtr(), url,
                  make_scoped_refptr(media_task_runner), callback, file_info,
                  buffer),
       base::Bind(&DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void DeviceMediaAsyncFileUtil::FinishStreamingSnapshotFile(
     const fileapi::FileSystemURL& url,
     base::SequencedTaskRunner* media_task_runner,
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
-    const base::PlatformFileInfo& file_info,
+    const base::File::Info& file_info,
     net::IOBuffer* buffer,
     int buffer_size) {
-  base::PlatformFileError error =
+  base::File::Error error =
       NativeMediaFileUtil::BufferIsMediaHeader(buffer, buffer_size);
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     OnCreateSnapshotFileError(callback, error);
     return;
   }
-  callback.Run(base::PLATFORM_FILE_OK, file_info, base::FilePath(),
+  callback.Run(base::File::FILE_OK, file_info, base::FilePath(),
                scoped_refptr<ShareableFileReference>());
 }
 
 void DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
-    base::PlatformFileError error) {
-  callback.Run(error, base::PlatformFileInfo(), base::FilePath(),
+    base::File::Error error) {
+  callback.Run(error, base::File::Info(), base::FilePath(),
                scoped_refptr<ShareableFileReference>());
 }
 
 void DeviceMediaAsyncFileUtil::OnSnapshotFileCreatedRunTask(
     scoped_ptr<FileSystemOperationContext> context,
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     const FileSystemURL& url,
     base::FilePath* snapshot_file_path) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   if (!snapshot_file_path || snapshot_file_path->empty()) {
-    OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_FAILED);
+    OnCreateSnapshotFileError(callback, base::File::FILE_ERROR_FAILED);
     return;
   }
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
-    OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    OnCreateSnapshotFileError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
   delegate->CreateSnapshotFile(
       url.path(),  // device file path
       *snapshot_file_path,
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  make_scoped_refptr(context->task_runner())),
       base::Bind(&DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }