Replace FileUtilProxy with FileProxy in renderer_host/pepper

content/browser/renderer_host/pepper/pepper_file_io_host.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 "content/browser/renderer_host/pepper/pepper_file_io_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/files/file_util_proxy.h"
@@ skipping 68 matching lines @@
 }
 
 }  // namespace
 
 PepperFileIOHost::PepperFileIOHost(BrowserPpapiHostImpl* host,
                                    PP_Instance instance,
                                    PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       browser_ppapi_host_(host),
       render_process_host_(NULL),
-      file_(base::kInvalidPlatformFileValue),
+      file_(BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)),
       open_flags_(0),
       file_system_type_(PP_FILESYSTEMTYPE_INVALID),
       max_written_offset_(0),
       check_quota_(false),
       weak_factory_(this) {
   int unused;
   if (!host->GetRenderFrameIDsForInstance(
           instance, &render_process_id_, &unused)) {
     render_process_id_ = -1;
   }
-  file_message_loop_ =
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
 }
 
 PepperFileIOHost::~PepperFileIOHost() {}
 
 int32_t PepperFileIOHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   PPAPI_BEGIN_MESSAGE_MAP(PepperFileIOHost, msg)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FileIO_Open, OnHostMsgOpen)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FileIO_Touch, OnHostMsgTouch)
@@ skipping 146 matching lines @@
     }
   }
 
   ExecutePlatformOpenFileCallback(
       reply_context, result, base::PassPlatformFile(&file), true);
 }
 
 void PepperFileIOHost::GotResolvedRenderProcessId(
     ppapi::host::ReplyMessageContext reply_context,
     base::FilePath path,
-    int platform_file_flags,
+    int file_flags,
     base::ProcessId resolved_render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   resolved_render_process_id_ = resolved_render_process_id;
-  base::FileUtilProxy::CreateOrOpen(
-      file_message_loop_,
+  file_.CreateOrOpen(
       path,
-      platform_file_flags,
-      base::Bind(&PepperFileIOHost::ExecutePlatformOpenFileCallback,
+      file_flags,
+      base::Bind(&PepperFileIOHost::OnOpenProxyCallback,
                  weak_factory_.GetWeakPtr(),
                  reply_context));
 }
 
 int32_t PepperFileIOHost::OnHostMsgTouch(
     ppapi::host::HostMessageContext* context,
     PP_Time last_access_time,
     PP_Time last_modified_time) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
-  if (!base::FileUtilProxy::Touch(
-          file_message_loop_,
-          file_,
+  if (!file_.SetTimes(
           PPTimeToTime(last_access_time),
           PPTimeToTime(last_modified_time),
           base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
                      weak_factory_.GetWeakPtr(),
-                     context->MakeReplyMessageContext())))
+                     context->MakeReplyMessageContext()))) {
     return PP_ERROR_FAILED;
+  }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgSetLength(
     ppapi::host::HostMessageContext* context,
     int64_t length) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
   if (length < 0)
     return PP_ERROR_BADARGUMENT;
 
   // Quota checks are performed on the plugin side, in order to use the same
   // quota reservation and request system as Write.
 
-  if (!base::FileUtilProxy::Truncate(
-          file_message_loop_,
-          file_,
+  if (!file_.SetLength(
           length,
           base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
                      weak_factory_.GetWeakPtr(),
-                     context->MakeReplyMessageContext())))
+                     context->MakeReplyMessageContext()))) {
     return PP_ERROR_FAILED;
+  }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgFlush(
     ppapi::host::HostMessageContext* context) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
