Convert Media Galleries to use base::File

chrome/browser/media_galleries/win/mtp_device_delegate_impl_win.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.
 //
 // MTPDeviceDelegateImplWin implementation.
 
 #include "chrome/browser/media_galleries/win/mtp_device_delegate_impl_win.h"
 
 #include <portabledevice.h>
 
@@ skipping 130 matching lines @@
   bool init_succeeded = device.get() != NULL;
   if (init_succeeded) {
     PortableDeviceMapService::GetInstance()->AddPortableDevice(
         registered_device_path, device.get());
   }
   return init_succeeded;
 }
 
 // Gets the |file_path| details from the MTP device specified by the
 // |device_info.registered_device_path|. On success, |error| is set to
-// base::PLATFORM_FILE_OK and fills in |file_info|. On failure, |error| is set
+// base::File::FILE_OK and fills in |file_info|. On failure, |error| is set
 // to corresponding platform file error and |file_info| is not set.
-base::PlatformFileError GetFileInfoOnBlockingPoolThread(
+base::File::Error GetFileInfoOnBlockingPoolThread(
     const MTPDeviceDelegateImplWin::StorageDeviceInfo& device_info,
     const base::FilePath& file_path,
-    base::PlatformFileInfo* file_info) {
+    base::File::Info* file_info) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!device_info.registered_device_path.empty());
   DCHECK(!file_path.empty());
   DCHECK(file_info);
   IPortableDevice* device =
       PortableDeviceMapService::GetInstance()->GetPortableDevice(
           device_info.registered_device_path);
   if (!device)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   base::string16 object_id =
       GetFileObjectIdFromPathOnBlockingPoolThread(device_info, file_path);
   if (object_id.empty())
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
   return media_transfer_protocol::GetFileEntryInfo(device, object_id,
                                                    file_info);
 }
 
 // Reads the |root| directory file entries on a blocking pool thread. On
-// success, |error| is set to base::PLATFORM_FILE_OK and |entries| contains the
+// success, |error| is set to base::File::FILE_OK and |entries| contains the
 // directory file entries. On failure, |error| is set to platform file error
 // and |entries| is not set.
-base::PlatformFileError ReadDirectoryOnBlockingPoolThread(
+base::File::Error ReadDirectoryOnBlockingPoolThread(
     const MTPDeviceDelegateImplWin::StorageDeviceInfo& device_info,
     const base::FilePath& root,
     fileapi::AsyncFileUtil::EntryList* entries) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!root.empty());
   DCHECK(entries);
-  base::PlatformFileInfo file_info;
-  base::PlatformFileError error = GetFileInfoOnBlockingPoolThread(device_info,
-                                                                  root,
-                                                                  &file_info);
-  if (error != base::PLATFORM_FILE_OK)
+  base::File::Info file_info;
+  base::File::Error error = GetFileInfoOnBlockingPoolThread(device_info, root,
+                                                            &file_info);
+  if (error != base::File::FILE_OK)
     return error;
 
   if (!file_info.is_directory)
-    return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+    return base::File::FILE_ERROR_NOT_A_DIRECTORY;
 
   base::FilePath current;
   scoped_ptr<MTPDeviceObjectEnumerator> file_enum =
       CreateFileEnumeratorOnBlockingPoolThread(device_info, root);
   if (!file_enum)
     return error;
 
   while (!(current = file_enum->Next()).empty()) {
     fileapi::DirectoryEntry entry;
     entry.is_directory = file_enum->IsDirectory();
     entry.name = fileapi::VirtualPath::BaseName(current).value();
     entry.size = file_enum->Size();
     entry.last_modified_time = file_enum->LastModifiedTime();
     entries->push_back(entry);
   }
   return error;
 }
 
 // Gets the device file stream object on a blocking pool thread.
 // |device_info| contains the device storage partition details.
-// On success, returns base::PLATFORM_FILE_OK and file stream details are set in
+// On success, returns base::File::FILE_OK and file stream details are set in
 // |file_details|. On failure, returns a platform file error and file stream
 // details are not set in |file_details|.
