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/cpp/private/flash_file.h" 6 7#include "ppapi/c/pp_bool.h" 8#include "ppapi/c/pp_errors.h" 9#include "ppapi/cpp/file_ref.h" 10#include "ppapi/cpp/instance_handle.h" 11#include "ppapi/cpp/module_impl.h" 12 13namespace pp { 14 15// FileModuleLocal ------------------------------------------------------------- 16 17namespace { 18 19template <> const char* interface_name<PPB_Flash_File_ModuleLocal_3_0>() { 20 return PPB_FLASH_FILE_MODULELOCAL_INTERFACE_3_0; 21} 22 23} // namespace 24 25namespace flash { 26 27static FileModuleLocal::DirEntry ConvertDirEntry(const PP_DirEntry_Dev& entry) { 28 FileModuleLocal::DirEntry rv = { entry.name, PP_ToBool(entry.is_dir) }; 29 return rv; 30} 31 32// static 33bool FileModuleLocal::IsAvailable() { 34 return has_interface<PPB_Flash_File_ModuleLocal_3_0>(); 35} 36 37// static 38PP_FileHandle FileModuleLocal::OpenFile(const InstanceHandle& instance, 39 const std::string& path, 40 int32_t mode) { 41 PP_FileHandle file_handle = PP_kInvalidFileHandle; 42 int32_t result = PP_ERROR_FAILED; 43 if (has_interface<PPB_Flash_File_ModuleLocal_3_0>()) { 44 result = get_interface<PPB_Flash_File_ModuleLocal_3_0>()-> 45 OpenFile(instance.pp_instance(), path.c_str(), mode, &file_handle); 46 } 47 return (result == PP_OK) ? file_handle : PP_kInvalidFileHandle; 48} 49 50// static 51bool FileModuleLocal::RenameFile(const InstanceHandle& instance, 52 const std::string& path_from, 53 const std::string& path_to) { 54 int32_t result = PP_ERROR_FAILED; 55 if (has_interface<PPB_Flash_File_ModuleLocal_3_0>()) { 56 result = get_interface<PPB_Flash_File_ModuleLocal_3_0>()-> 57 RenameFile(instance.pp_instance(), path_from.c_str(), path_to.c_str()); 58 } 59 return result == PP_OK; 60} 61 62// static 63bool FileModuleLocal::DeleteFileOrDir(const InstanceHandle& instance, 64 const std::string& path, 65 bool recursive) { 66 int32_t result = PP_ERROR_FAILED; 67 if (has_interface<PPB_Flash_File_ModuleLocal_3_0>()) { 68 result = get_interface<PPB_Flash_File_ModuleLocal_3_0>()-> 69 DeleteFileOrDir(instance.pp_instance(), path.c_str(), 70 PP_FromBool(recursive)); 71 } 72 return result == PP_OK; 73} 74 75// static 76bool FileModuleLocal::CreateDir(const InstanceHandle& instance, 77 const std::string& path) { 78 int32_t result = PP_ERROR_FAILED; 79 if (has_interface<PPB_Flash_File_ModuleLocal_3_0>()) { 80 result = get_interface<PPB_Flash_File_ModuleLocal_3_0>()-> 81 CreateDir(instance.pp_instance(), path.c_str()); 82 } 83 return result == PP_OK; 84} 85 86// static 87bool FileModuleLocal::QueryFile(const InstanceHandle& instance, 88 const std::string& path, 89 PP_FileInfo* info) { 90 int32_t result = PP_ERROR_FAILED; 91 if (has_interface<PPB_Flash_File_ModuleLocal_3_0>()) { 92 result = get_interface<PPB_Flash_File_ModuleLocal_3_0>()-> 93 QueryFile(instance.pp_instance(), path.c_str(), info); 94 } 95 return result == PP_OK; 96} 97 98// static 99bool FileModuleLocal::GetDirContents( 100 const InstanceHandle& instance, 101 const std::string& path, 102 std::vector<DirEntry>* dir_contents) { 103 dir_contents->clear(); 104 105 int32_t result = PP_ERROR_FAILED; 106 if (has_interface<PPB_Flash_File_ModuleLocal_3_0>()) { 107 PP_DirContents_Dev* contents = NULL; 108 result = get_interface<PPB_Flash_File_ModuleLocal_3_0>()-> 109 GetDirContents(instance.pp_instance(), path.c_str(), &contents); 110 if (result == PP_OK && contents) { 111 for (int32_t i = 0; i < contents->count; i++) 112 dir_contents->push_back(ConvertDirEntry(contents->entries[i])); 113 } 114 if (contents) { 115 get_interface<PPB_Flash_File_ModuleLocal_3_0>()-> 116 FreeDirContents(instance.pp_instance(), contents); 117 } 118 } 119 return result == PP_OK; 120} 121 122// static 123PP_FileHandle FileModuleLocal::CreateTemporaryFile( 124 const InstanceHandle& instance) { 125 PP_FileHandle file_handle = PP_kInvalidFileHandle; 126 int32_t result = PP_ERROR_FAILED; 127 if (has_interface<PPB_Flash_File_ModuleLocal_3_0>()) { 128 result = get_interface<PPB_Flash_File_ModuleLocal_3_0>()-> 129 CreateTemporaryFile(instance.pp_instance(), &file_handle); 130 } 131 return (result == PP_OK) ? file_handle : PP_kInvalidFileHandle; 132} 133 134} // namespace flash 135 136// FileFileRef ----------------------------------------------------------------- 137 138namespace { 139 140template <> const char* interface_name<PPB_Flash_File_FileRef>() { 141 return PPB_FLASH_FILE_FILEREF_INTERFACE; 142} 143 144} // namespace 145 146namespace flash { 147 148// static 149bool FileFileRef::IsAvailable() { 150 return has_interface<PPB_Flash_File_FileRef>(); 151} 152 153// static 154PP_FileHandle FileFileRef::OpenFile(const pp::FileRef& resource, 155 int32_t mode) { 156 PP_FileHandle file_handle = PP_kInvalidFileHandle; 157 int32_t result = PP_ERROR_FAILED; 158 if (has_interface<PPB_Flash_File_FileRef>()) { 159 result = get_interface<PPB_Flash_File_FileRef>()-> 160 OpenFile(resource.pp_resource(), mode, &file_handle); 161 } 162 return (result == PP_OK) ? file_handle : PP_kInvalidFileHandle; 163} 164 165// static 166bool FileFileRef::QueryFile(const pp::FileRef& resource, 167 PP_FileInfo* info) { 168 int32_t result = PP_ERROR_FAILED; 169 if (has_interface<PPB_Flash_File_FileRef>()) { 170 result = get_interface<PPB_Flash_File_FileRef>()-> 171 QueryFile(resource.pp_resource(), info); 172 } 173 return result == PP_OK; 174} 175 176} // namespace flash 177 178} // namespace pp 179