-  if (!base::FileUtilProxy::Flush(
-          file_message_loop_,
-          file_,
+  if (!file_.Flush(
           base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback,
                      weak_factory_.GetWeakPtr(),
-                     context->MakeReplyMessageContext())))
+                     context->MakeReplyMessageContext()))) {
     return PP_ERROR_FAILED;
+  }
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperFileIOHost::OnHostMsgClose(
     ppapi::host::HostMessageContext* context,
     const ppapi::FileGrowth& file_growth) {
   if (check_quota_) {
     file_system_host_->CloseQuotaFile(this, file_growth);
     check_quota_ = false;
   }
 
-  if (file_ != base::kInvalidPlatformFileValue) {
-    base::FileUtilProxy::Close(file_message_loop_,
-                               file_,
-                               base::Bind(&PepperFileIOHost::DidCloseFile,
-                                          weak_factory_.GetWeakPtr()));
-    file_ = base::kInvalidPlatformFileValue;
+  if (file_.IsValid()) {
+    file_.Close(base::Bind(&PepperFileIOHost::DidCloseFile,
+                           weak_factory_.GetWeakPtr()));
   }
   return PP_OK;
 }
 
 void PepperFileIOHost::DidOpenQuotaFile(
     ppapi::host::ReplyMessageContext reply_context,
     base::PlatformFile file,
     int64_t max_written_offset) {
   max_written_offset_ = max_written_offset;
 
@@ skipping 45 matching lines @@
 }
 
 void PepperFileIOHost::ExecutePlatformGeneralCallback(
     ppapi::host::ReplyMessageContext reply_context,
     base::File::Error error_code) {
   reply_context.params.set_result(ppapi::FileErrorToPepperError(error_code));
   host()->SendReply(reply_context, PpapiPluginMsg_FileIO_GeneralReply());
   state_manager_.SetOperationFinished();
 }
 
+// TODO(rvargas): this method should go away when FileApi moves to use File.
 void PepperFileIOHost::ExecutePlatformOpenFileCallback(
     ppapi::host::ReplyMessageContext reply_context,
     base::File::Error error_code,
     base::PassPlatformFile file,
     bool unused_created) {
+  DCHECK(!file_.IsValid());
+  file_.SetFile(base::File(file.ReleaseValue()));
+
+  OnOpenProxyCallback(reply_context, error_code);
+}
+
+void PepperFileIOHost::OnOpenProxyCallback(
+    ppapi::host::ReplyMessageContext reply_context,
+    base::File::Error error_code) {
   int32_t pp_error = ppapi::FileErrorToPepperError(error_code);
-  DCHECK(file_ == base::kInvalidPlatformFileValue);
-  file_ = file.ReleaseValue();
-
-  if (file_ != base::kInvalidPlatformFileValue &&
-      !AddFileToReplyContext(open_flags_, &reply_context))
+  if (file_.IsValid() && !AddFileToReplyContext(open_flags_, &reply_context))
     pp_error = PP_ERROR_FAILED;
 
   PP_Resource quota_file_system = 0;
   if (pp_error == PP_OK) {
     state_manager_.SetOpenSucceed();
     // A non-zero resource id signals the plugin side to check quota.
     if (check_quota_)
       quota_file_system = file_system_host_->pp_resource();
   }
 
@@ skipping 11 matching lines @@
 
 bool PepperFileIOHost::AddFileToReplyContext(
     int32_t open_flags,
     ppapi::host::ReplyMessageContext* reply_context) const {
   base::ProcessId plugin_process_id =
       base::GetProcId(browser_ppapi_host_->GetPluginProcessHandle());
   if (plugin_process_id == base::kNullProcessId)
     plugin_process_id = resolved_render_process_id_;
 
   IPC::PlatformFileForTransit transit_file =
-      BrokerGetFileHandleForProcess(file_, plugin_process_id, false);
+      BrokerGetFileHandleForProcess(file_.GetPlatformFile(), plugin_process_id,
+                                    false);
   if (transit_file == IPC::InvalidPlatformFileForTransit())
     return false;
 
   ppapi::proxy::SerializedHandle file_handle;
   // A non-zero resource id signals NaClIPCAdapter to create a NaClQuotaDesc.
   PP_Resource quota_file_io = check_quota_ ? pp_resource() : 0;
   file_handle.set_file_handle(transit_file, open_flags, quota_file_io);
   reply_context->params.AppendHandle(file_handle);
   return true;
 }
 
 }  // namespace content