-base::PlatformFileError GetFileStreamOnBlockingPoolThread(
+base::File::Error GetFileStreamOnBlockingPoolThread(
     const MTPDeviceDelegateImplWin::StorageDeviceInfo& device_info,
     SnapshotFileDetails* file_details) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(file_details);
   DCHECK(!file_details->request_info().device_file_path.empty());
   DCHECK(!file_details->request_info().snapshot_file_path.empty());
   IPortableDevice* device =
       PortableDeviceMapService::GetInstance()->GetPortableDevice(
           device_info.registered_device_path);
   if (!device)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
   base::string16 file_object_id =
       GetFileObjectIdFromPathOnBlockingPoolThread(
           device_info, file_details->request_info().device_file_path);
   if (file_object_id.empty())
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::File::FILE_ERROR_FAILED;
 
-  base::PlatformFileInfo file_info;
-  base::PlatformFileError error =
+  base::File::Info file_info;
+  base::File::Error error =
       GetFileInfoOnBlockingPoolThread(
           device_info,
           file_details->request_info().device_file_path,
           &file_info);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return error;
 
   DWORD optimal_transfer_size = 0;
   base::win::ScopedComPtr<IStream> file_stream;
   if (file_info.size > 0) {
     HRESULT hr = media_transfer_protocol::GetFileStreamForObject(
         device,
         file_object_id,
         file_stream.Receive(),
         &optimal_transfer_size);
     if (hr != S_OK)
-      return base::PLATFORM_FILE_ERROR_FAILED;
+      return base::File::FILE_ERROR_FAILED;
   }
 
   // LocalFileStreamReader is used to read the contents of the snapshot file.
   // Snapshot file modification time does not match the last modified time
   // of the original media file. Therefore, set the last modified time to null
   // in order to avoid the verification in LocalFileStreamReader.
   //
   // Users will use HTML5 FileSystem Entry getMetadata() interface to get the
   // actual last modified time of the media file.
   file_info.last_modified = base::Time();
@@ skipping 75 matching lines @@
     const base::string16& registered_device_path,
     const base::string16& storage_object_id)
     : pnp_device_id(pnp_device_id),
       registered_device_path(registered_device_path),
       storage_object_id(storage_object_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 }
 
 MTPDeviceDelegateImplWin::PendingTaskInfo::PendingTaskInfo(
     const tracked_objects::Location& location,
-    const base::Callback<base::PlatformFileError(void)>& task,
-    const base::Callback<void(base::PlatformFileError)>& reply)
+    const base::Callback<base::File::Error(void)>& task,
+    const base::Callback<void(base::File::Error)>& reply)
     : location(location),
       task(task),
       reply(reply) {
 }
 
 MTPDeviceDelegateImplWin::MTPDeviceDelegateImplWin(
     const base::string16& registered_device_path,
     const base::string16& pnp_device_id,
     const base::string16& storage_object_id)
     : storage_device_info_(pnp_device_id, registered_device_path,
@@ skipping 12 matching lines @@
 MTPDeviceDelegateImplWin::~MTPDeviceDelegateImplWin() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 }
 
 void MTPDeviceDelegateImplWin::GetFileInfo(
     const base::FilePath& file_path,
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(!file_path.empty());
-  base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
+  base::File::Info* file_info = new base::File::Info;
   EnsureInitAndRunTask(
       PendingTaskInfo(FROM_HERE,
                       base::Bind(&GetFileInfoOnBlockingPoolThread,
                                  storage_device_info_,
                                  file_path,
                                  base::Unretained(file_info)),
                       base::Bind(&MTPDeviceDelegateImplWin::OnGetFileInfo,
                                  weak_ptr_factory_.GetWeakPtr(),
                                  success_callback,
                                  error_callback,
@@ skipping 128 matching lines @@
 void MTPDeviceDelegateImplWin::OnInitCompleted(bool succeeded) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   init_state_ = succeeded ? INITIALIZED : UNINITIALIZED;
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplWin::OnGetFileInfo(
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback,
-    base::PlatformFileInfo* file_info,
-    base::PlatformFileError error) {
+    base::File::Info* file_info,
+    base::File::Error error) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(file_info);
-  if (error == base::PLATFORM_FILE_OK)
+  if (error == base::File::FILE_OK)
     success_callback.Run(*file_info);
   else
     error_callback.Run(error);
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplWin::OnDidReadDirectory(
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     fileapi::AsyncFileUtil::EntryList* file_list,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(file_list);
-  if (error == base::PLATFORM_FILE_OK)
+  if (error == base::File::FILE_OK)
     success_callback.Run(*file_list, false /*no more entries*/);
   else
     error_callback.Run(error);
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplWin::OnGetFileStream(
     scoped_ptr<SnapshotFileDetails> file_details,
-    base::PlatformFileError error) {
+    base::File::Error error) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(file_details);
   DCHECK(!file_details->request_info().device_file_path.empty());
   DCHECK(!file_details->request_info().snapshot_file_path.empty());
   DCHECK(!current_snapshot_details_.get());
-  if (error != base::PLATFORM_FILE_OK) {
+  if (error != base::File::FILE_OK) {
     file_details->request_info().error_callback.Run(error);
     task_in_progress_ = false;
     ProcessNextPendingRequest();
     return;
   }
   DCHECK(file_details->file_info().size == 0 ||
          file_details->device_file_stream());
   current_snapshot_details_.reset(file_details.release());
   WriteDataChunkIntoSnapshotFile();
 }
@@ skipping 28 matching lines @@
   if (should_continue) {
     WriteDataChunkIntoSnapshotFile();
     return;
   }
   if (succeeded) {
     current_snapshot_details_->request_info().success_callback.Run(
         current_snapshot_details_->file_info(),
         current_snapshot_details_->request_info().snapshot_file_path);
   } else {
     current_snapshot_details_->request_info().error_callback.Run(
-        base::PLATFORM_FILE_ERROR_FAILED);
+        base::File::FILE_ERROR_FAILED);
   }
   task_in_progress_ = false;
   current_snapshot_details_.reset();
   ProcessNextPendingRequest();
 }