Home | History | Annotate | Download | only in proxy 
      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_ref_create_info.h"
     14 #include "ppapi/shared_impl/file_system_util.h"
     15 #include "ppapi/shared_impl/file_type_conversion.h"
     16 #include "ppapi/shared_impl/ppapi_globals.h"
     17 #include "ppapi/shared_impl/proxy_lock.h"
     18 #include "ppapi/shared_impl/resource_tracker.h"
     19 #include "ppapi/thunk/enter.h"
     20 #include "ppapi/thunk/ppb_file_ref_api.h"
     21 #include "ppapi/thunk/ppb_file_system_api.h"
     22 
     23 using ppapi::thunk::EnterResourceNoLock;
     24 using ppapi::thunk::PPB_FileIO_API;
     25 using ppapi::thunk::PPB_FileRef_API;
     26 using ppapi::thunk::PPB_FileSystem_API;
     27 
     28 namespace {
     29 
     30 // We must allocate a buffer sized according to the request of the plugin. To
     31 // reduce the chance of out-of-memory errors, we cap the read and write size to
     32 // 32MB. This is OK since the API specifies that it may perform a partial read
     33 // or write.
     34 static const int32_t kMaxReadWriteSize = 32 * 1024 * 1024;  // 32MB
     35 
     36 // An adapter to let Read() share the same implementation with ReadToArray().
     37 void* DummyGetDataBuffer(void* user_data, uint32_t count, uint32_t size) {
     38   return user_data;
     39 }
     40 
     41 // File thread task to close the file handle.
     42 void DoClose(base::File auto_close_file) {
     43 }
     44 
     45 }  // namespace
     46 
     47 namespace ppapi {
     48 namespace proxy {
     49 
     50 FileIOResource::QueryOp::QueryOp(scoped_refptr<FileHolder> file_holder)
     51     : file_holder_(file_holder) {
     52   DCHECK(file_holder_.get());
     53 }
     54 
     55 FileIOResource::QueryOp::~QueryOp() {
     56 }
     57 
     58 int32_t FileIOResource::QueryOp::DoWork() {
     59   return file_holder_->file()->GetInfo(&file_info_) ? PP_OK : PP_ERROR_FAILED;
     60 }
     61 
     62 FileIOResource::ReadOp::ReadOp(scoped_refptr<FileHolder> file_holder,
     63                                int64_t offset,
     64                                int32_t bytes_to_read)
     65   : file_holder_(file_holder),
     66     offset_(offset),
     67     bytes_to_read_(bytes_to_read) {
     68   DCHECK(file_holder_.get());
     69 }
     70 
     71 FileIOResource::ReadOp::~ReadOp() {
     72 }
     73 
     74 int32_t FileIOResource::ReadOp::DoWork() {
     75   DCHECK(!buffer_.get());
     76   buffer_.reset(new char[bytes_to_read_]);
     77   return file_holder_->file()->Read(offset_, buffer_.get(), bytes_to_read_);
     78 }
     79 
     80 FileIOResource::WriteOp::WriteOp(scoped_refptr<FileHolder> file_holder,
     81                                  int64_t offset,
     82                                  scoped_ptr<char[]> buffer,
     83                                  int32_t bytes_to_write,
     84                                  bool append)
     85     : file_holder_(file_holder),
     86       offset_(offset),
     87       buffer_(buffer.Pass()),
     88       bytes_to_write_(bytes_to_write),
     89       append_(append) {
     90 }
     91 
     92 FileIOResource::WriteOp::~WriteOp() {
     93 }
     94 
     95 int32_t FileIOResource::WriteOp::DoWork() {
     96   // In append mode, we can't call Write, since NaCl doesn't implement fcntl,
     97   // causing the function to call pwrite, which is incorrect.
     98   if (append_) {
     99     return file_holder_->file()->WriteAtCurrentPos(buffer_.get(),
    100                                                    bytes_to_write_);
    101   } else {
    102     return file_holder_->file()->Write(offset_, buffer_.get(), bytes_to_write_);
    103   }
    104 }
    105 
    106 FileIOResource::FileIOResource(Connection connection, PP_Instance instance)
    107     : PluginResource(connection, instance),
    108       file_system_type_(PP_FILESYSTEMTYPE_INVALID),
    109       open_flags_(0),
    110       max_written_offset_(0),
    111       append_mode_write_amount_(0),
    112       check_quota_(false),
    113       called_close_(false) {
    114   SendCreate(BROWSER, PpapiHostMsg_FileIO_Create());
    115 }
    116 
    117 FileIOResource::~FileIOResource() {
    118   Close();
    119 }
    120 
    121 PPB_FileIO_API* FileIOResource::AsPPB_FileIO_API() {
    122   return this;
    123 }
    124 
    125 int32_t FileIOResource::Open(PP_Resource file_ref,
    126                              int32_t open_flags,
    127                              scoped_refptr<TrackedCallback> callback) {
    128   EnterResourceNoLock<PPB_FileRef_API> enter_file_ref(file_ref, true);
    129   if (enter_file_ref.failed())
    130     return PP_ERROR_BADRESOURCE;
    131 
    132   PPB_FileRef_API* file_ref_api = enter_file_ref.object();
    133   const FileRefCreateInfo& create_info = file_ref_api->GetCreateInfo();
    134   if (!FileSystemTypeIsValid(create_info.file_system_type)) {
    135     NOTREACHED();
    136     return PP_ERROR_FAILED;
    137   }
    138   int32_t rv = state_manager_.CheckOperationState(
    139       FileIOStateManager::OPERATION_EXCLUSIVE, false);
    140   if (rv != PP_OK)
    141     return rv;
    142 
    143   open_flags_ = open_flags;
    144   file_system_type_ = create_info.file_system_type;
    145 
    146   if (create_info.file_system_plugin_resource) {
    147     EnterResourceNoLock<PPB_FileSystem_API> enter_file_system(
    148         create_info.file_system_plugin_resource, true);
    149     if (enter_file_system.failed())
    150       return PP_ERROR_FAILED;
    151     // Take a reference on the FileSystem resource. The FileIO host uses the
    152     // FileSystem host for running tasks and checking quota.
    153     file_system_resource_ = enter_file_system.resource();
    154   }
    155 
    156   // Take a reference on the FileRef resource while we're opening the file; we
    157   // don't want the plugin destroying it during the Open operation.
    158   file_ref_ = enter_file_ref.resource();
    159 
    160   Call<PpapiPluginMsg_FileIO_OpenReply>(BROWSER,
    161       PpapiHostMsg_FileIO_Open(
    162           file_ref,
    163           open_flags),
    164       base::Bind(&FileIOResource::OnPluginMsgOpenFileComplete, this,
    165                  callback));
    166 
    167   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
    168   return PP_OK_COMPLETIONPENDING;
    169 }
    170 
    171 int32_t FileIOResource::Query(PP_FileInfo* info,
    172                               scoped_refptr<TrackedCallback> callback) {
    173   int32_t rv = state_manager_.CheckOperationState(
    174       FileIOStateManager::OPERATION_EXCLUSIVE, true);
    175   if (rv != PP_OK)
    176     return rv;
    177   if (!info)
    178     return PP_ERROR_BADARGUMENT;
    179   if (!FileHolder::IsValid(file_holder_))
    180     return PP_ERROR_FAILED;
    181 
    182   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
    183 
    184   // If the callback is blocking, perform the task on the calling thread.
    185   if (callback->is_blocking()) {
    186     int32_t result = PP_ERROR_FAILED;
    187     base::File::Info file_info;
    188     // The plugin could release its reference to this instance when we release
    189     // the proxy lock below.
    190     scoped_refptr<FileIOResource> protect(this);
    191     {
    192       // Release the proxy lock while making a potentially slow file call.
    193       ProxyAutoUnlock unlock;
    194       if (file_holder_->file()->GetInfo(&file_info))
    195         result = PP_OK;
    196     }
    197     if (result == PP_OK) {
    198       // This writes the file info into the plugin's PP_FileInfo struct.
    199       ppapi::FileInfoToPepperFileInfo(file_info,
    200                                       file_system_type_,
    201                                       info);
    202     }
    203     state_manager_.SetOperationFinished();
    204     return result;
    205   }
    206 
    207   // For the non-blocking case, post a task to the file thread and add a
    208   // completion task to write the result.
    209   scoped_refptr<QueryOp> query_op(new QueryOp(file_holder_));
    210   base::PostTaskAndReplyWithResult(
    211       PpapiGlobals::Get()->GetFileTaskRunner(),
    212       FROM_HERE,
    213       Bind(&FileIOResource::QueryOp::DoWork, query_op),
    214       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
    215   callback->set_completion_task(
    216       Bind(&FileIOResource::OnQueryComplete, this, query_op, info));
    217 
    218   return PP_OK_COMPLETIONPENDING;
    219 }
    220 
    221 int32_t FileIOResource::Touch(PP_Time last_access_time,
    222                               PP_Time last_modified_time,
    223                               scoped_refptr<TrackedCallback> callback) {
    224   int32_t rv = state_manager_.CheckOperationState(
    225       FileIOStateManager::OPERATION_EXCLUSIVE, true);
    226   if (rv != PP_OK)
    227     return rv;
    228 
    229   Call<PpapiPluginMsg_FileIO_GeneralReply>(BROWSER,
    230       PpapiHostMsg_FileIO_Touch(last_access_time, last_modified_time),
    231       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
    232                  callback));
    233 
    234   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
    235   return PP_OK_COMPLETIONPENDING;
    236 }
    237 
    238 int32_t FileIOResource::Read(int64_t offset,
    239                              char* buffer,
    240                              int32_t bytes_to_read,
    241                              scoped_refptr<TrackedCallback> callback) {
    242   int32_t rv = state_manager_.CheckOperationState(
    243       FileIOStateManager::OPERATION_READ, true);
    244   if (rv != PP_OK)
    245     return rv;
    246 
    247   PP_ArrayOutput output_adapter;
    248   output_adapter.GetDataBuffer = &DummyGetDataBuffer;
    249   output_adapter.user_data = buffer;
    250   return ReadValidated(offset, bytes_to_read, output_adapter, callback);
    251 }
    252 
    253 int32_t FileIOResource::ReadToArray(int64_t offset,
    254                                     int32_t max_read_length,
    255                                     PP_ArrayOutput* array_output,
    256                                     scoped_refptr<TrackedCallback> callback) {
    257   DCHECK(array_output);
    258   int32_t rv = state_manager_.CheckOperationState(
    259       FileIOStateManager::OPERATION_READ, true);
    260   if (rv != PP_OK)
    261     return rv;
    262 
    263   return ReadValidated(offset, max_read_length, *array_output, callback);
    264 }
    265 
    266 int32_t FileIOResource::Write(int64_t offset,
    267                               const char* buffer,
    268                               int32_t bytes_to_write,
    269                               scoped_refptr<TrackedCallback> callback) {
    270   if (!buffer)
    271     return PP_ERROR_FAILED;
    272   if (offset < 0 || bytes_to_write < 0)
    273     return PP_ERROR_FAILED;
    274   if (!FileHolder::IsValid(file_holder_))
    275     return PP_ERROR_FAILED;
    276 
    277   int32_t rv = state_manager_.CheckOperationState(
    278       FileIOStateManager::OPERATION_WRITE, true);
    279   if (rv != PP_OK)
    280     return rv;
    281 
    282   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_WRITE);
    283 
    284   if (check_quota_) {
    285     int64_t increase = 0;
    286     uint64_t max_offset = 0;
    287     bool append = (open_flags_ & PP_FILEOPENFLAG_APPEND) != 0;
    288     if (append) {
    289       increase = bytes_to_write;
    290     } else {
    291       uint64_t max_offset = offset + bytes_to_write;
    292       if (max_offset > static_cast<uint64_t>(kint64max))
    293         return PP_ERROR_FAILED;  // amount calculation would overflow.
    294       increase = static_cast<int64_t>(max_offset) - max_written_offset_;
    295     }
    296 
    297     if (increase > 0) {
    298       // Request a quota reservation. This makes the Write asynchronous, so we
    299       // must copy the plugin's buffer.
    300       scoped_ptr<char[]> copy(new char[bytes_to_write]);
    301       memcpy(copy.get(), buffer, bytes_to_write);
    302       int64_t result =
    303           file_system_resource_->AsPPB_FileSystem_API()->RequestQuota(
    304               increase,
    305               base::Bind(&FileIOResource::OnRequestWriteQuotaComplete,
    306                          this,
    307                          offset,
    308                          base::Passed(&copy),
    309                          bytes_to_write,
    310                          callback));
    311       if (result == PP_OK_COMPLETIONPENDING)
    312         return PP_OK_COMPLETIONPENDING;
    313       DCHECK(result == increase);
    314 
    315       if (append)
    316         append_mode_write_amount_ += bytes_to_write;
    317       else
    318         max_written_offset_ = max_offset;
    319     }
    320   }
    321   return WriteValidated(offset, buffer, bytes_to_write, callback);
    322 }
    323 
    324 int32_t FileIOResource::SetLength(int64_t length,
    325                                   scoped_refptr<TrackedCallback> callback) {
    326   int32_t rv = state_manager_.CheckOperationState(
    327       FileIOStateManager::OPERATION_EXCLUSIVE, true);
    328   if (rv != PP_OK)
    329     return rv;
    330   if (length < 0)
    331     return PP_ERROR_FAILED;
    332 
    333   if (check_quota_) {
    334     int64_t increase = length - max_written_offset_;
    335     if (increase > 0) {
    336       int32_t result =
    337           file_system_resource_->AsPPB_FileSystem_API()->RequestQuota(
    338               increase,
    339               base::Bind(&FileIOResource::OnRequestSetLengthQuotaComplete,
    340                          this,
    341                          length, callback));
    342       if (result == PP_OK_COMPLETIONPENDING) {
    343         state_manager_.SetPendingOperation(
    344             FileIOStateManager::OPERATION_EXCLUSIVE);
    345         return PP_OK_COMPLETIONPENDING;
    346       }
    347       DCHECK(result == increase);
    348       max_written_offset_ = length;
    349     }
    350   }
    351 
    352   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
    353   SetLengthValidated(length, callback);
    354   return PP_OK_COMPLETIONPENDING;
    355 }
    356 
    357 int32_t FileIOResource::Flush(scoped_refptr<TrackedCallback> callback) {
    358   int32_t rv = state_manager_.CheckOperationState(
    359       FileIOStateManager::OPERATION_EXCLUSIVE, true);
    360   if (rv != PP_OK)
    361     return rv;
    362 
    363   Call<PpapiPluginMsg_FileIO_GeneralReply>(BROWSER,
    364       PpapiHostMsg_FileIO_Flush(),
    365       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
    366                  callback));
    367 
    368   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
    369   return PP_OK_COMPLETIONPENDING;
    370 }
    371 
    372 int64_t FileIOResource::GetMaxWrittenOffset() const {
    373   return max_written_offset_;
    374 }
    375 
    376 int64_t FileIOResource::GetAppendModeWriteAmount() const {
    377   return append_mode_write_amount_;
    378 }
    379 
    380 void FileIOResource::SetMaxWrittenOffset(int64_t max_written_offset) {
    381   max_written_offset_ = max_written_offset;
    382 }
    383 
    384 void FileIOResource::SetAppendModeWriteAmount(
    385     int64_t append_mode_write_amount) {
    386   append_mode_write_amount_ = append_mode_write_amount;
    387 }
    388 
    389 void FileIOResource::Close() {
    390   if (called_close_)
    391     return;
    392 
    393   called_close_ = true;
    394   if (check_quota_) {
    395     check_quota_ = false;
    396     file_system_resource_->AsPPB_FileSystem_API()->CloseQuotaFile(
    397         pp_resource());
    398   }
    399 
    400   if (file_holder_.get())
    401     file_holder_ = NULL;
    402 
    403   Post(BROWSER, PpapiHostMsg_FileIO_Close(
    404       FileGrowth(max_written_offset_, append_mode_write_amount_)));
    405 }
    406 
    407 int32_t FileIOResource::RequestOSFileHandle(
    408     PP_FileHandle* handle,
    409     scoped_refptr<TrackedCallback> callback) {
    410   int32_t rv = state_manager_.CheckOperationState(
    411       FileIOStateManager::OPERATION_EXCLUSIVE, true);
    412   if (rv != PP_OK)
    413     return rv;
    414 
    415   Call<PpapiPluginMsg_FileIO_RequestOSFileHandleReply>(BROWSER,
    416       PpapiHostMsg_FileIO_RequestOSFileHandle(),
    417       base::Bind(&FileIOResource::OnPluginMsgRequestOSFileHandleComplete, this,
    418                  callback, handle));
    419 
    420   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE);
    421   return PP_OK_COMPLETIONPENDING;
    422 }
    423 
    424 FileIOResource::FileHolder::FileHolder(PP_FileHandle file_handle)
    425     : file_(file_handle) {
    426 }
    427 
    428 // static
    429 bool FileIOResource::FileHolder::IsValid(
    430     const scoped_refptr<FileIOResource::FileHolder>& handle) {
    431   return handle.get() && handle->file_.IsValid();
    432 }
    433 
    434 FileIOResource::FileHolder::~FileHolder() {
    435   if (file_.IsValid()) {
    436     base::TaskRunner* file_task_runner =
    437         PpapiGlobals::Get()->GetFileTaskRunner();
    438     file_task_runner->PostTask(FROM_HERE,
    439                                base::Bind(&DoClose, Passed(&file_)));
    440   }
    441 }
    442 
    443 int32_t FileIOResource::ReadValidated(int64_t offset,
    444                                       int32_t bytes_to_read,
    445                                       const PP_ArrayOutput& array_output,
    446                                       scoped_refptr<TrackedCallback> callback) {
    447   if (bytes_to_read < 0)
    448     return PP_ERROR_FAILED;
    449   if (!FileHolder::IsValid(file_holder_))
    450     return PP_ERROR_FAILED;
    451 
    452   state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_READ);
    453 
    454   bytes_to_read = std::min(bytes_to_read, kMaxReadWriteSize);
    455   if (callback->is_blocking()) {
    456     char* buffer = static_cast<char*>(
    457         array_output.GetDataBuffer(array_output.user_data, bytes_to_read, 1));
    458     int32_t result = PP_ERROR_FAILED;
    459     // The plugin could release its reference to this instance when we release
    460     // the proxy lock below.
    461     scoped_refptr<FileIOResource> protect(this);
    462     if (buffer) {
    463       // Release the proxy lock while making a potentially slow file call.
    464       ProxyAutoUnlock unlock;
    465       result = file_holder_->file()->Read(offset, buffer, bytes_to_read);
    466       if (result < 0)
    467         result = PP_ERROR_FAILED;
    468     }
    469     state_manager_.SetOperationFinished();
    470     return result;
    471   }
    472 
    473   // For the non-blocking case, post a task to the file thread.
    474   scoped_refptr<ReadOp> read_op(
    475       new ReadOp(file_holder_, offset, bytes_to_read));
    476   base::PostTaskAndReplyWithResult(
    477       PpapiGlobals::Get()->GetFileTaskRunner(),
    478       FROM_HERE,
    479       Bind(&FileIOResource::ReadOp::DoWork, read_op),
    480       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
    481   callback->set_completion_task(
    482       Bind(&FileIOResource::OnReadComplete, this, read_op, array_output));
    483 
    484   return PP_OK_COMPLETIONPENDING;
    485 }
    486 
    487 int32_t FileIOResource::WriteValidated(
    488     int64_t offset,
    489     const char* buffer,
    490     int32_t bytes_to_write,
    491     scoped_refptr<TrackedCallback> callback) {
    492   bool append = (open_flags_ & PP_FILEOPENFLAG_APPEND) != 0;
    493   if (callback->is_blocking()) {
    494     int32_t result;
    495     {
    496       // Release the proxy lock while making a potentially slow file call.
    497       ProxyAutoUnlock unlock;
    498       if (append) {
    499         result = file_holder_->file()->WriteAtCurrentPos(buffer,
    500                                                          bytes_to_write);
    501       } else {
    502         result = file_holder_->file()->Write(offset, buffer, bytes_to_write);
    503       }
    504     }
    505     if (result < 0)
    506       result = PP_ERROR_FAILED;
    507 
    508     state_manager_.SetOperationFinished();
    509     return result;
    510   }
    511 
    512   // For the non-blocking case, post a task to the file thread. We must copy the
    513   // plugin's buffer at this point.
    514   scoped_ptr<char[]> copy(new char[bytes_to_write]);
    515   memcpy(copy.get(), buffer, bytes_to_write);
    516   scoped_refptr<WriteOp> write_op(
    517       new WriteOp(file_holder_, offset, copy.Pass(), bytes_to_write, append));
    518   base::PostTaskAndReplyWithResult(
    519       PpapiGlobals::Get()->GetFileTaskRunner(),
    520       FROM_HERE,
    521       Bind(&FileIOResource::WriteOp::DoWork, write_op),
    522       RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
    523   callback->set_completion_task(Bind(&FileIOResource::OnWriteComplete, this));
    524 
    525   return PP_OK_COMPLETIONPENDING;
    526 }
    527 
    528 void FileIOResource::SetLengthValidated(
    529     int64_t length,
    530     scoped_refptr<TrackedCallback> callback) {
    531   Call<PpapiPluginMsg_FileIO_GeneralReply>(BROWSER,
    532       PpapiHostMsg_FileIO_SetLength(length),
    533       base::Bind(&FileIOResource::OnPluginMsgGeneralComplete, this,
    534                  callback));
    535 
    536   // On the browser side we grow |max_written_offset_| monotonically, due to the
    537   // unpredictable ordering of plugin side Write and SetLength calls. Match that
    538   // behavior here.
    539   if (max_written_offset_ < length)
    540     max_written_offset_ = length;
    541 }
    542 
    543 int32_t FileIOResource::OnQueryComplete(scoped_refptr<QueryOp> query_op,
    544                                         PP_FileInfo* info,
    545                                         int32_t result) {
    546   DCHECK(state_manager_.get_pending_operation() ==
    547          FileIOStateManager::OPERATION_EXCLUSIVE);
    548 
    549   if (result == PP_OK) {
    550     // This writes the file info into the plugin's PP_FileInfo struct.
    551     ppapi::FileInfoToPepperFileInfo(query_op->file_info(),
    552                                     file_system_type_,
    553                                     info);
    554   }
    555   state_manager_.SetOperationFinished();
    556   return result;
    557 }
    558 
    559 int32_t FileIOResource::OnReadComplete(scoped_refptr<ReadOp> read_op,
    560                                        PP_ArrayOutput array_output,
    561                                        int32_t result) {
    562   DCHECK(state_manager_.get_pending_operation() ==
    563          FileIOStateManager::OPERATION_READ);
    564   if (result >= 0) {
    565     ArrayWriter output;
    566     output.set_pp_array_output(array_output);
    567     if (output.is_valid())
    568       output.StoreArray(read_op->buffer(), result);
    569     else
    570       result = PP_ERROR_FAILED;
    571   } else {
    572     // The read operation failed.
    573     result = PP_ERROR_FAILED;
    574   }
    575   state_manager_.SetOperationFinished();
    576   return result;
    577 }
    578 
    579 void FileIOResource::OnRequestWriteQuotaComplete(
    580     int64_t offset,
    581     scoped_ptr<char[]> buffer,
    582     int32_t bytes_to_write,
    583     scoped_refptr<TrackedCallback> callback,
    584     int64_t granted) {
    585   DCHECK(granted >= 0);
    586   if (granted == 0) {
    587     callback->Run(PP_ERROR_NOQUOTA);
    588     return;
    589   }
    590   if (open_flags_ & PP_FILEOPENFLAG_APPEND) {
    591     DCHECK_LE(bytes_to_write, granted);
    592     append_mode_write_amount_ += bytes_to_write;
    593   } else {
    594     DCHECK_LE(offset + bytes_to_write - max_written_offset_, granted);
    595 
    596     int64_t max_offset = offset + bytes_to_write;
    597     if (max_written_offset_ < max_offset)
    598       max_written_offset_ = max_offset;
    599   }
    600 
    601   if (callback->is_blocking()) {
    602     int32_t result =
    603         WriteValidated(offset, buffer.get(), bytes_to_write, callback);
    604     DCHECK(result != PP_OK_COMPLETIONPENDING);
    605     callback->Run(result);
    606   } else {
    607     bool append = (open_flags_ & PP_FILEOPENFLAG_APPEND) != 0;
    608     scoped_refptr<WriteOp> write_op(new WriteOp(
    609         file_holder_, offset, buffer.Pass(), bytes_to_write, append));
    610     base::PostTaskAndReplyWithResult(
    611         PpapiGlobals::Get()->GetFileTaskRunner(),
    612         FROM_HERE,
    613         Bind(&FileIOResource::WriteOp::DoWork, write_op),
    614         RunWhileLocked(Bind(&TrackedCallback::Run, callback)));
    615     callback->set_completion_task(Bind(&FileIOResource::OnWriteComplete, this));
    616   }
    617 }
    618 
    619 void FileIOResource::OnRequestSetLengthQuotaComplete(
    620     int64_t length,
    621     scoped_refptr<TrackedCallback> callback,
    622     int64_t granted) {
    623   DCHECK(granted >= 0);
    624   if (granted == 0) {
    625     callback->Run(PP_ERROR_NOQUOTA);
    626     return;
    627   }
    628 
    629   DCHECK_LE(length - max_written_offset_, granted);
    630   if (max_written_offset_ < length)
    631     max_written_offset_ = length;
    632   SetLengthValidated(length, callback);
    633 }
    634 
    635 int32_t FileIOResource::OnWriteComplete(int32_t result) {
    636   DCHECK(state_manager_.get_pending_operation() ==
    637          FileIOStateManager::OPERATION_WRITE);
    638   // |result| is the return value of WritePlatformFile; -1 indicates failure.
    639   if (result < 0)
    640     result = PP_ERROR_FAILED;
    641 
    642   state_manager_.SetOperationFinished();
    643   return result;
    644 }
    645 
    646 void FileIOResource::OnPluginMsgGeneralComplete(
    647     scoped_refptr<TrackedCallback> callback,
    648     const ResourceMessageReplyParams& params) {
    649   DCHECK(state_manager_.get_pending_operation() ==
    650          FileIOStateManager::OPERATION_EXCLUSIVE ||
    651          state_manager_.get_pending_operation() ==
    652          FileIOStateManager::OPERATION_WRITE);
    653   // End this operation now, so the user's callback can execute another FileIO
    654   // operation, assuming there are no other pending operations.
    655   state_manager_.SetOperationFinished();
    656   callback->Run(params.result());
    657 }
    658 
    659 void FileIOResource::OnPluginMsgOpenFileComplete(
    660     scoped_refptr<TrackedCallback> callback,
    661     const ResourceMessageReplyParams& params,
    662     PP_Resource quota_file_system,
    663     int64_t max_written_offset) {
    664   DCHECK(state_manager_.get_pending_operation() ==
    665          FileIOStateManager::OPERATION_EXCLUSIVE);
    666 
    667   // Release the FileRef resource.
    668   file_ref_ = NULL;
    669   int32_t result = params.result();
    670   if (result == PP_OK) {
    671     state_manager_.SetOpenSucceed();
    672 
    673     if (quota_file_system) {
    674       DCHECK(quota_file_system == file_system_resource_->pp_resource());
    675       check_quota_ = true;
    676       max_written_offset_ = max_written_offset;
    677       file_system_resource_->AsPPB_FileSystem_API()->OpenQuotaFile(
    678           pp_resource());
    679     }
    680 
    681     IPC::PlatformFileForTransit transit_file;
    682     if (params.TakeFileHandleAtIndex(0, &transit_file)) {
    683       file_holder_ = new FileHolder(
    684           IPC::PlatformFileForTransitToPlatformFile(transit_file));
    685     }
    686   }
    687   // End this operation now, so the user's callback can execute another FileIO
    688   // operation, assuming there are no other pending operations.
    689   state_manager_.SetOperationFinished();
    690   callback->Run(result);
    691 }
    692 
    693 void FileIOResource::OnPluginMsgRequestOSFileHandleComplete(
    694     scoped_refptr<TrackedCallback> callback,
    695     PP_FileHandle* output_handle,
    696     const ResourceMessageReplyParams& params) {
    697   DCHECK(state_manager_.get_pending_operation() ==
    698          FileIOStateManager::OPERATION_EXCLUSIVE);
    699 
    700   if (!TrackedCallback::IsPending(callback)) {
    701     state_manager_.SetOperationFinished();
    702     return;
    703   }
    704 
    705   int32_t result = params.result();
    706   IPC::PlatformFileForTransit transit_file;
    707   if (!params.TakeFileHandleAtIndex(0, &transit_file))
    708     result = PP_ERROR_FAILED;
    709   *output_handle = IPC::PlatformFileForTransitToPlatformFile(transit_file);
    710 
    711   // End this operation now, so the user's callback can execute another FileIO
    712   // operation, assuming there are no other pending operations.
    713   state_manager_.SetOperationFinished();
    714   callback->Run(result);
    715 }
    716 
    717 }  // namespace proxy
    718 }  // namespace ppapi
    719