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 13 namespace pp { 14 15 // FileModuleLocal ------------------------------------------------------------- 16 17 namespace { 18 19 template <> const char* interface_name<PPB_Flash_File_ModuleLocal_3_0>() { 20 return PPB_FLASH_FILE_MODULELOCAL_INTERFACE_3_0; 21 } 22 23 } // namespace 24 25 namespace flash { 26 27 static 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 33 bool FileModuleLocal::IsAvailable() { 34 return has_interface<PPB_Flash_File_ModuleLocal_3_0>(); 35 } 36 37 // static 38 PP_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 51 bool 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 63 bool 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 76 bool 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 87 bool 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 99 bool 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 123 PP_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 138 namespace { 139 140 template <> const char* interface_name<PPB_Flash_File_FileRef>() { 141 return PPB_FLASH_FILE_FILEREF_INTERFACE; 142 } 143 144 } // namespace 145 146 namespace flash { 147 148 // static 149 bool FileFileRef::IsAvailable() { 150 return has_interface<PPB_Flash_File_FileRef>(); 151 } 152 153 // static 154 PP_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 166 bool 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