ppapi/proxy/file_io_resource.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/proxy/file_io_resource.h"
   6
   7 #include "base/bind.h"
   8 #include "base/task_runner_util.h"
   9 #include "ipc/ipc_message.h"
  10 #include "ppapi/c/pp_errors.h"
  11 #include "ppapi/proxy/ppapi_messages.h"
  12 #include "ppapi/shared_impl/array_writer.h"
  13 #include "ppapi/shared_impl/file_type_conversion.h"
  14 #include "ppapi/shared_impl/ppapi_globals.h"
  15 #include "ppapi/shared_impl/proxy_lock.h"
  16 #include "ppapi/shared_impl/resource_tracker.h"
  17 #include "ppapi/thunk/enter.h"
  18 #include "ppapi/thunk/ppb_file_ref_api.h"
  19
  20 using ppapi::thunk::EnterResourceNoLock;
  21 using ppapi::thunk::PPB_FileIO_API;
  22 using ppapi::thunk::PPB_FileRef_API;
  23
  24 namespace {
  25
  26 // We must allocate a buffer sized according to the request of the plugin. To
  27 // reduce the chance of out-of-memory errors, we cap the read size to 32MB.
  28 // This is OK since the API specifies that it may perform a partial read.
  29 static const int32_t kMaxReadSize = 32 * 1024 * 1024;  // 32MB
  30
  31 // An adapter to let Read() share the same implementation with ReadToArray().
  32 void* DummyGetDataBuffer(void* user_data, uint32_t count, uint32_t size) {
  33   return user_data;
  34 }
  35
  36 // File thread task to close the file handle.
  37 void DoClose(base::PlatformFile file) {
  38   base::ClosePlatformFile(file);
  39 }
  40
  41 }  // namespace
  42
  43 namespace ppapi {
  44 namespace proxy {
  45
  46 FileIOResource::QueryOp::QueryOp(PP_FileHandle file_handle)
  47     : file_handle_(file_handle) {
  48 }
  49
  50 FileIOResource::QueryOp::~QueryOp() {
  51 }
  52
  53 int32_t FileIOResource::QueryOp::DoWork() {
  54   return base::GetPlatformFileInfo(file_handle_, &file_info_) ?
  55       PP_OK : PP_ERROR_FAILED;
  56 }
  57
  58 FileIOResource::ReadOp::ReadOp(PP_FileHandle file_handle,
  59                                int64_t offset,
  60                                int32_t bytes_to_read)
  61   : file_handle_(file_handle),
  62     offset_(offset),
  63     bytes_to_read_(bytes_to_read) {
  64 }
  65
  66 FileIOResource::ReadOp::~ReadOp() {
  67 }
  68
  69 int32_t FileIOResource::ReadOp::DoWork() {
  70   DCHECK(!buffer_.get());
  71   buffer_.reset(new char[bytes_to_read_]);
  72   return base::ReadPlatformFile(
  73       file_handle_, offset_, buffer_.get(), bytes_to_read_);
  74 }
  75
  76 FileIOResource::FileIOResource(Connection connection, PP_Instance instance)
  77     : PluginResource(connection, instance),
  78       file_handle_(base::kInvalidPlatformFileValue),
  79       file_system_type_(PP_FILESYSTEMTYPE_INVALID) {
  80   SendCreate(RENDERER, PpapiHostMsg_FileIO_Create());
  81 }
  82
  83 FileIOResource::~FileIOResource() {
  84   CloseFileHandle();
  85 }
  86
  87 PPB_FileIO_API* FileIOResource::AsPPB_FileIO_API() {
  88   return this;
  89 }
  90
  91 int32_t FileIOResource::Open(PP_Resource file_ref,
  92                              int32_t open_flags,
  93                              scoped_refptr<TrackedCallback> callback) {
  94   EnterResourceNoLock<PPB_FileRef_API> enter(file_ref, true);
  95   if (enter.failed())
  96     return PP_ERROR_BADRESOURCE;
  97
  98   PPB_FileRef_API* file_ref_api = enter.object();
  99   PP_FileSystemType type = file_ref_api->GetFileSystemType();
 100   if (type != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
 101       type != PP_FILESYSTEMTYPE_LOCALTEMPORARY &&
 102       type != PP_FILESYSTEMTYPE_EXTERNAL &&
 103       type != PP_FILESYSTEMTYPE_ISOLATED) {
 104     NOTREACHED();
 105     return PP_ERROR_FAILED;
 106   }
 107   file_system_type_ = type;
 108
 109   int32_t rv = state_manager_.CheckOperationState(
 110       FileIOStateManager::OPERATION_EXCLUSIVE, false);
 111   if (rv != PP_OK)
 112     return rv;
 113
 114   Call<PpapiPluginMsg_FileIO_OpenReply>(RENDERER,
 115       PpapiHostMsg_FileIO_Open(
 116           enter.resource()->host_resource().host_resource(),
 117           open_flags),
 118       base::Bind(&FileIOResource::OnPluginMsgOpenFileComplete, this,
 119                  callback));
 120
 121   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 122   return PP_OK_COMPLETIONPENDING;
 123 }
 124
 125 int32_t FileIOResource::Query(PP_FileInfo* info,
 126                               scoped_refptr<TrackedCallback> callback) {
 127   int32_t rv = state_manager_.CheckOperationState(
 128       FileIOStateManager::OPERATION_EXCLUSIVE, true);
 129   if (rv != PP_OK)
 130     return rv;
 131   if (!info)
 132     return PP_ERROR_BADARGUMENT;
 133   if (file_handle_ == base::kInvalidPlatformFileValue)
 134     return PP_ERROR_FAILED;
 135
 136   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 137   scoped_refptr<QueryOp> query_op(new QueryOp(file_handle_));
 138
 139   // If the callback is blocking, perform the task on the calling thread.
 140   if (callback->is_blocking()) {
 141     int32_t result;
 142     {
 143       // Release the proxy lock while making a potentially slow file call.
 144       ProxyAutoUnlock unlock;
 145       result = query_op->DoWork();
 146     }
 147     return OnQueryComplete(query_op, info, result);
 148   }
 149
 150   // For the non-blocking case, post a task to the file thread and add a
 151   // completion task to write the result.
 152   base::PostTaskAndReplyWithResult(
 153       PpapiGlobals::Get()->GetFileTaskRunner(pp_instance()),
 154       FROM_HERE,
 155       Bind(&FileIOResource::QueryOp::DoWork, query_op),
 156       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
 157   callback->set_completion_task(
 158       Bind(&FileIOResource::OnQueryComplete, this, query_op, info));
 159
 160   return PP_OK_COMPLETIONPENDING;
 161 }
 162
 163 int32_t FileIOResource::Touch(PP_Time last_access_time,
 164                               PP_Time last_modified_time,
 165                               scoped_refptr<TrackedCallback> callback) {
 166   int32_t rv = state_manager_.CheckOperationState(
 167       FileIOStateManager::OPERATION_EXCLUSIVE, true);
 168   if (rv != PP_OK)
 169     return rv;
 170
 171   Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
 172       PpapiHostMsg_FileIO_Touch(last_access_time, last_modified_time),
 173       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
 174                  callback));
 175
 176   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 177   return PP_OK_COMPLETIONPENDING;
 178 }
 179
 180 int32_t FileIOResource::Read(int64_t offset,
 181                              char* buffer,
 182                              int32_t bytes_to_read,
 183                              scoped_refptr<TrackedCallback> callback) {
 184   int32_t rv = state_manager_.CheckOperationState(
 185       FileIOStateManager::OPERATION_READ, true);
 186   if (rv != PP_OK)
 187     return rv;
 188
 189   PP_ArrayOutput output_adapter;
 190   output_adapter.GetDataBuffer = &DummyGetDataBuffer;
 191   output_adapter.user_data = buffer;
 192   return ReadValidated(offset, bytes_to_read, output_adapter, callback);
 193 }
 194
 195 int32_t FileIOResource::ReadToArray(int64_t offset,
 196                                     int32_t max_read_length,
 197                                     PP_ArrayOutput* array_output,
 198                                     scoped_refptr<TrackedCallback> callback) {
 199   DCHECK(array_output);
 200   int32_t rv = state_manager_.CheckOperationState(
 201       FileIOStateManager::OPERATION_READ, true);
 202   if (rv != PP_OK)
 203     return rv;
 204
 205   return ReadValidated(offset, max_read_length, *array_output, callback);
 206 }
 207
 208 int32_t FileIOResource::Write(int64_t offset,
 209                               const char* buffer,
 210                               int32_t bytes_to_write,
 211                               scoped_refptr<TrackedCallback> callback) {
 212   int32_t rv = state_manager_.CheckOperationState(
 213       FileIOStateManager::OPERATION_WRITE, true);
 214   if (rv != PP_OK)
 215     return rv;
 216
 217   // TODO(brettw) it would be nice to use a shared memory buffer for large
 218   // writes rather than having to copy to a string (which will involve a number
 219   // of extra copies to serialize over IPC).
 220   Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
 221       PpapiHostMsg_FileIO_Write(offset, std::string(buffer, bytes_to_write)),
 222       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
 223                  callback));
 224
 225   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_WRITE);
 226   return PP_OK_COMPLETIONPENDING;
 227 }
 228
 229 int32_t FileIOResource::SetLength(int64_t length,
 230                                   scoped_refptr<TrackedCallback> callback) {
 231   int32_t rv = state_manager_.CheckOperationState(
 232       FileIOStateManager::OPERATION_EXCLUSIVE, true);
 233   if (rv != PP_OK)
 234     return rv;
 235
 236   Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
 237       PpapiHostMsg_FileIO_SetLength(length),
 238       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
 239                  callback));
 240
 241   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 242   return PP_OK_COMPLETIONPENDING;
 243 }
 244
 245 int32_t FileIOResource::Flush(scoped_refptr<TrackedCallback> callback) {
 246   int32_t rv = state_manager_.CheckOperationState(
 247       FileIOStateManager::OPERATION_EXCLUSIVE, true);
 248   if (rv != PP_OK)
 249     return rv;
 250
 251   Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
 252       PpapiHostMsg_FileIO_Flush(),
 253       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
 254                  callback));
 255
 256   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 257   return PP_OK_COMPLETIONPENDING;
 258 }
 259
 260 void FileIOResource::Close() {
 261   CloseFileHandle();
 262   Post(RENDERER, PpapiHostMsg_FileIO_Close());
 263 }
 264
 265 int32_t FileIOResource::GetOSFileDescriptor() {
 266   int32_t file_descriptor;
 267   // Only available when running in process.
 268   SyncCall<PpapiPluginMsg_FileIO_GetOSFileDescriptorReply>(
 269       RENDERER, PpapiHostMsg_FileIO_GetOSFileDescriptor(), &file_descriptor);
 270   return file_descriptor;
 271 }
 272
 273 int32_t FileIOResource::RequestOSFileHandle(
 274     PP_FileHandle* handle,
 275     scoped_refptr<TrackedCallback> callback) {
 276   int32_t rv = state_manager_.CheckOperationState(
 277       FileIOStateManager::OPERATION_EXCLUSIVE, true);
 278   if (rv != PP_OK)
 279     return rv;
 280
 281   Call<PpapiPluginMsg_FileIO_RequestOSFileHandleReply>(RENDERER,
 282       PpapiHostMsg_FileIO_RequestOSFileHandle(),
 283       base::Bind(&FileIOResource::OnPluginMsgRequestOSFileHandleComplete, this,
 284                  callback, handle));
 285
 286   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 287   return PP_OK_COMPLETIONPENDING;
 288 }
 289
 290 int32_t FileIOResource::WillWrite(int64_t offset,
 291                                   int32_t bytes_to_write,
 292                                   scoped_refptr<TrackedCallback> callback) {
 293   Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
 294       PpapiHostMsg_FileIO_WillWrite(offset, bytes_to_write),
 295       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this, callback));
 296
 297   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 298   return PP_OK_COMPLETIONPENDING;
 299 }
 300
 301 int32_t FileIOResource::WillSetLength(int64_t length,
 302                                       scoped_refptr<TrackedCallback> callback) {
 303   Call<PpapiPluginMsg_FileIO_GeneralReply>(RENDERER,
 304       PpapiHostMsg_FileIO_WillSetLength(length),
 305       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this, callback));
 306
 307   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
 308   return PP_OK_COMPLETIONPENDING;
 309 }
 310
 311 int32_t FileIOResource::ReadValidated(int64_t offset,
 312                                       int32_t bytes_to_read,
 313                                       const PP_ArrayOutput& array_output,
 314                                       scoped_refptr<TrackedCallback> callback) {
 315   if (bytes_to_read < 0)
 316     return PP_ERROR_FAILED;
 317   if (file_handle_ == base::kInvalidPlatformFileValue)
 318     return PP_ERROR_FAILED;
 319
 320   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_READ);
 321
 322   bytes_to_read = std::min(bytes_to_read, kMaxReadSize);
 323   scoped_refptr<ReadOp> read_op(
 324       new ReadOp(file_handle_, offset, bytes_to_read));
 325   if (callback->is_blocking()) {
 326     int32_t result;
 327     {
 328       // Release the proxy lock while making a potentially slow file call.
 329       ProxyAutoUnlock unlock;
 330       result = read_op->DoWork();
 331     }
 332     return OnReadComplete(read_op, array_output, result);
 333   }
 334
 335   // For the non-blocking case, post a task to the file thread.
 336   base::PostTaskAndReplyWithResult(
 337       PpapiGlobals::Get()->GetFileTaskRunner(pp_instance()),
 338       FROM_HERE,
 339       Bind(&FileIOResource::ReadOp::DoWork, read_op),
 340       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
 341   callback->set_completion_task(
 342       Bind(&FileIOResource::OnReadComplete, this, read_op, array_output));
 343
 344   return PP_OK_COMPLETIONPENDING;
 345 }
 346
 347 void FileIOResource::CloseFileHandle() {
 348   if (file_handle_ != base::kInvalidPlatformFileValue) {
 349     // Close our local fd on the file thread.
 350     base::TaskRunner* file_task_runner =
 351         PpapiGlobals::Get()->GetFileTaskRunner(pp_instance());
 352     file_task_runner->PostTask(FROM_HERE,
 353                                base::Bind(&DoClose, file_handle_));
 354
 355     file_handle_ = base::kInvalidPlatformFileValue;
 356   }
 357 }
 358
 359 int32_t FileIOResource::OnQueryComplete(scoped_refptr<QueryOp> query_op,
 360                                         PP_FileInfo* info,
 361                                         int32_t result) {
 362   DCHECK(state_manager_.get_pending_operation() ==
 363          FileIOStateManager::OPERATION_EXCLUSIVE);
 364
 365   if (result == PP_OK) {
 366     // This writes the file info into the plugin's PP_FileInfo struct.
 367     ppapi::PlatformFileInfoToPepperFileInfo(query_op->file_info(),
 368                                             file_system_type_,
 369                                             info);
 370   }
 371   state_manager_.SetOperationFinished();
 372   return result;
 373 }
 374
 375 int32_t FileIOResource::OnReadComplete(scoped_refptr<ReadOp> read_op,
 376                                        PP_ArrayOutput array_output,
 377                                        int32_t result) {
 378   DCHECK(state_manager_.get_pending_operation() ==
 379          FileIOStateManager::OPERATION_READ);
 380   if (result >= 0) {
 381     ArrayWriter output;
 382     output.set_pp_array_output(array_output);
 383     if (output.is_valid())
 384       output.StoreArray(read_op->buffer(), result);
 385     else
 386       result = PP_ERROR_FAILED;
 387   } else {
 388     // The read operation failed.
 389     result = PP_ERROR_FAILED;
 390   }
 391   state_manager_.SetOperationFinished();
 392   return result;
 393 }
 394
 395 void FileIOResource::OnPluginMsgGeneralComplete(
 396     scoped_refptr<TrackedCallback> callback,
 397     const ResourceMessageReplyParams& params) {
 398   DCHECK(state_manager_.get_pending_operation() ==
 399          FileIOStateManager::OPERATION_EXCLUSIVE ||
 400          state_manager_.get_pending_operation() ==
 401          FileIOStateManager::OPERATION_WRITE);
 402   // End this operation now, so the user's callback can execute another FileIO
 403   // operation, assuming there are no other pending operations.
 404   state_manager_.SetOperationFinished();
 405   callback->Run(params.result());
 406 }
 407
 408 void FileIOResource::OnPluginMsgOpenFileComplete(
 409     scoped_refptr<TrackedCallback> callback,
 410     const ResourceMessageReplyParams& params) {
 411   DCHECK(state_manager_.get_pending_operation() ==
 412          FileIOStateManager::OPERATION_EXCLUSIVE);
 413   if (params.result() == PP_OK)
 414     state_manager_.SetOpenSucceed();
 415
 416   int32_t result = params.result();
 417   IPC::PlatformFileForTransit transit_file;
 418   if ((result == PP_OK) && params.TakeFileHandleAtIndex(0, &transit_file))
 419     file_handle_ = IPC::PlatformFileForTransitToPlatformFile(transit_file);
 420   // End this operation now, so the user's callback can execute another FileIO
 421   // operation, assuming there are no other pending operations.
 422   state_manager_.SetOperationFinished();
 423   callback->Run(result);
 424 }
 425
 426 void FileIOResource::OnPluginMsgRequestOSFileHandleComplete(
 427     scoped_refptr<TrackedCallback> callback,
 428     PP_FileHandle* output_handle,
 429     const ResourceMessageReplyParams& params) {
 430   DCHECK(state_manager_.get_pending_operation() ==
 431          FileIOStateManager::OPERATION_EXCLUSIVE);
 432
 433   if (!TrackedCallback::IsPending(callback)) {
 434     state_manager_.SetOperationFinished();
 435     return;
 436   }
 437
 438   int32_t result = params.result();
 439   IPC::PlatformFileForTransit transit_file;
 440   if (!params.TakeFileHandleAtIndex(0, &transit_file))
 441     result = PP_ERROR_FAILED;
 442   *output_handle = IPC::PlatformFileForTransitToPlatformFile(transit_file);
 443
 444   // End this operation now, so the user's callback can execute another FileIO
 445   // operation, assuming there are no other pending operations.
 446   state_manager_.SetOperationFinished();
 447   callback->Run(result);
 448 }
 449
 450 }  // namespace proxy
 451 }  // namespace ppapi