content/browser/renderer_host/pepper/pepper_internal_file_ref_backend.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 "content/browser/renderer_host/pepper/pepper_internal_file_ref_backend.h"
   6
   7 #include <string>
   8
   9 #include "base/callback.h"
  10 #include "base/files/file_util.h"
  11 #include "base/files/file_util_proxy.h"
  12 #include "content/browser/child_process_security_policy_impl.h"
  13 #include "content/browser/fileapi/browser_file_system_helper.h"
  14 #include "content/browser/renderer_host/pepper/pepper_file_system_browser_host.h"
  15 #include "content/public/browser/browser_context.h"
  16 #include "content/public/browser/render_process_host.h"
  17 #include "content/public/browser/storage_partition.h"
  18 #include "net/base/escape.h"
  19 #include "ppapi/c/pp_errors.h"
  20 #include "ppapi/c/pp_file_info.h"
  21 #include "ppapi/c/pp_instance.h"
  22 #include "ppapi/c/pp_resource.h"
  23 #include "ppapi/c/ppb_file_ref.h"
  24 #include "ppapi/host/dispatch_host_message.h"
  25 #include "ppapi/host/ppapi_host.h"
  26 #include "ppapi/proxy/ppapi_messages.h"
  27 #include "ppapi/shared_impl/file_ref_create_info.h"
  28 #include "ppapi/shared_impl/file_ref_util.h"
  29 #include "ppapi/shared_impl/file_type_conversion.h"
  30 #include "ppapi/shared_impl/scoped_pp_var.h"
  31 #include "ppapi/shared_impl/time_conversion.h"
  32 #include "ppapi/shared_impl/var.h"
  33 #include "ppapi/thunk/enter.h"
  34 #include "ppapi/thunk/ppb_file_ref_api.h"
  35 #include "ppapi/thunk/ppb_file_system_api.h"
  36 #include "storage/browser/fileapi/file_system_operation.h"
  37 #include "storage/browser/fileapi/file_system_operation_runner.h"
  38 #include "storage/browser/fileapi/file_system_url.h"
  39 #include "storage/common/fileapi/file_system_util.h"
  40
  41 using ppapi::host::PpapiHost;
  42 using ppapi::host::ResourceHost;
  43
  44 namespace content {
  45
  46 PepperInternalFileRefBackend::PepperInternalFileRefBackend(
  47     PpapiHost* host,
  48     int render_process_id,
  49     base::WeakPtr<PepperFileSystemBrowserHost> fs_host,
  50     const std::string& path)
  51     : host_(host),
  52       render_process_id_(render_process_id),
  53       fs_host_(fs_host),
  54       fs_type_(fs_host->GetType()),
  55       path_(path),
  56       weak_factory_(this) {
  57   ppapi::NormalizeInternalPath(&path_);
  58 }
  59
  60 PepperInternalFileRefBackend::~PepperInternalFileRefBackend() {}
  61
  62 storage::FileSystemURL PepperInternalFileRefBackend::GetFileSystemURL() const {
  63   if (!fs_url_.is_valid() && fs_host_.get() && fs_host_->IsOpened()) {
  64     GURL fs_path =
  65         fs_host_->GetRootUrl().Resolve(net::EscapePath(path_.substr(1)));
  66     scoped_refptr<storage::FileSystemContext> fs_context =
  67         GetFileSystemContext();
  68     if (fs_context.get())
  69       fs_url_ = fs_context->CrackURL(fs_path);
  70   }
  71   return fs_url_;
  72 }
  73
  74 base::FilePath PepperInternalFileRefBackend::GetExternalFilePath() const {
  75   return base::FilePath();
  76 }
  77
  78 scoped_refptr<storage::FileSystemContext>
  79 PepperInternalFileRefBackend::GetFileSystemContext() const {
  80   if (!fs_host_.get())
  81     return NULL;
  82   return fs_host_->GetFileSystemContext();
  83 }
  84
  85 void PepperInternalFileRefBackend::DidFinish(
  86     ppapi::host::ReplyMessageContext context,
  87     const IPC::Message& msg,
  88     base::File::Error error) {
  89   context.params.set_result(ppapi::FileErrorToPepperError(error));
  90   host_->SendReply(context, msg);
  91 }
  92
  93 int32_t PepperInternalFileRefBackend::MakeDirectory(
  94     ppapi::host::ReplyMessageContext reply_context,
  95     int32_t make_directory_flags) {
  96   if (!GetFileSystemURL().is_valid())
  97     return PP_ERROR_FAILED;
  98
  99   GetFileSystemContext()->operation_runner()->CreateDirectory(
 100       GetFileSystemURL(),
 101       !!(make_directory_flags & PP_MAKEDIRECTORYFLAG_EXCLUSIVE),
 102       !!(make_directory_flags & PP_MAKEDIRECTORYFLAG_WITH_ANCESTORS),
 103       base::Bind(&PepperInternalFileRefBackend::DidFinish,
 104                  weak_factory_.GetWeakPtr(),
 105                  reply_context,
 106                  PpapiPluginMsg_FileRef_MakeDirectoryReply()));
 107   return PP_OK_COMPLETIONPENDING;
 108 }
 109
 110 int32_t PepperInternalFileRefBackend::Touch(
 111     ppapi::host::ReplyMessageContext reply_context,
 112     PP_Time last_access_time,
 113     PP_Time last_modified_time) {
 114   if (!GetFileSystemURL().is_valid())
 115     return PP_ERROR_FAILED;
 116
 117   GetFileSystemContext()->operation_runner()->TouchFile(
 118       GetFileSystemURL(),
 119       ppapi::PPTimeToTime(last_access_time),
 120       ppapi::PPTimeToTime(last_modified_time),
 121       base::Bind(&PepperInternalFileRefBackend::DidFinish,
 122                  weak_factory_.GetWeakPtr(),
 123                  reply_context,
 124                  PpapiPluginMsg_FileRef_TouchReply()));
 125   return PP_OK_COMPLETIONPENDING;
 126 }
 127
 128 int32_t PepperInternalFileRefBackend::Delete(
 129     ppapi::host::ReplyMessageContext reply_context) {
 130   if (!GetFileSystemURL().is_valid())
 131     return PP_ERROR_FAILED;
 132
 133   GetFileSystemContext()->operation_runner()->Remove(
 134       GetFileSystemURL(),
 135       false,
 136       base::Bind(&PepperInternalFileRefBackend::DidFinish,
 137                  weak_factory_.GetWeakPtr(),
 138                  reply_context,
 139                  PpapiPluginMsg_FileRef_DeleteReply()));
 140   return PP_OK_COMPLETIONPENDING;
 141 }
 142
 143 int32_t PepperInternalFileRefBackend::Rename(
 144     ppapi::host::ReplyMessageContext reply_context,
 145     PepperFileRefHost* new_file_ref) {
 146   if (!GetFileSystemURL().is_valid())
 147     return PP_ERROR_FAILED;
 148
 149   storage::FileSystemURL new_url = new_file_ref->GetFileSystemURL();
 150   if (!new_url.is_valid())
 151     return PP_ERROR_FAILED;
 152   if (!new_url.IsInSameFileSystem(GetFileSystemURL()))
 153     return PP_ERROR_FAILED;
 154
 155   GetFileSystemContext()->operation_runner()->Move(
 156       GetFileSystemURL(),
 157       new_url,
 158       storage::FileSystemOperation::OPTION_NONE,
 159       base::Bind(&PepperInternalFileRefBackend::DidFinish,
 160                  weak_factory_.GetWeakPtr(),
 161                  reply_context,
 162                  PpapiPluginMsg_FileRef_RenameReply()));
 163   return PP_OK_COMPLETIONPENDING;
 164 }
 165
 166 int32_t PepperInternalFileRefBackend::Query(
 167     ppapi::host::ReplyMessageContext reply_context) {
 168   if (!GetFileSystemURL().is_valid())
 169     return PP_ERROR_FAILED;
 170
 171   GetFileSystemContext()->operation_runner()->GetMetadata(
 172       GetFileSystemURL(),
 173       base::Bind(&PepperInternalFileRefBackend::GetMetadataComplete,
 174                  weak_factory_.GetWeakPtr(),
 175                  reply_context));
 176   return PP_OK_COMPLETIONPENDING;
 177 }
 178
 179 void PepperInternalFileRefBackend::GetMetadataComplete(
 180     ppapi::host::ReplyMessageContext reply_context,
 181     base::File::Error error,
 182     const base::File::Info& file_info) {
 183   reply_context.params.set_result(ppapi::FileErrorToPepperError(error));
 184
 185   PP_FileInfo pp_file_info;
 186   if (error == base::File::FILE_OK)
 187     ppapi::FileInfoToPepperFileInfo(file_info, fs_type_, &pp_file_info);
 188   else
 189     memset(&pp_file_info, 0, sizeof(pp_file_info));
 190
 191   host_->SendReply(reply_context,
 192                    PpapiPluginMsg_FileRef_QueryReply(pp_file_info));
 193 }
 194
 195 int32_t PepperInternalFileRefBackend::ReadDirectoryEntries(
 196     ppapi::host::ReplyMessageContext reply_context) {
 197   if (!GetFileSystemURL().is_valid())
 198     return PP_ERROR_FAILED;
 199
 200   storage::FileSystemOperation::FileEntryList* accumulated_file_list =
 201       new storage::FileSystemOperation::FileEntryList;
 202   GetFileSystemContext()->operation_runner()->ReadDirectory(
 203       GetFileSystemURL(),
 204       base::Bind(&PepperInternalFileRefBackend::ReadDirectoryComplete,
 205                  weak_factory_.GetWeakPtr(),
 206                  reply_context,
 207                  base::Owned(accumulated_file_list)));
 208   return PP_OK_COMPLETIONPENDING;
 209 }
 210
 211 void PepperInternalFileRefBackend::ReadDirectoryComplete(
 212     ppapi::host::ReplyMessageContext context,
 213     storage::FileSystemOperation::FileEntryList* accumulated_file_list,
 214     base::File::Error error,
 215     const storage::FileSystemOperation::FileEntryList& file_list,
 216     bool has_more) {
 217   accumulated_file_list->insert(
 218       accumulated_file_list->end(), file_list.begin(), file_list.end());
 219   if (has_more)
 220     return;
 221
 222   context.params.set_result(ppapi::FileErrorToPepperError(error));
 223
 224   std::vector<ppapi::FileRefCreateInfo> infos;
 225   std::vector<PP_FileType> file_types;
 226   if (error == base::File::FILE_OK && fs_host_.get()) {
 227     std::string dir_path = path_;
 228     if (dir_path.empty() || dir_path[dir_path.size() - 1] != '/')
 229       dir_path += '/';
 230
 231     for (storage::FileSystemOperation::FileEntryList::const_iterator it =
 232              accumulated_file_list->begin();
 233          it != accumulated_file_list->end();
 234          ++it) {
 235       if (it->is_directory)
 236         file_types.push_back(PP_FILETYPE_DIRECTORY);
 237       else
 238         file_types.push_back(PP_FILETYPE_REGULAR);
 239
 240       ppapi::FileRefCreateInfo info;
 241       info.file_system_type = fs_type_;
 242       info.file_system_plugin_resource = fs_host_->pp_resource();
 243       std::string path =
 244           dir_path + storage::FilePathToString(base::FilePath(it->name));
 245       info.internal_path = path;
 246       info.display_name = ppapi::GetNameForInternalFilePath(path);
 247       infos.push_back(info);
 248     }
 249   }
 250
 251   host_->SendReply(
 252       context,
 253       PpapiPluginMsg_FileRef_ReadDirectoryEntriesReply(infos, file_types));
 254 }
 255
 256 int32_t PepperInternalFileRefBackend::GetAbsolutePath(
 257     ppapi::host::ReplyMessageContext reply_context) {
 258   host_->SendReply(reply_context,
 259                    PpapiPluginMsg_FileRef_GetAbsolutePathReply(path_));
 260   return PP_OK_COMPLETIONPENDING;
 261 }
 262
 263 int32_t PepperInternalFileRefBackend::CanRead() const {
 264   storage::FileSystemURL url = GetFileSystemURL();
 265   if (!FileSystemURLIsValid(GetFileSystemContext().get(), url))
 266     return PP_ERROR_FAILED;
 267   if (!ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFileSystemFile(
 268           render_process_id_, url)) {
 269     return PP_ERROR_NOACCESS;
 270   }
 271   return PP_OK;
 272 }
 273
 274 int32_t PepperInternalFileRefBackend::CanWrite() const {
 275   storage::FileSystemURL url = GetFileSystemURL();
 276   if (!FileSystemURLIsValid(GetFileSystemContext().get(), url))
 277     return PP_ERROR_FAILED;
 278   if (!ChildProcessSecurityPolicyImpl::GetInstance()->CanWriteFileSystemFile(
 279           render_process_id_, url)) {
 280     return PP_ERROR_NOACCESS;
 281   }
 282   return PP_OK;
 283 }
 284
 285 int32_t PepperInternalFileRefBackend::CanCreate() const {
 286   storage::FileSystemURL url = GetFileSystemURL();
 287   if (!FileSystemURLIsValid(GetFileSystemContext().get(), url))
 288     return PP_ERROR_FAILED;
 289   if (!ChildProcessSecurityPolicyImpl::GetInstance()->CanCreateFileSystemFile(
 290           render_process_id_, url)) {
 291     return PP_ERROR_NOACCESS;
 292   }
 293   return PP_OK;
 294 }
 295
 296 int32_t PepperInternalFileRefBackend::CanReadWrite() const {
 297   storage::FileSystemURL url = GetFileSystemURL();
 298   if (!FileSystemURLIsValid(GetFileSystemContext().get(), url))
 299     return PP_ERROR_FAILED;
 300   ChildProcessSecurityPolicyImpl* policy =
 301       ChildProcessSecurityPolicyImpl::GetInstance();
 302   if (!policy->CanReadFileSystemFile(render_process_id_, url) ||
 303       !policy->CanWriteFileSystemFile(render_process_id_, url)) {
 304     return PP_ERROR_NOACCESS;
 305   }
 306   return PP_OK;
 307 }
 308
 309 }  // namespace content