diff options
Diffstat (limited to 'ppapi/proxy/ppb_file_io_proxy.cc')
| -rw-r--r-- | ppapi/proxy/ppb_file_io_proxy.cc | 442 |
1 files changed, 442 insertions, 0 deletions
diff --git a/ppapi/proxy/ppb_file_io_proxy.cc b/ppapi/proxy/ppb_file_io_proxy.cc new file mode 100644 index 0000000..0acd3ac --- /dev/null +++ b/ppapi/proxy/ppb_file_io_proxy.cc @@ -0,0 +1,442 @@ +// Copyright (c) 2011 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/ppb_file_io_proxy.h" + +#include "ppapi/c/pp_errors.h" +#include "ppapi/proxy/enter_proxy.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" +#include "ppapi/shared_impl/ppapi_globals.h" +#include "ppapi/shared_impl/ppb_file_io_shared.h" +#include "ppapi/shared_impl/resource.h" +#include "ppapi/shared_impl/resource_tracker.h" + +using ppapi::thunk::PPB_FileIO_API; +using ppapi::thunk::PPB_FileRef_API; + +namespace ppapi { +namespace proxy { + +namespace { + +// The maximum size we'll support reading in one chunk. The renderer process +// must allocate a buffer sized according to the request of the plugin. To +// keep things from getting out of control, we cap the read size to this value. +// This should generally be OK since the API specifies that it may perform a +// partial read. +static const int32_t kMaxReadSize = 33554432; // 32MB + +typedef EnterHostFromHostResourceForceCallback<PPB_FileIO_API> EnterHostFileIO; +typedef EnterPluginFromHostResource<PPB_FileIO_API> EnterPluginFileIO; + +class FileIO : public PPB_FileIO_Shared { + public: + explicit FileIO(const HostResource& host_resource); + virtual ~FileIO(); + + // PPB_FileIO_API implementation (not provided by FileIOImpl). + virtual void Close() OVERRIDE; + virtual int32_t GetOSFileDescriptor() OVERRIDE; + virtual int32_t WillWrite(int64_t offset, + int32_t bytes_to_write, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t WillSetLength(int64_t length, + PP_CompletionCallback callback) OVERRIDE; + + private: + // FileIOImpl overrides. + virtual int32_t OpenValidated(PP_Resource file_ref_resource, + PPB_FileRef_API* file_ref_api, + int32_t open_flags, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t QueryValidated(PP_FileInfo* info, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t TouchValidated(PP_Time last_access_time, + PP_Time last_modified_time, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t ReadValidated(int64_t offset, + char* buffer, + int32_t bytes_to_read, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t WriteValidated(int64_t offset, + const char* buffer, + int32_t bytes_to_write, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t SetLengthValidated(int64_t length, + PP_CompletionCallback callback) OVERRIDE; + virtual int32_t FlushValidated(PP_CompletionCallback callback) OVERRIDE; + + PluginDispatcher* GetDispatcher() const { + return PluginDispatcher::GetForResource(this); + } + + static const ApiID kApiID = API_ID_PPB_FILE_IO; + + DISALLOW_IMPLICIT_CONSTRUCTORS(FileIO); +}; + +FileIO::FileIO(const HostResource& host_resource) + : PPB_FileIO_Shared(host_resource) { +} + +FileIO::~FileIO() { + Close(); +} + +void FileIO::Close() { + if (file_open_) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Close(kApiID, + host_resource())); + } +} + +int32_t FileIO::GetOSFileDescriptor() { + return -1; +} + +int32_t FileIO::WillWrite(int64_t offset, + int32_t bytes_to_write, + PP_CompletionCallback callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_WillWrite( + kApiID, host_resource(), offset, bytes_to_write)); + RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileIO::WillSetLength(int64_t length, + PP_CompletionCallback callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_WillSetLength( + kApiID, host_resource(), length)); + RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileIO::OpenValidated(PP_Resource file_ref_resource, + PPB_FileRef_API* file_ref_api, + int32_t open_flags, + PP_CompletionCallback callback) { + Resource* file_ref_object = + PpapiGlobals::Get()->GetResourceTracker()->GetResource(file_ref_resource); + + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Open( + kApiID, host_resource(), file_ref_object->host_resource(), open_flags)); + RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileIO::QueryValidated(PP_FileInfo* info, + PP_CompletionCallback callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Query( + kApiID, host_resource())); + RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, info); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileIO::TouchValidated(PP_Time last_access_time, + PP_Time last_modified_time, + PP_CompletionCallback callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Touch( + kApiID, host_resource(), last_access_time, last_modified_time)); + RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileIO::ReadValidated(int64_t offset, + char* buffer, + int32_t bytes_to_read, + PP_CompletionCallback callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Read( + kApiID, host_resource(), offset, bytes_to_read)); + RegisterCallback(OPERATION_READ, callback, buffer, NULL); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileIO::WriteValidated(int64_t offset, + const char* buffer, + int32_t bytes_to_write, + PP_CompletionCallback callback) { + // 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). + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Write( + kApiID, host_resource(), offset, std::string(buffer, bytes_to_write))); + RegisterCallback(OPERATION_WRITE, callback, NULL, NULL); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileIO::SetLengthValidated(int64_t length, + PP_CompletionCallback callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_SetLength( + kApiID, host_resource(), length)); + RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileIO::FlushValidated(PP_CompletionCallback callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Flush( + kApiID, host_resource())); + RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL); + return PP_OK_COMPLETIONPENDING; +} + +} // namespace + +// ----------------------------------------------------------------------------- + +PPB_FileIO_Proxy::PPB_FileIO_Proxy(Dispatcher* dispatcher) + : InterfaceProxy(dispatcher), + callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { +} + +PPB_FileIO_Proxy::~PPB_FileIO_Proxy() { +} + +// static +PP_Resource PPB_FileIO_Proxy::CreateProxyResource(PP_Instance instance) { + PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance); + if (!dispatcher) + return 0; + + HostResource result; + dispatcher->Send(new PpapiHostMsg_PPBFileIO_Create(kApiID, instance, + &result)); + if (result.is_null()) + return 0; + return (new FileIO(result))->GetReference(); +} + +bool PPB_FileIO_Proxy::OnMessageReceived(const IPC::Message& msg) { + bool handled = true; + IPC_BEGIN_MESSAGE_MAP(PPB_FileIO_Proxy, msg) + // Plugin -> host message. + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Create, OnHostMsgCreate) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Open, OnHostMsgOpen) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Close, OnHostMsgClose) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Query, OnHostMsgQuery) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Touch, OnHostMsgTouch) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Read, OnHostMsgRead) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Write, OnHostMsgWrite) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_SetLength, OnHostMsgSetLength) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Flush, OnHostMsgFlush) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_WillWrite, OnHostMsgWillWrite) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_WillSetLength, + OnHostMsgWillSetLength) + + // Host -> plugin messages. + IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_GeneralComplete, + OnPluginMsgGeneralComplete) + IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_OpenFileComplete, + OnPluginMsgOpenFileComplete) + IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_QueryComplete, + OnPluginMsgQueryComplete) + IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_ReadComplete, + OnPluginMsgReadComplete) + IPC_MESSAGE_UNHANDLED(handled = false) + IPC_END_MESSAGE_MAP() + return handled; +} + +void PPB_FileIO_Proxy::OnHostMsgCreate(PP_Instance instance, + HostResource* result) { + thunk::EnterResourceCreation enter(instance); + if (enter.succeeded()) { + result->SetHostResource(instance, + enter.functions()->CreateFileIO(instance)); + } +} + +void PPB_FileIO_Proxy::OnHostMsgOpen(const HostResource& host_resource, + const HostResource& file_ref_resource, + int32_t open_flags) { + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::OpenFileCallbackCompleteInHost, host_resource); + if (enter.succeeded()) { + enter.SetResult(enter.object()->Open( + file_ref_resource.host_resource(), open_flags, enter.callback())); + } +} + +void PPB_FileIO_Proxy::OnHostMsgClose(const HostResource& host_resource) { + EnterHostFromHostResource<PPB_FileIO_API> enter(host_resource); + if (enter.succeeded()) + enter.object()->Close(); +} + +void PPB_FileIO_Proxy::OnHostMsgQuery(const HostResource& host_resource) { + // The callback will take charge of deleting the FileInfo. The contents must + // be defined so we don't send garbage to the plugin in the failure case. + PP_FileInfo* info = new PP_FileInfo; + memset(info, 0, sizeof(PP_FileInfo)); + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::QueryCallbackCompleteInHost, + host_resource, info); + if (enter.succeeded()) + enter.SetResult(enter.object()->Query(info, enter.callback())); +} + +void PPB_FileIO_Proxy::OnHostMsgTouch(const HostResource& host_resource, + PP_Time last_access_time, + PP_Time last_modified_time) { + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost, + host_resource); + if (enter.succeeded()) { + enter.SetResult(enter.object()->Touch(last_access_time, last_modified_time, + enter.callback())); + } +} + +void PPB_FileIO_Proxy::OnHostMsgRead(const HostResource& host_resource, + int64_t offset, + int32_t bytes_to_read) { + // Validate bytes_to_read before allocating below. This value is coming from + // the untrusted plugin. + bytes_to_read = std::min(bytes_to_read, kMaxReadSize); + if (bytes_to_read < 0) { + ReadCallbackCompleteInHost(PP_ERROR_FAILED, host_resource, + new std::string()); + return; + } + + // The callback will take charge of deleting the string. + std::string* dest = new std::string; + dest->resize(bytes_to_read); + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::ReadCallbackCompleteInHost, + host_resource, dest); + if (enter.succeeded()) { + enter.SetResult(enter.object()->Read(offset, + bytes_to_read > 0 ? &(*dest)[0] : NULL, + bytes_to_read, enter.callback())); + } +} + +void PPB_FileIO_Proxy::OnHostMsgWrite(const HostResource& host_resource, + int64_t offset, + const std::string& data) { + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost, + host_resource); + if (enter.succeeded()) { + enter.SetResult(enter.object()->Write(offset, data.data(), data.size(), + enter.callback())); + } +} + +void PPB_FileIO_Proxy::OnHostMsgSetLength(const HostResource& host_resource, + int64_t length) { + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost, + host_resource); + if (enter.succeeded()) + enter.SetResult(enter.object()->SetLength(length, enter.callback())); +} + +void PPB_FileIO_Proxy::OnHostMsgFlush(const HostResource& host_resource) { + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost, + host_resource); + if (enter.succeeded()) + enter.SetResult(enter.object()->Flush(enter.callback())); +} + +void PPB_FileIO_Proxy::OnHostMsgWillWrite(const HostResource& host_resource, + int64_t offset, + int32_t bytes_to_write) { + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost, + host_resource); + if (enter.succeeded()) { + enter.SetResult(enter.object()->WillWrite(offset, bytes_to_write, + enter.callback())); + } +} + +void PPB_FileIO_Proxy::OnHostMsgWillSetLength(const HostResource& host_resource, + int64_t length) { + EnterHostFileIO enter(host_resource, callback_factory_, + &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost, + host_resource); + if (enter.succeeded()) + enter.SetResult(enter.object()->WillSetLength(length, enter.callback())); +} + +void PPB_FileIO_Proxy::OnPluginMsgGeneralComplete( + const HostResource& host_resource, + int32_t result) { + EnterPluginFileIO enter(host_resource); + if (enter.succeeded()) + static_cast<FileIO*>(enter.object())->ExecuteGeneralCallback(result); +} + +void PPB_FileIO_Proxy::OnPluginMsgOpenFileComplete( + const HostResource& host_resource, + int32_t result) { + EnterPluginFileIO enter(host_resource); + if (enter.succeeded()) + static_cast<FileIO*>(enter.object())->ExecuteOpenFileCallback(result); +} + +void PPB_FileIO_Proxy::OnPluginMsgQueryComplete( + const HostResource& host_resource, + int32_t result, + const PP_FileInfo& info) { + EnterPluginFileIO enter(host_resource); + if (enter.succeeded()) + static_cast<FileIO*>(enter.object())->ExecuteQueryCallback(result, info); +} + +void PPB_FileIO_Proxy::OnPluginMsgReadComplete( + const HostResource& host_resource, + int32_t result, + const std::string& data) { + EnterPluginFileIO enter(host_resource); + if (enter.succeeded()) { + // The result code should contain the data size if it's positive. + DCHECK((result < 0 && data.size() == 0) || + result == static_cast<int32_t>(data.size())); + static_cast<FileIO*>(enter.object())->ExecuteReadCallback(result, + data.data()); + } +} + +void PPB_FileIO_Proxy::GeneralCallbackCompleteInHost( + int32_t pp_error, + const HostResource& host_resource) { + Send(new PpapiMsg_PPBFileIO_GeneralComplete(kApiID, host_resource, pp_error)); +} + +void PPB_FileIO_Proxy::OpenFileCallbackCompleteInHost( + int32_t pp_error, + const HostResource& host_resource) { + Send(new PpapiMsg_PPBFileIO_OpenFileComplete(kApiID, host_resource, + pp_error)); +} + +void PPB_FileIO_Proxy::QueryCallbackCompleteInHost( + int32_t pp_error, + const HostResource& host_resource, + PP_FileInfo* info) { + Send(new PpapiMsg_PPBFileIO_QueryComplete(kApiID, host_resource, pp_error, + *info)); + delete info; +} + +void PPB_FileIO_Proxy::ReadCallbackCompleteInHost( + int32_t pp_error, + const HostResource& host_resource, + std::string* data) { + // Only send the amount of data in the string that was actually read. + if (pp_error >= 0) { + DCHECK(pp_error <= static_cast<int32_t>(data->size())); + data->resize(pp_error); + } + Send(new PpapiMsg_PPBFileIO_ReadComplete(kApiID, host_resource, pp_error, + *data)); + delete data; +} + +} // namespace proxy +} // namespace ppapi |