Convert Media Galleries to use base::File

ppapi/proxy/file_io_resource.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 "ppapi/proxy/file_io_resource.h"
 
 #include "base/bind.h"
 #include "base/task_runner_util.h"
 #include "ipc/ipc_message.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 39 matching lines @@
 
 FileIOResource::QueryOp::QueryOp(scoped_refptr<FileHandleHolder> file_handle)
     : file_handle_(file_handle) {
   DCHECK(file_handle_);
 }
 
 FileIOResource::QueryOp::~QueryOp() {
 }
 
 int32_t FileIOResource::QueryOp::DoWork() {
-  return base::GetPlatformFileInfo(file_handle_->raw_handle(), &file_info_) ?
-      PP_OK : PP_ERROR_FAILED;
+  // TODO(rvargas): Convert this code to use base::File.
+  if (base::GetPlatformFileInfo(
+         file_handle_->raw_handle(),
+         reinterpret_cast<base::PlatformFileInfo*>(&file_info_))) {
+    return PP_OK;
+  }
+  return PP_ERROR_FAILED;
 }
 
 FileIOResource::ReadOp::ReadOp(scoped_refptr<FileHandleHolder> file_handle,
                                int64_t offset,
                                int32_t bytes_to_read)
   : file_handle_(file_handle),
     offset_(offset),
     bytes_to_read_(bytes_to_read) {
   DCHECK(file_handle_);
 }
@@ skipping 108 matching lines @@
   if (!info)
     return PP_ERROR_BADARGUMENT;
   if (!FileHandleHolder::IsValid(file_handle_))
     return PP_ERROR_FAILED;
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 
   // If the callback is blocking, perform the task on the calling thread.
   if (callback->is_blocking()) {
     int32_t result = PP_ERROR_FAILED;
-    base::PlatformFileInfo file_info;
+    base::File::Info file_info;
     // The plugin could release its reference to this instance when we release
     // the proxy lock below.
     scoped_refptr<FileIOResource> protect(this);
     {
       // Release the proxy lock while making a potentially slow file call.
       ProxyAutoUnlock unlock;
-      if (base::GetPlatformFileInfo(file_handle_->raw_handle(), &file_info))
+      // TODO(rvargas): Convert this code to base::File.
+      if (base::GetPlatformFileInfo(
+              file_handle_->raw_handle(),
+              reinterpret_cast<base::PlatformFileInfo*>(&file_info))) {
         result = PP_OK;
+      }
     }
     if (result == PP_OK) {
       // This writes the file info into the plugin's PP_FileInfo struct.
-      ppapi::PlatformFileInfoToPepperFileInfo(file_info,
-                                              file_system_type_,
-                                              info);
+      ppapi::FileInfoToPepperFileInfo(file_info,
+                                      file_system_type_,
+                                      info);
     }
     state_manager_.SetOperationFinished();
     return result;
   }
 
   // For the non-blocking case, post a task to the file thread and add a
   // completion task to write the result.
   scoped_refptr<QueryOp> query_op(new QueryOp(file_handle_));
   base::PostTaskAndReplyWithResult(
       PpapiGlobals::Get()->GetFileTaskRunner(),
@@ skipping 299 matching lines @@
 }
 
 int32_t FileIOResource::OnQueryComplete(scoped_refptr<QueryOp> query_op,
                                         PP_FileInfo* info,
                                         int32_t result) {
   DCHECK(state_manager_.get_pending_operation() ==
          FileIOStateManager::OPERATION_EXCLUSIVE);
 
   if (result == PP_OK) {
     // This writes the file info into the plugin's PP_FileInfo struct.
-    ppapi::PlatformFileInfoToPepperFileInfo(query_op->file_info(),
-                                            file_system_type_,
-                                            info);
+    ppapi::FileInfoToPepperFileInfo(query_op->file_info(),
+                                    file_system_type_,
+                                    info);
   }
   state_manager_.SetOperationFinished();
   return result;
 }
 
 int32_t FileIOResource::OnReadComplete(scoped_refptr<ReadOp> read_op,
                                        PP_ArrayOutput array_output,
                                        int32_t result) {
   DCHECK(state_manager_.get_pending_operation() ==
          FileIOStateManager::OPERATION_READ);
@@ skipping 121 matching lines @@
   *output_handle = IPC::PlatformFileForTransitToPlatformFile(transit_file);
 
   // End this operation now, so the user's callback can execute another FileIO
   // operation, assuming there are no other pending operations.
   state_manager_.SetOperationFinished();
   callback->Run(result);
 }
 
 }  // namespace proxy
 }  // namespace ppapi