Home | History | Annotate | Download | only in private 
      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