Convert Media Galleries to use base::File

chrome/browser/media_galleries/linux/mtp_device_task_helper.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/media_galleries/linux/mtp_device_task_helper.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 47 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void MTPDeviceTaskHelper::GetFileInfoByPath(
     const std::string& file_path,
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (device_handle_.empty())
-    return HandleDeviceError(error_callback, base::PLATFORM_FILE_ERROR_FAILED);
+    return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
   GetMediaTransferProtocolManager()->GetFileInfoByPath(
       device_handle_, file_path,
       base::Bind(&MTPDeviceTaskHelper::OnGetFileInfo,
                  weak_ptr_factory_.GetWeakPtr(),
                  success_callback,
                  error_callback));
 }
 
 void MTPDeviceTaskHelper::ReadDirectoryByPath(
     const std::string& dir_path,
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (device_handle_.empty())
-    return HandleDeviceError(error_callback, base::PLATFORM_FILE_ERROR_FAILED);
+    return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
   GetMediaTransferProtocolManager()->ReadDirectoryByPath(
       device_handle_, dir_path,
       base::Bind(&MTPDeviceTaskHelper::OnDidReadDirectoryByPath,
                  weak_ptr_factory_.GetWeakPtr(),
                  success_callback,
                  error_callback));
 }
 
 void MTPDeviceTaskHelper::WriteDataIntoSnapshotFile(
     const SnapshotRequestInfo& request_info,
-    const base::PlatformFileInfo& snapshot_file_info) {
+    const base::File::Info& snapshot_file_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (device_handle_.empty()) {
     return HandleDeviceError(request_info.error_callback,
-                             base::PLATFORM_FILE_ERROR_FAILED);
+                             base::File::FILE_ERROR_FAILED);
   }
 
   if (!read_file_worker_)
     read_file_worker_.reset(new MTPReadFileWorker(device_handle_));
   read_file_worker_->WriteDataIntoSnapshotFile(request_info,
                                                snapshot_file_info);
 }
 
 void MTPDeviceTaskHelper::ReadBytes(
     const MTPDeviceAsyncDelegate::ReadBytesRequest& request) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (device_handle_.empty()) {
     return HandleDeviceError(request.error_callback,
-                             base::PLATFORM_FILE_ERROR_FAILED);
+                             base::File::FILE_ERROR_FAILED);
   }
 
   GetMediaTransferProtocolManager()->ReadFileChunkByPath(
       device_handle_,
       request.device_file_relative_path,
       base::checked_cast<uint32>(request.offset),
       base::checked_cast<uint32>(request.buf_len),
       base::Bind(&MTPDeviceTaskHelper::OnDidReadBytes,
                  weak_ptr_factory_.GetWeakPtr(), request));
 }
@@ skipping 18 matching lines @@
 }
 
 void MTPDeviceTaskHelper::OnGetFileInfo(
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const MtpFileEntry& file_entry,
     bool error) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (error) {
     return HandleDeviceError(error_callback,
-                             base::PLATFORM_FILE_ERROR_NOT_FOUND);
+                             base::File::FILE_ERROR_NOT_FOUND);
   }
 
-  base::PlatformFileInfo file_entry_info;
+  base::File::Info file_entry_info;
   file_entry_info.size = file_entry.file_size();
   file_entry_info.is_directory =
       file_entry.file_type() == MtpFileEntry::FILE_TYPE_FOLDER;
   file_entry_info.is_symbolic_link = false;
   file_entry_info.last_modified =
       base::Time::FromTimeT(file_entry.modification_time());
   file_entry_info.last_accessed = file_entry_info.last_modified;
   file_entry_info.creation_time = base::Time();
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(success_callback,
                                               file_entry_info));
 }
 
 void MTPDeviceTaskHelper::OnDidReadDirectoryByPath(
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const std::vector<MtpFileEntry>& file_entries,
     bool error) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (error)
-    return HandleDeviceError(error_callback, base::PLATFORM_FILE_ERROR_FAILED);
+    return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
   fileapi::AsyncFileUtil::EntryList entries;
   base::FilePath current;
   MTPDeviceObjectEnumerator file_enum(file_entries);
   while (!(current = file_enum.Next()).empty()) {
     fileapi::DirectoryEntry entry;
     entry.name = fileapi::VirtualPath::BaseName(current).value();
     entry.is_directory = file_enum.IsDirectory();
     entry.size = file_enum.Size();
     entry.last_modified_time = file_enum.LastModifiedTime();
     entries.push_back(entry);
   }
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(success_callback, entries));
 }
 
 void MTPDeviceTaskHelper::OnDidReadBytes(
     const MTPDeviceAsyncDelegate::ReadBytesRequest& request,
     const std::string& data,
     bool error) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (error) {
     return HandleDeviceError(request.error_callback,
-                             base::PLATFORM_FILE_ERROR_FAILED);
+                             base::File::FILE_ERROR_FAILED);
   }
 
   CHECK_LE(base::checked_cast<int>(data.length()), request.buf_len);
   std::copy(data.begin(), data.end(), request.buf->data());
 
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(request.success_callback,
                                               data.length()));
 }
 
 void MTPDeviceTaskHelper::HandleDeviceError(
     const ErrorCallback& error_callback,
-    base::PlatformFileError error) const {
+    base::File::Error error) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(error_callback, error));
 }