Home | History | Annotate | Download | only in proxy 
      1 // Copyright (c) 2013 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_system_resource.h"
      6 
      7 #include "base/bind.h"
      8 #include "ipc/ipc_message.h"
      9 #include "ppapi/c/pp_errors.h"
     10 #include "ppapi/proxy/ppapi_messages.h"
     11 #include "ppapi/shared_impl/tracked_callback.h"
     12 
     13 using ppapi::thunk::PPB_FileSystem_API;
     14 
     15 namespace ppapi {
     16 namespace proxy {
     17 
     18 FileSystemResource::FileSystemResource(Connection connection,
     19                                        PP_Instance instance,
     20                                        PP_FileSystemType type)
     21     : PluginResource(connection, instance),
     22       type_(type),
     23       called_open_(false),
     24       callback_count_(0),
     25       callback_result_(PP_OK) {
     26   DCHECK(type_ != PP_FILESYSTEMTYPE_INVALID);
     27   SendCreate(RENDERER, PpapiHostMsg_FileSystem_Create(type_));
     28   SendCreate(BROWSER, PpapiHostMsg_FileSystem_Create(type_));
     29 }
     30 
     31 FileSystemResource::FileSystemResource(Connection connection,
     32                                        PP_Instance instance,
     33                                        int pending_renderer_id,
     34                                        int pending_browser_id,
     35                                        PP_FileSystemType type)
     36     : PluginResource(connection, instance),
     37       type_(type),
     38       called_open_(true),
     39       callback_count_(0),
     40       callback_result_(PP_OK) {
     41   DCHECK(type_ != PP_FILESYSTEMTYPE_INVALID);
     42   AttachToPendingHost(RENDERER, pending_renderer_id);
     43   AttachToPendingHost(BROWSER, pending_browser_id);
     44 }
     45 
     46 FileSystemResource::~FileSystemResource() {
     47 }
     48 
     49 PPB_FileSystem_API* FileSystemResource::AsPPB_FileSystem_API() {
     50   return this;
     51 }
     52 
     53 int32_t FileSystemResource::Open(int64_t expected_size,
     54                                  scoped_refptr<TrackedCallback> callback) {
     55   DCHECK(type_ != PP_FILESYSTEMTYPE_ISOLATED);
     56   if (called_open_)
     57     return PP_ERROR_FAILED;
     58   called_open_ = true;
     59 
     60   Call<PpapiPluginMsg_FileSystem_OpenReply>(RENDERER,
     61       PpapiHostMsg_FileSystem_Open(expected_size),
     62       base::Bind(&FileSystemResource::OpenComplete,
     63                  this,
     64                  callback));
     65   Call<PpapiPluginMsg_FileSystem_OpenReply>(BROWSER,
     66       PpapiHostMsg_FileSystem_Open(expected_size),
     67       base::Bind(&FileSystemResource::OpenComplete,
     68                  this,
     69                  callback));
     70   return PP_OK_COMPLETIONPENDING;
     71 }
     72 
     73 PP_FileSystemType FileSystemResource::GetType() {
     74   return type_;
     75 }
     76 
     77 int32_t FileSystemResource::InitIsolatedFileSystem(
     78     const std::string& fsid,
     79     PP_IsolatedFileSystemType_Private type,
     80     const base::Callback<void(int32_t)>& callback) {
     81   // This call is mutually exclusive with Open() above, so we can reuse the
     82   // called_open state.
     83   DCHECK(type_ == PP_FILESYSTEMTYPE_ISOLATED);
     84   if (called_open_)
     85     return PP_ERROR_FAILED;
     86   called_open_ = true;
     87 
     88   Call<PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply>(RENDERER,
     89       PpapiHostMsg_FileSystem_InitIsolatedFileSystem(fsid, type),
     90       base::Bind(&FileSystemResource::InitIsolatedFileSystemComplete,
     91       this,
     92       callback));
     93   Call<PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply>(BROWSER,
     94       PpapiHostMsg_FileSystem_InitIsolatedFileSystem(fsid, type),
     95       base::Bind(&FileSystemResource::InitIsolatedFileSystemComplete,
     96       this,
     97       callback));
     98   return PP_OK_COMPLETIONPENDING;
     99 }
    100 
    101 void FileSystemResource::OpenComplete(
    102     scoped_refptr<TrackedCallback> callback,
    103     const ResourceMessageReplyParams& params) {
    104   ++callback_count_;
    105   // Prioritize worse result since only one status can be returned.
    106   if (params.result() != PP_OK)
    107     callback_result_ = params.result();
    108   // Received callback from browser and renderer.
    109   if (callback_count_ == 2)
    110     callback->Run(callback_result_);
    111 }
    112 
    113 void FileSystemResource::InitIsolatedFileSystemComplete(
    114     const base::Callback<void(int32_t)>& callback,
    115     const ResourceMessageReplyParams& params) {
    116   ++callback_count_;
    117   // Prioritize worse result since only one status can be returned.
    118   if (params.result() != PP_OK)
    119     callback_result_ = params.result();
    120   // Received callback from browser and renderer.
    121   if (callback_count_ == 2)
    122     callback.Run(callback_result_);
    123 }
    124 
    125 }  // namespace proxy
    126 }  // namespace ppapi
    127