ppapi/proxy/file_ref_resource.cc

   1 // Copyright 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_ref_resource.h"
   6
   7 #include "ppapi/c/pp_directory_entry.h"
   8 #include "ppapi/c/pp_instance.h"
   9 #include "ppapi/c/pp_resource.h"
  10 #include "ppapi/proxy/ppapi_messages.h"
  11 #include "ppapi/shared_impl/array_writer.h"
  12 #include "ppapi/shared_impl/file_ref_util.h"
  13 #include "ppapi/shared_impl/resource.h"
  14 #include "ppapi/shared_impl/resource_tracker.h"
  15 #include "ppapi/shared_impl/var.h"
  16 #include "ppapi/thunk/enter.h"
  17 #include "ppapi/thunk/ppb_file_system_api.h"
  18
  19 namespace ppapi {
  20 namespace proxy {
  21
  22 FileRefResource::FileRefResource(
  23     Connection connection,
  24     PP_Instance instance,
  25     const FileRefCreateInfo& create_info)
  26     : PluginResource(connection, instance),
  27       create_info_(create_info),
  28       file_system_resource_(create_info.file_system_plugin_resource) {
  29   if (uses_internal_paths()) {
  30     // If path ends with a slash, then normalize it away unless path is
  31     // the root path.
  32     int path_size = create_info_.internal_path.size();
  33     if (path_size > 1 && create_info_.internal_path.at(path_size - 1) == '/')
  34       create_info_.internal_path.erase(path_size - 1, 1);
  35
  36     path_var_ = new StringVar(create_info_.internal_path);
  37     create_info_.display_name = GetNameForInternalFilePath(
  38         create_info_.internal_path);
  39   } else {
  40     DCHECK(!create_info_.display_name.empty());
  41   }
  42   name_var_ = new StringVar(create_info_.display_name);
  43
  44   if (create_info_.browser_pending_host_resource_id != 0 &&
  45       create_info_.renderer_pending_host_resource_id != 0) {
  46     AttachToPendingHost(BROWSER, create_info_.browser_pending_host_resource_id);
  47     AttachToPendingHost(RENDERER,
  48                         create_info_.renderer_pending_host_resource_id);
  49   } else {
  50     CHECK_EQ(0, create_info_.browser_pending_host_resource_id);
  51     CHECK_EQ(0, create_info_.renderer_pending_host_resource_id);
  52     CHECK(uses_internal_paths());
  53     SendCreate(BROWSER, PpapiHostMsg_FileRef_CreateForFileAPI(
  54         create_info.file_system_plugin_resource,
  55         create_info.internal_path));
  56     SendCreate(RENDERER, PpapiHostMsg_FileRef_CreateForFileAPI(
  57         create_info.file_system_plugin_resource,
  58         create_info.internal_path));
  59   }
  60 }
  61
  62 FileRefResource::~FileRefResource() {
  63 }
  64
  65 // static
  66 PP_Resource FileRefResource::CreateFileRef(
  67     Connection connection,
  68     PP_Instance instance,
  69     const FileRefCreateInfo& create_info) {
  70   // If we have a valid file_system resource, ensure that its type matches that
  71   // of the fs_type parameter.
  72   if (create_info.file_system_plugin_resource != 0) {
  73     thunk::EnterResourceNoLock<thunk::PPB_FileSystem_API> enter(
  74         create_info.file_system_plugin_resource, true);
  75     if (enter.failed())
  76       return 0;
  77     if (enter.object()->GetType() != create_info.file_system_type) {
  78       NOTREACHED() << "file system type mismatch with resource";
  79       return 0;
  80     }
  81   }
  82
  83   if (create_info.file_system_type == PP_FILESYSTEMTYPE_LOCALPERSISTENT ||
  84       create_info.file_system_type == PP_FILESYSTEMTYPE_LOCALTEMPORARY) {
  85     if (!IsValidInternalPath(create_info.internal_path))
  86       return 0;
  87   }
  88   return (new FileRefResource(connection,
  89                               instance,
  90                               create_info))->GetReference();
  91 }
  92
  93 thunk::PPB_FileRef_API* FileRefResource::AsPPB_FileRef_API() {
  94   return this;
  95 }
  96
  97 PP_FileSystemType FileRefResource::GetFileSystemType() const {
  98   return create_info_.file_system_type;
  99 }
 100
 101 PP_Var FileRefResource::GetName() const {
 102   return name_var_->GetPPVar();
 103 }
 104
 105 PP_Var FileRefResource::GetPath() const {
 106   if (!uses_internal_paths())
 107     return PP_MakeUndefined();
 108   return path_var_->GetPPVar();
 109 }
 110
 111 PP_Resource FileRefResource::GetParent() {
 112   if (!uses_internal_paths())
 113     return 0;
 114
 115   size_t pos = create_info_.internal_path.rfind('/');
 116   CHECK(pos != std::string::npos);
 117   if (pos == 0)
 118     pos++;
 119   std::string parent_path = create_info_.internal_path.substr(0, pos);
 120
 121   ppapi::FileRefCreateInfo parent_info;
 122   parent_info.file_system_type = create_info_.file_system_type;
 123   parent_info.internal_path = parent_path;
 124   parent_info.display_name = GetNameForInternalFilePath(parent_path);
 125   parent_info.file_system_plugin_resource =
 126       create_info_.file_system_plugin_resource;
 127
 128   return (new FileRefResource(connection(),
 129                               pp_instance(),
 130                               parent_info))->GetReference();
 131 }
 132
 133 int32_t FileRefResource::MakeDirectory(
 134     int32_t make_directory_flags,
 135     scoped_refptr<TrackedCallback> callback) {
 136   Call<PpapiPluginMsg_FileRef_MakeDirectoryReply>(
 137       BROWSER,
 138       PpapiHostMsg_FileRef_MakeDirectory(make_directory_flags),
 139       base::Bind(&FileRefResource::RunTrackedCallback, this, callback));
 140   return PP_OK_COMPLETIONPENDING;
 141 }
 142
 143 int32_t FileRefResource::Touch(PP_Time last_access_time,
 144                                PP_Time last_modified_time,
 145                                scoped_refptr<TrackedCallback> callback) {
 146   Call<PpapiPluginMsg_FileRef_TouchReply>(
 147       BROWSER,
 148       PpapiHostMsg_FileRef_Touch(last_access_time,
 149                                  last_modified_time),
 150       base::Bind(&FileRefResource::RunTrackedCallback, this, callback));
 151   return PP_OK_COMPLETIONPENDING;
 152 }
 153
 154 int32_t FileRefResource::Delete(scoped_refptr<TrackedCallback> callback) {
 155   Call<PpapiPluginMsg_FileRef_DeleteReply>(
 156       BROWSER,
 157       PpapiHostMsg_FileRef_Delete(),
 158       base::Bind(&FileRefResource::RunTrackedCallback, this, callback));
 159   return PP_OK_COMPLETIONPENDING;
 160 }
 161
 162 int32_t FileRefResource::Rename(PP_Resource new_file_ref,
 163                                 scoped_refptr<TrackedCallback> callback) {
 164   Call<PpapiPluginMsg_FileRef_RenameReply>(
 165       BROWSER,
 166       PpapiHostMsg_FileRef_Rename(new_file_ref),
 167       base::Bind(&FileRefResource::RunTrackedCallback, this, callback));
 168   return PP_OK_COMPLETIONPENDING;
 169 }
 170
 171 int32_t FileRefResource::Query(PP_FileInfo* info,
 172                                scoped_refptr<TrackedCallback> callback) {
 173   if (info == NULL)
 174     return PP_ERROR_BADARGUMENT;
 175
 176   Call<PpapiPluginMsg_FileRef_QueryReply>(
 177       BROWSER,
 178       PpapiHostMsg_FileRef_Query(),
 179       base::Bind(&FileRefResource::OnQueryReply, this, info, callback));
 180   return PP_OK_COMPLETIONPENDING;
 181 }
 182
 183 int32_t FileRefResource::ReadDirectoryEntries(
 184     const PP_ArrayOutput& output,
 185     scoped_refptr<TrackedCallback> callback) {
 186   Call<PpapiPluginMsg_FileRef_ReadDirectoryEntriesReply>(
 187       BROWSER,
 188       PpapiHostMsg_FileRef_ReadDirectoryEntries(),
 189       base::Bind(&FileRefResource::OnDirectoryEntriesReply,
 190                  this, output, callback));
 191   return PP_OK_COMPLETIONPENDING;
 192 }
 193
 194 const FileRefCreateInfo& FileRefResource::GetCreateInfo() const {
 195   return create_info_;
 196 }
 197
 198 PP_Var FileRefResource::GetAbsolutePath() {
 199   if (!absolute_path_var_.get()) {
 200     std::string absolute_path;
 201     int32_t result = SyncCall<PpapiPluginMsg_FileRef_GetAbsolutePathReply>(
 202         BROWSER, PpapiHostMsg_FileRef_GetAbsolutePath(), &absolute_path);
 203     if (result != PP_OK)
 204       return PP_MakeUndefined();
 205     absolute_path_var_ = new StringVar(absolute_path);
 206   }
 207   return absolute_path_var_->GetPPVar();
 208 }
 209
 210 void FileRefResource::RunTrackedCallback(
 211     scoped_refptr<TrackedCallback> callback,
 212     const ResourceMessageReplyParams& params) {
 213   if (TrackedCallback::IsPending(callback))
 214     callback->Run(params.result());
 215 }
 216
 217 void FileRefResource::OnQueryReply(
 218     PP_FileInfo* out_info,
 219     scoped_refptr<TrackedCallback> callback,
 220     const ResourceMessageReplyParams& params,
 221     const PP_FileInfo& info) {
 222   if (!TrackedCallback::IsPending(callback))
 223     return;
 224
 225   if (params.result() == PP_OK)
 226     *out_info = info;
 227   callback->Run(params.result());
 228 }
 229
 230 void FileRefResource::OnDirectoryEntriesReply(
 231     const PP_ArrayOutput& output,
 232     scoped_refptr<TrackedCallback> callback,
 233     const ResourceMessageReplyParams& params,
 234     const std::vector<ppapi::FileRefCreateInfo>& infos,
 235     const std::vector<PP_FileType>& file_types) {
 236   if (!TrackedCallback::IsPending(callback))
 237     return;
 238
 239   if (params.result() == PP_OK) {
 240     ArrayWriter writer(output);
 241     if (!writer.is_valid()) {
 242       callback->Run(PP_ERROR_BADARGUMENT);
 243       return;
 244     }
 245
 246     std::vector<PP_DirectoryEntry> entries;
 247     for (size_t i = 0; i < infos.size(); ++i) {
 248       PP_DirectoryEntry entry;
 249       entry.file_ref = FileRefResource::CreateFileRef(connection(),
 250                                                       pp_instance(),
 251                                                       infos[i]);
 252       entry.file_type = file_types[i];
 253       entries.push_back(entry);
 254     }
 255
 256     writer.StoreVector(entries);
 257   }
 258   callback->Run(params.result());
 259 }
 260
 261 bool FileRefResource::uses_internal_paths() const {
 262   return (create_info_.file_system_type != PP_FILESYSTEMTYPE_EXTERNAL) ||
 263          !create_info_.internal_path.empty();
 264 }
 265
 266 }  // namespace proxy
 267 }  // namespace ppapi