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
interface_name()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
ConvertDirEntry(const PP_DirEntry_Dev & entry)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
IsAvailable()33 bool FileModuleLocal::IsAvailable() {
34 return has_interface<PPB_Flash_File_ModuleLocal_3_0>();
35 }
36
37 // static
OpenFile(const InstanceHandle & instance,const std::string & path,int32_t mode)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
RenameFile(const InstanceHandle & instance,const std::string & path_from,const std::string & path_to)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
DeleteFileOrDir(const InstanceHandle & instance,const std::string & path,bool recursive)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
CreateDir(const InstanceHandle & instance,const std::string & path)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
QueryFile(const InstanceHandle & instance,const std::string & path,PP_FileInfo * info)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
GetDirContents(const InstanceHandle & instance,const std::string & path,std::vector<DirEntry> * dir_contents)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
CreateTemporaryFile(const InstanceHandle & instance)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
interface_name()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
IsAvailable()149 bool FileFileRef::IsAvailable() {
150 return has_interface<PPB_Flash_File_FileRef>();
151 }
152
153 // static
OpenFile(const pp::FileRef & resource,int32_t mode)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
QueryFile(const pp::FileRef & resource,PP_FileInfo * info)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