Convert Media Galleries to use base::File

chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.cc

 // Copyright (c) 2012 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_delegate_impl_linux.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/media_galleries/linux/mtp_device_task_helper.h"
@@ skipping 67 matching lines @@
 //
 // |storage_name| specifies the name of the storage device.
 // |success_callback| is called when the ReadDirectory request succeeds.
 // |error_callback| is called when the ReadDirectory request fails.
 // |success_callback| and |error_callback| runs on the IO thread.
 void ReadDirectoryOnUIThread(
     const std::string& storage_name,
     const std::string& root,
     const base::Callback<
         void(const fileapi::AsyncFileUtil::EntryList&)>& success_callback,
-    const base::Callback<void(base::PlatformFileError)>& error_callback) {
+    const base::Callback<void(base::File::Error)>& error_callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name);
   if (!task_helper)
     return;
   task_helper->ReadDirectoryByPath(root, success_callback, error_callback);
 }
 
 // Gets the |file_path| details.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
 // |success_callback| is called when the GetFileInfo request succeeds.
 // |error_callback| is called when the GetFileInfo request fails.
 // |success_callback| and |error_callback| runs on the IO thread.
 void GetFileInfoOnUIThread(
     const std::string& storage_name,
     const std::string& file_path,
-    const base::Callback<void(const base::PlatformFileInfo&)>& success_callback,
-    const base::Callback<void(base::PlatformFileError)>& error_callback) {
+    const base::Callback<void(const base::File::Info&)>& success_callback,
+    const base::Callback<void(base::File::Error)>& error_callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name);
   if (!task_helper)
     return;
   task_helper->GetFileInfoByPath(file_path, success_callback, error_callback);
 }
 
 // Copies the contents of |device_file_path| to |snapshot_file_path|.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
 // |device_file_path| specifies the media device file path.
 // |snapshot_file_path| specifies the platform path of the snapshot file.
 // |file_size| specifies the number of bytes that will be written to the
 // snapshot file.
 // |success_callback| is called when the copy operation succeeds.
 // |error_callback| is called when the copy operation fails.
 // |success_callback| and |error_callback| runs on the IO thread.
 void WriteDataIntoSnapshotFileOnUIThread(
     const std::string& storage_name,
     const SnapshotRequestInfo& request_info,
-    const base::PlatformFileInfo& snapshot_file_info) {
+    const base::File::Info& snapshot_file_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name);
   if (!task_helper)
     return;
   task_helper->WriteDataIntoSnapshotFile(request_info, snapshot_file_info);
 }
 
 // Closes the device storage specified by the |storage_name| and destroys the
 // MTPDeviceTaskHelper object associated with the device storage.
@@ skipping 142 matching lines @@
         content::BrowserThread::UI,
         FROM_HERE,
         base::Bind(&OpenStorageOnUIThread,
                    storage_name_,
                    base::Bind(&MTPDeviceDelegateImplLinux::OnInitCompleted,
                               weak_ptr_factory_.GetWeakPtr())));
   }
 }
 
 void MTPDeviceDelegateImplLinux::WriteDataIntoSnapshotFile(
-    const base::PlatformFileInfo& file_info) {
+    const base::File::Info& file_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(current_snapshot_request_info_.get());
   DCHECK_GT(file_info.size, 0);
   task_in_progress_ = true;
   SnapshotRequestInfo request_info(
       current_snapshot_request_info_->device_file_path,
       current_snapshot_request_info_->snapshot_file_path,
       base::Bind(
           &MTPDeviceDelegateImplLinux::OnDidWriteDataIntoSnapshotFile,
           weak_ptr_factory_.GetWeakPtr()),
@@ skipping 26 matching lines @@
 
 void MTPDeviceDelegateImplLinux::OnInitCompleted(bool succeeded) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   init_state_ = succeeded ? INITIALIZED : UNINITIALIZED;
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidGetFileInfo(
     const GetFileInfoSuccessCallback& success_callback,
-    const base::PlatformFileInfo& file_info) {
+    const base::File::Info& file_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   success_callback.Run(file_info);
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidGetFileInfoToReadDirectory(
     const std::string& root,
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
-    const base::PlatformFileInfo& file_info) {
+    const base::File::Info& file_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(task_in_progress_);
   if (!file_info.is_directory) {
     return HandleDeviceFileError(error_callback,
-                                 base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY);
+                                 base::File::FILE_ERROR_NOT_A_DIRECTORY);
   }
 
   base::Closure task_closure =
       base::Bind(&ReadDirectoryOnUIThread,
                  storage_name_,
                  root,
                  base::Bind(&MTPDeviceDelegateImplLinux::OnDidReadDirectory,
                             weak_ptr_factory_.GetWeakPtr(),
                             success_callback),
                  base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                             weak_ptr_factory_.GetWeakPtr(),
                             error_callback));
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    FROM_HERE,
                                    task_closure);
 }
 
 void MTPDeviceDelegateImplLinux::OnDidGetFileInfoToCreateSnapshotFile(
     scoped_ptr<SnapshotRequestInfo> snapshot_request_info,
-    const base::PlatformFileInfo& file_info) {
+    const base::File::Info& file_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(!current_snapshot_request_info_.get());
   DCHECK(snapshot_request_info.get());
   DCHECK(task_in_progress_);
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   if (file_info.is_directory)
-    error = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+    error = base::File::FILE_ERROR_NOT_A_FILE;
   else if (file_info.size < 0 || file_info.size > kuint32max)
-    error = base::PLATFORM_FILE_ERROR_FAILED;
+    error = base::File::FILE_ERROR_FAILED;
 
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return HandleDeviceFileError(snapshot_request_info->error_callback, error);
 
-  base::PlatformFileInfo snapshot_file_info(file_info);
+  base::File::Info snapshot_file_info(file_info);
   // Modify the last modified time to null. This prevents the time stamp
   // verfication in LocalFileStreamReader.
   snapshot_file_info.last_modified = base::Time();
 
   current_snapshot_request_info_.reset(snapshot_request_info.release());
   if (file_info.size == 0) {
     // Empty snapshot file.
     return OnDidWriteDataIntoSnapshotFile(
         snapshot_file_info, current_snapshot_request_info_->snapshot_file_path);
   }
   WriteDataIntoSnapshotFile(snapshot_file_info);
 }
 
 void MTPDeviceDelegateImplLinux::OnDidReadDirectory(
     const ReadDirectorySuccessCallback& success_callback,
     const fileapi::AsyncFileUtil::EntryList& file_list) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   success_callback.Run(file_list, false /*no more entries*/);
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidWriteDataIntoSnapshotFile(
-    const base::PlatformFileInfo& file_info,
+    const base::File::Info& file_info,
     const base::FilePath& snapshot_file_path) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(current_snapshot_request_info_.get());
   DCHECK(task_in_progress_);
   current_snapshot_request_info_->success_callback.Run(
       file_info, snapshot_file_path);
   task_in_progress_ = false;
   current_snapshot_request_info_.reset();
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplLinux::OnWriteDataIntoSnapshotFileError(
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(current_snapshot_request_info_.get());
   DCHECK(task_in_progress_);
   current_snapshot_request_info_->error_callback.Run(error);
   task_in_progress_ = false;
   current_snapshot_request_info_.reset();
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplLinux::HandleDeviceFileError(
     const ErrorCallback& error_callback,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   error_callback.Run(error);
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void CreateMTPDeviceAsyncDelegate(
     const std::string& device_location,
     const CreateMTPDeviceAsyncDelegateCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   callback.Run(new MTPDeviceDelegateImplLinux(device_location));
 }