Pepper: Move FileIO host from renderer to browser.

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 60 matching lines @@
 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_);
 }
 
 FileIOResource::FileIOResource(Connection connection, PP_Instance instance)
     : PluginResource(connection, instance),
       file_system_type_(PP_FILESYSTEMTYPE_INVALID) {
-  SendCreate(RENDERER, PpapiHostMsg_FileIO_Create());
+  SendCreate(BROWSER, PpapiHostMsg_FileIO_Create());
 }
 
 FileIOResource::~FileIOResource() {
 }
 
 PPB_FileIO_API* FileIOResource::AsPPB_FileIO_API() {
   return this;
 }
 
 int32_t FileIOResource::Open(PP_Resource file_ref,
@@ skipping 16 matching lines @@
 
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, false);
   if (rv != PP_OK)
     return rv;
 
   // Take a reference on the FileRef resource while we're opening the file; we
   // don't want the plugin destroying it during the Open operation.
   file_ref_ = enter.resource();
 
-  Call<PpapiPluginMsg_FileIO_OpenReply>(RENDERER,
+  Call<PpapiPluginMsg_FileIO_OpenReply>(BROWSER,
       PpapiHostMsg_FileIO_Open(
           file_ref,
           open_flags),
       base::Bind(&FileIOResource::OnPluginMsgOpenFileComplete, this,
                  callback));
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
@@ skipping 36 matching lines @@
 }
 
 int32_t FileIOResource::Touch(PP_Time last_access_time,
                               PP_Time last_modified_time,
                               scoped_refptr<TrackedCallback> callback) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
-  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(BROWSER,
       PpapiHostMsg_FileIO_Touch(last_access_time, last_modified_time),
       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
                  callback));
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FileIOResource::Read(int64_t offset,
                              char* buffer,
@@ skipping 28 matching lines @@
                               int32_t bytes_to_write,
                               scoped_refptr<TrackedCallback> callback) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_WRITE, true);
   if (rv != PP_OK)
     return rv;
 
   // TODO(brettw) it would be nice to use a shared memory buffer for large
   // writes rather than having to copy to a string (which will involve a number
   // of extra copies to serialize over IPC).
-  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(BROWSER,
       PpapiHostMsg_FileIO_Write(offset, std::string(buffer, bytes_to_write)),
       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
                  callback));
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_WRITE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FileIOResource::SetLength(int64_t length,
                                   scoped_refptr<TrackedCallback> callback) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
-  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(BROWSER,
       PpapiHostMsg_FileIO_SetLength(length),
       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
                  callback));
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FileIOResource::Flush(scoped_refptr<TrackedCallback> callback) {
   int32_t rv = state_manager_.CheckOperationState(
       FileIOStateManager::OPERATION_EXCLUSIVE, true);
   if (rv != PP_OK)
     return rv;
 
-  Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
+  Call<PpapiPluginMsg_FileIO_GeneralReply>(BROWSER,
       PpapiHostMsg_FileIO_Flush(),
       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
                  callback));
 
   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void FileIOResource::Close() {
   if (file_handle_) {
     file_handle_ = NULL;
   }
-  Post(RENDERER, PpapiHostMsg_FileIO_Close());
+  Post(BROWSER, PpapiHostMsg_FileIO_Close());
 }
 
 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>(RENDERER,
+  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) {
@@ skipping 141 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