Remove PlatformFile from ppapi

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 21 matching lines @@
 // 32MB. This is OK since the API specifies that it may perform a partial read
 // or write.
 static const int32_t kMaxReadWriteSize = 32 * 1024 * 1024;  // 32MB
 
 // An adapter to let Read() share the same implementation with ReadToArray().
 void* DummyGetDataBuffer(void* user_data, uint32_t count, uint32_t size) {
   return user_data;
 }
 
 // File thread task to close the file handle.
-void DoClose(base::PlatformFile file) {
-  base::ClosePlatformFile(file);
+void DoClose(base::File auto_close_file) {
 }
 
 }  // namespace
 
 namespace ppapi {
 namespace proxy {
 
-FileIOResource::QueryOp::QueryOp(scoped_refptr<FileHandleHolder> file_handle)
-    : file_handle_(file_handle) {
-  DCHECK(file_handle_);
+FileIOResource::QueryOp::QueryOp(scoped_refptr<FileHolder> file_holder)
+    : file_holder_(file_holder) {
+  DCHECK(file_holder_);
 }
 
 FileIOResource::QueryOp::~QueryOp() {
 }
 
 int32_t FileIOResource::QueryOp::DoWork() {
-  // TODO(rvargas): Convert this code to use base::File.
-  base::File file(file_handle_->raw_handle());
-  bool success = file.GetInfo(&file_info_);
-  file.TakePlatformFile();
-  return success ? PP_OK : PP_ERROR_FAILED;
+  return file_holder_->file()->GetInfo(&file_info_) ? PP_OK : PP_ERROR_FAILED;
 }
 
-FileIOResource::ReadOp::ReadOp(scoped_refptr<FileHandleHolder> file_handle,
+FileIOResource::ReadOp::ReadOp(scoped_refptr<FileHolder> file_holder,
                                int64_t offset,
                                int32_t bytes_to_read)
-  : file_handle_(file_handle),
+  : file_holder_(file_holder),
     offset_(offset),
     bytes_to_read_(bytes_to_read) {
-  DCHECK(file_handle_);
+  DCHECK(file_holder_);
 }
 
 FileIOResource::ReadOp::~ReadOp() {
 }
 
 int32_t FileIOResource::ReadOp::DoWork() {
   DCHECK(!buffer_.get());
   buffer_.reset(new char[bytes_to_read_]);
-  return base::ReadPlatformFile(
-      file_handle_->raw_handle(), offset_, buffer_.get(), bytes_to_read_);
+  return file_holder_->file()->Read(offset_, buffer_.get(), bytes_to_read_);
 }
 
-FileIOResource::WriteOp::WriteOp(scoped_refptr<FileHandleHolder> file_handle,
+FileIOResource::WriteOp::WriteOp(scoped_refptr<FileHolder> file_holder,
                                  int64_t offset,
                                  scoped_ptr<char[]> buffer,
                                  int32_t bytes_to_write,
                                  bool append)
-    : file_handle_(file_handle),
+    : file_holder_(file_holder),
       offset_(offset),
       buffer_(buffer.Pass()),
       bytes_to_write_(bytes_to_write),
       append_(append) {
 }
 
 FileIOResource::WriteOp::~WriteOp() {
 }
 
 int32_t FileIOResource::WriteOp::DoWork() {
   // In append mode, we can't call WritePlatformFile, since NaCl doesn't
   // implement fcntl, causing the function to call pwrite, which is incorrect.
   if (append_) {
-    return base::WritePlatformFileAtCurrentPos(
-        file_handle_->raw_handle(), buffer_.get(), bytes_to_write_);
+    return file_holder_->file()->WriteAtCurrentPos(buffer_.get(),
+                                                   bytes_to_write_);
   } else {
-    return base::WritePlatformFile(
-        file_handle_->raw_handle(), offset_, buffer_.get(), bytes_to_write_);
+    return file_holder_->file()->Write(offset_, buffer_.get(), bytes_to_write_);
   }
 }
 
 FileIOResource::FileIOResource(Connection connection, PP_Instance instance)
     : PluginResource(connection, instance),
       file_system_type_(PP_FILESYSTEMTYPE_INVALID),
       open_flags_(0),
       max_written_offset_(0),
       append_mode_write_amount_(0),
       check_quota_(false),
@@ skipping 56 matching lines @@
 }
 
 int32_t FileIOResource::Query(PP_FileInfo* info,
                               scoped_refptr<TrackedCallback> callback) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
   if (!info)
     return PP_ERROR_BADARGUMENT;
-  if (!FileHandleHolder::IsValid(file_handle_))
+  if (!FileHolder::IsValid(file_holder_))
     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::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;
-      // TODO(rvargas): Convert this code to base::File.
-      base::File file(file_handle_->raw_handle());
-      bool success = file.GetInfo(&file_info);
-      file.TakePlatformFile();
-      if (success)
+      if (file_holder_->file()->GetInfo(&file_info))
         result = PP_OK;
     }
     if (result == PP_OK) {
       // This writes the file info into the plugin's PP_FileInfo struct.
       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_));
+  scoped_refptr<QueryOp> query_op(new QueryOp(file_holder_));
   base::PostTaskAndReplyWithResult(
       PpapiGlobals::Get()->GetFileTaskRunner(),
       FROM_HERE,
       Bind(&FileIOResource::QueryOp::DoWork, query_op),
       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
   callback->set_completion_task(
       Bind(&FileIOResource::OnQueryComplete, this, query_op, info));
 
   return PP_OK_COMPLETIONPENDING;
 }
@@ skipping 44 matching lines @@
 }
 
 int32_t FileIOResource::Write(int64_t offset,
                               const char* buffer,
                               int32_t bytes_to_write,
                               scoped_refptr<TrackedCallback> callback) {
   if (!buffer)
     return PP_ERROR_FAILED;
   if (offset < 0 || bytes_to_write < 0)
     return PP_ERROR_FAILED;
-  if (!FileHandleHolder::IsValid(file_handle_))
+  if (!FileHolder::IsValid(file_holder_))
     return PP_ERROR_FAILED;
 
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_WRITE, true);
   if (rv != PP_OK)
     return rv;
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_WRITE);
 
   if (check_quota_) {
@@ skipping 105 matching lines @@
   if (called_close_)
     return;
 
   called_close_ = true;
   if (check_quota_) {
     check_quota_ = false;
     file_system_resource_->AsPPB_FileSystem_API()->CloseQuotaFile(
         pp_resource());
   }
 
-  if (file_handle_)
-    file_handle_ = NULL;
+  if (file_holder_)
+    file_holder_ = NULL;
 
   Post(BROWSER, PpapiHostMsg_FileIO_Close(
       FileGrowth(max_written_offset_, append_mode_write_amount_)));
 }
 
 int32_t FileIOResource::RequestOSFileHandle(
     PP_FileHandle* handle,
     scoped_refptr<TrackedCallback> callback) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
   Call<PpapiPluginMsg_FileIO_RequestOSFileHandleReply>(BROWSER,
       PpapiHostMsg_FileIO_RequestOSFileHandle(),
       base::Bind(&FileIOResource::OnPluginMsgRequestOSFileHandleComplete, this,
                  callback, handle));
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
-FileIOResource::FileHandleHolder::FileHandleHolder(PP_FileHandle file_handle)
-    : raw_handle_(file_handle) {
+FileIOResource::FileHolder::FileHolder(PP_FileHandle file_handle)
+    : file_(file_handle) {
 }
 
 // static
-bool FileIOResource::FileHandleHolder::IsValid(
-    const scoped_refptr<FileIOResource::FileHandleHolder>& handle) {
-  return handle && (handle->raw_handle() != base::kInvalidPlatformFileValue);
+bool FileIOResource::FileHolder::IsValid(
+    const scoped_refptr<FileIOResource::FileHolder>& handle) {
+  return handle && handle->file_.IsValid();
 }
 
-FileIOResource::FileHandleHolder::~FileHandleHolder() {
-  if (raw_handle_ != base::kInvalidPlatformFileValue) {
+FileIOResource::FileHolder::~FileHolder() {
+  if (file_.IsValid()) {
     base::TaskRunner* file_task_runner =
         PpapiGlobals::Get()->GetFileTaskRunner();
     file_task_runner->PostTask(FROM_HERE,
-                               base::Bind(&DoClose, raw_handle_));
+                               base::Bind(&DoClose, Passed(&file_)));
   }
 }
 
 int32_t FileIOResource::ReadValidated(int64_t offset,
                                       int32_t bytes_to_read,
                                       const PP_ArrayOutput& array_output,
                                       scoped_refptr<TrackedCallback> callback) {
   if (bytes_to_read < 0)
     return PP_ERROR_FAILED;
-  if (!FileHandleHolder::IsValid(file_handle_))
+  if (!FileHolder::IsValid(file_holder_))
     return PP_ERROR_FAILED;
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_READ);
 
   bytes_to_read = std::min(bytes_to_read, kMaxReadWriteSize);
   if (callback->is_blocking()) {
     char* buffer = static_cast<char*>(
         array_output.GetDataBuffer(array_output.user_data, bytes_to_read, 1));
     int32_t result = PP_ERROR_FAILED;
     // The plugin could release its reference to this instance when we release
     // the proxy lock below.
     scoped_refptr<FileIOResource> protect(this);
     if (buffer) {
       // Release the proxy lock while making a potentially slow file call.
       ProxyAutoUnlock unlock;
-      result = base::ReadPlatformFile(
-          file_handle_->raw_handle(), offset, buffer, bytes_to_read);
+      result = file_holder_->file()->Read(offset, buffer, bytes_to_read);
       if (result < 0)
         result = PP_ERROR_FAILED;
     }
     state_manager_.SetOperationFinished();
     return result;
   }
 
   // For the non-blocking case, post a task to the file thread.
   scoped_refptr<ReadOp> read_op(
-      new ReadOp(file_handle_, offset, bytes_to_read));
+      new ReadOp(file_holder_, offset, bytes_to_read));
   base::PostTaskAndReplyWithResult(
       PpapiGlobals::Get()->GetFileTaskRunner(),
       FROM_HERE,
       Bind(&FileIOResource::ReadOp::DoWork, read_op),
       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
   callback->set_completion_task(
       Bind(&FileIOResource::OnReadComplete, this, read_op, array_output));
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FileIOResource::WriteValidated(
     int64_t offset,
     const char* buffer,
     int32_t bytes_to_write,
     scoped_refptr<TrackedCallback> callback) {
   bool append = (open_flags_ & PP_FILEOPENFLAG_APPEND) != 0;
   if (callback->is_blocking()) {
     int32_t result;
     {
       // Release the proxy lock while making a potentially slow file call.
       ProxyAutoUnlock unlock;
       if (append) {
-        result = base::WritePlatformFileAtCurrentPos(
-            file_handle_->raw_handle(), buffer, bytes_to_write);
+        result = file_holder_->file()->WriteAtCurrentPos(buffer,
+                                                         bytes_to_write);
       } else {
-        result = base::WritePlatformFile(
-            file_handle_->raw_handle(), offset, buffer, bytes_to_write);
+        result = file_holder_->file()->Write(offset, buffer, bytes_to_write);
       }
     }
     if (result < 0)
       result = PP_ERROR_FAILED;
 
     state_manager_.SetOperationFinished();
     return result;
   }
 
   // For the non-blocking case, post a task to the file thread. We must copy the
   // plugin's buffer at this point.
   scoped_ptr<char[]> copy(new char[bytes_to_write]);
   memcpy(copy.get(), buffer, bytes_to_write);
   scoped_refptr<WriteOp> write_op(
-      new WriteOp(file_handle_, offset, copy.Pass(), bytes_to_write, append));
+      new WriteOp(file_holder_, offset, copy.Pass(), bytes_to_write, append));
   base::PostTaskAndReplyWithResult(
       PpapiGlobals::Get()->GetFileTaskRunner(),
       FROM_HERE,
       Bind(&FileIOResource::WriteOp::DoWork, write_op),
       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
   callback->set_completion_task(Bind(&FileIOResource::OnWriteComplete, this));
 
   return PP_OK_COMPLETIONPENDING;
 }
 
@@ skipping 71 matching lines @@
   }
 
   if (callback->is_blocking()) {
     int32_t result =
         WriteValidated(offset, buffer.get(), bytes_to_write, callback);
     DCHECK(result != PP_OK_COMPLETIONPENDING);
     callback->Run(result);
   } else {
     bool append = (open_flags_ & PP_FILEOPENFLAG_APPEND) != 0;
     scoped_refptr<WriteOp> write_op(new WriteOp(
-        file_handle_, offset, buffer.Pass(), bytes_to_write, append));
+        file_holder_, offset, buffer.Pass(), bytes_to_write, append));
     base::PostTaskAndReplyWithResult(
         PpapiGlobals::Get()->GetFileTaskRunner(),
         FROM_HERE,
         Bind(&FileIOResource::WriteOp::DoWork, write_op),
         RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
     callback->set_completion_task(Bind(&FileIOResource::OnWriteComplete, this));
   }
 }
 
 void FileIOResource::OnRequestSetLengthQuotaComplete(
@@ skipping 53 matching lines @@
     if (quota_file_system) {
       DCHECK(quota_file_system == file_system_resource_->pp_resource());
       check_quota_ = true;
       max_written_offset_ = max_written_offset;
       file_system_resource_->AsPPB_FileSystem_API()->OpenQuotaFile(
           pp_resource());
     }
 
     IPC::PlatformFileForTransit transit_file;
     if (params.TakeFileHandleAtIndex(0, &transit_file)) {
-      file_handle_ = new FileHandleHolder(
+      file_holder_ = new FileHolder(
           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);
 }
 
 void FileIOResource::OnPluginMsgRequestOSFileHandleComplete(
@@ skipping 15 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