diff --git a/cocos/platform/CCFileUtils.cpp b/cocos/platform/CCFileUtils.cpp
index 42bb5f76f5..fb0dcec330 100644
--- a/cocos/platform/CCFileUtils.cpp
+++ b/cocos/platform/CCFileUtils.cpp
@@ -59,7 +59,7 @@ THE SOFTWARE.
 
 NS_CC_BEGIN
 
-typedef enum
+typedef enum 
 {
     SAX_NONE = 0,
     SAX_KEY,
@@ -81,22 +81,22 @@ class DictMaker : public SAXDelegator
 {
 public:
     SAXResult _resultType;
-    ValueMap _rootDict;
-    ValueVector _rootArray;
+	ValueMap _rootDict;
+	ValueVector _rootArray;
 
     std::string _curKey;   ///< parsed key
     std::string _curValue; // parsed value
     SAXState _state;
 
-    ValueMap*  _curDict;
+	ValueMap*  _curDict;
     ValueVector* _curArray;
 
-    std::stack<ValueMap*> _dictStack;
+	std::stack<ValueMap*> _dictStack;
     std::stack<ValueVector*> _arrayStack;
     std::stack<SAXState>  _stateStack;
 
 public:
-    DictMaker()
+    DictMaker()        
         : _resultType(SAX_RESULT_NONE)
     {
     }
@@ -114,20 +114,20 @@ public:
         parser.setDelegator(this);
 
         parser.parse(fileName);
-        return _rootDict;
+		return _rootDict;
     }
 
-    ValueMap dictionaryWithDataOfFile(const char* filedata, int filesize)
-    {
-        _resultType = SAX_RESULT_DICT;
-        SAXParser parser;
+	ValueMap dictionaryWithDataOfFile(const char* filedata, int filesize)
+	{
+		_resultType = SAX_RESULT_DICT;
+		SAXParser parser;
 
-        CCASSERT(parser.init("UTF-8"), "The file format isn't UTF-8");
-        parser.setDelegator(this);
+		CCASSERT(parser.init("UTF-8"), "The file format isn't UTF-8");
+		parser.setDelegator(this);
 
-        parser.parse(filedata, filesize);
-        return _rootDict;
-    }
+		parser.parse(filedata, filesize);
+		return _rootDict;
+	}
 
     ValueVector arrayWithContentsOfFile(const std::string& fileName)
     {
@@ -138,7 +138,7 @@ public:
         parser.setDelegator(this);
 
         parser.parse(fileName);
-        return _rootArray;
+		return _rootArray;
     }
 
     void startElement(void *ctx, const char *name, const char **atts)
@@ -148,7 +148,7 @@ public:
         const std::string sName(name);
         if( sName == "dict" )
         {
-            if(_resultType == SAX_RESULT_DICT && _rootDict.empty())
+			if(_resultType == SAX_RESULT_DICT && _rootDict.empty())
             {
                 _curDict = &_rootDict;
             }
@@ -165,7 +165,7 @@ public:
             {
                 // add a new dictionary into the array
                 _curArray->push_back(Value(ValueMap()));
-                _curDict = &(_curArray->rbegin())->asValueMap();
+				_curDict = &(_curArray->rbegin())->asValueMap();
             }
             else if (SAX_DICT == preState)
             {
@@ -173,7 +173,7 @@ public:
                 CCASSERT(! _dictStack.empty(), "The state is wrong!");
                 ValueMap* preDict = _dictStack.top();
                 (*preDict)[_curKey] = Value(ValueMap());
-                _curDict = &(*preDict)[_curKey].asValueMap();
+				_curDict = &(*preDict)[_curKey].asValueMap();
             }
 
             // record the dict state
@@ -200,9 +200,9 @@ public:
         {
             _state = SAX_ARRAY;
 
-            if (_resultType == SAX_RESULT_ARRAY && _rootArray.empty())
+			if (_resultType == SAX_RESULT_ARRAY && _rootArray.empty())
             {
-                _curArray = &_rootArray;
+				_curArray = &_rootArray;
             }
             SAXState preState = SAX_NONE;
             if (! _stateStack.empty())
@@ -213,14 +213,14 @@ public:
             if (preState == SAX_DICT)
             {
                 (*_curDict)[_curKey] = Value(ValueVector());
-                _curArray = &(*_curDict)[_curKey].asValueVector();
+				_curArray = &(*_curDict)[_curKey].asValueVector();
             }
             else if (preState == SAX_ARRAY)
             {
                 CCASSERT(! _arrayStack.empty(), "The state is wrong!");
                 ValueVector* preArray = _arrayStack.top();
                 preArray->push_back(Value(ValueVector()));
-                _curArray = &(_curArray->rbegin())->asValueVector();
+				_curArray = &(_curArray->rbegin())->asValueVector();
             }
             // record the array state
             _stateStack.push(_state);
@@ -300,7 +300,7 @@ public:
 
             _curValue.clear();
         }
-
+        
         _state = SAX_NONE;
     }
 
@@ -328,7 +328,7 @@ public:
                 {
                     CCASSERT(!_curKey.empty(), "key not found : <integer/real>");
                 }
-
+                
                 _curValue.append(text);
             }
             break;
@@ -370,26 +370,22 @@ static tinyxml2::XMLElement* generateElementForDict(const ValueMap& dict, tinyxm
  */
 bool FileUtils::writeToFile(ValueMap& dict, const std::string &fullPath)
 {
-    return writeValueMapToFile(dict, fullPath);
-}
-
-bool FileUtils::writeValueMapToFile(ValueMap& dict, const std::string& fullPath)
-{
-    tinyxml2::XMLDocument *doc = new (std::nothrow)tinyxml2::XMLDocument();
+    //CCLOG("tinyxml2 Dictionary %d writeToFile %s", dict->_ID, fullPath.c_str());
+    tinyxml2::XMLDocument *doc = new tinyxml2::XMLDocument();
     if (nullptr == doc)
         return false;
-
+    
     tinyxml2::XMLDeclaration *declaration = doc->NewDeclaration("xml version=\"1.0\" encoding=\"UTF-8\"");
     if (nullptr == declaration)
     {
         delete doc;
         return false;
     }
-
+    
     doc->LinkEndChild(declaration);
     tinyxml2::XMLElement *docType = doc->NewElement("!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\"");
     doc->LinkEndChild(docType);
-
+    
     tinyxml2::XMLElement *rootEle = doc->NewElement("plist");
     rootEle->SetAttribute("version", "1.0");
     if (nullptr == rootEle)
@@ -398,57 +394,17 @@ bool FileUtils::writeValueMapToFile(ValueMap& dict, const std::string& fullPath)
         return false;
     }
     doc->LinkEndChild(rootEle);
-
+    
     tinyxml2::XMLElement *innerDict = generateElementForDict(dict, doc);
-    if (nullptr == innerDict)
+    if (nullptr == innerDict )
     {
         delete doc;
         return false;
     }
     rootEle->LinkEndChild(innerDict);
-
+    
     bool ret = tinyxml2::XML_SUCCESS == doc->SaveFile(getSuitableFOpen(fullPath).c_str());
-
-    delete doc;
-    return ret;
-}
-
-bool FileUtils::writeValueVectorToFile(ValueVector vecData, const std::string& fullPath)
-{
-    tinyxml2::XMLDocument *doc = new (std::nothrow)tinyxml2::XMLDocument();
-    if (nullptr == doc)
-        return false;
-
-    tinyxml2::XMLDeclaration *declaration = doc->NewDeclaration("xml version=\"1.0\" encoding=\"UTF-8\"");
-    if (nullptr == declaration)
-    {
-        delete doc;
-        return false;
-    }
-
-    doc->LinkEndChild(declaration);
-    tinyxml2::XMLElement *docType = doc->NewElement("!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\"");
-    doc->LinkEndChild(docType);
-
-    tinyxml2::XMLElement *rootEle = doc->NewElement("plist");
-    rootEle->SetAttribute("version", "1.0");
-    if (nullptr == rootEle)
-    {
-        delete doc;
-        return false;
-    }
-    doc->LinkEndChild(rootEle);
-
-    tinyxml2::XMLElement *innerDict = generateElementForArray(vecData, doc);
-    if (nullptr == innerDict)
-    {
-        delete doc;
-        return false;
-    }
-    rootEle->LinkEndChild(innerDict);
-
-    bool ret = tinyxml2::XML_SUCCESS == doc->SaveFile(getSuitableFOpen(fullPath).c_str());
-
+    
     delete doc;
     return ret;
 }
@@ -466,7 +422,7 @@ static tinyxml2::XMLElement* generateElementForObject(const Value& value, tinyxm
         node->LinkEndChild(content);
         return node;
     }
-
+    
     // object is integer
     if (value.getType() == Value::Type::INTEGER)
     {
@@ -484,21 +440,21 @@ static tinyxml2::XMLElement* generateElementForObject(const Value& value, tinyxm
         node->LinkEndChild(content);
         return node;
     }
-
+    
     //object is bool
     if (value.getType() == Value::Type::BOOLEAN) {
-        tinyxml2::XMLElement* node = doc->NewElement(value.asString().c_str());
-        return node;
+		tinyxml2::XMLElement* node = doc->NewElement(value.asString().c_str());
+		return node;
     }
 
     // object is Array
     if (value.getType() == Value::Type::VECTOR)
         return generateElementForArray(value.asValueVector(), doc);
-
+    
     // object is Dictionary
     if (value.getType() == Value::Type::MAP)
         return generateElementForDict(value.asValueMap(), doc);
-
+    
     CCLOG("This type cannot appear in property list");
     return nullptr;
 }
@@ -509,14 +465,14 @@ static tinyxml2::XMLElement* generateElementForObject(const Value& value, tinyxm
 static tinyxml2::XMLElement* generateElementForDict(const ValueMap& dict, tinyxml2::XMLDocument *doc)
 {
     tinyxml2::XMLElement* rootNode = doc->NewElement("dict");
-
+    
     for (const auto &iter : dict)
     {
         tinyxml2::XMLElement* tmpNode = doc->NewElement("key");
         rootNode->LinkEndChild(tmpNode);
         tinyxml2::XMLText* content = doc->NewText(iter.first.c_str());
         tmpNode->LinkEndChild(content);
-
+        
         tinyxml2::XMLElement *element = generateElementForObject(iter.second, doc);
         if (element)
             rootNode->LinkEndChild(element);
@@ -561,7 +517,7 @@ void FileUtils::setDelegate(FileUtils *delegate)
 {
     if (s_sharedFileUtils)
         delete s_sharedFileUtils;
-
+        
     s_sharedFileUtils = delegate;
 }
 
@@ -574,38 +530,7 @@ FileUtils::~FileUtils()
 {
 }
 
-bool FileUtils::writeStringToFile(std::string dataStr, const std::string& fullPath)
-{
-    Data retData;
-    retData.copy((unsigned char*)dataStr.c_str(), dataStr.size());
 
-    return writeDataToFile(retData, fullPath);
-}
-
-bool FileUtils::writeDataToFile(Data retData, const std::string& fullPath)
-{
-    size_t size = 0;
-    const char* mode = "wb";
-
-    CCASSERT(!fullPath.empty() && retData.getSize() != 0, "Invalid parameters.");
-
-    auto fileutils = FileUtils::getInstance();
-    do
-    {
-        // Read the file from hardware
-        FILE *fp = fopen(fileutils->getSuitableFOpen(fullPath).c_str(), mode);
-        CC_BREAK_IF(!fp);
-        size = retData.getSize();
-
-        fwrite(retData.getBytes(), size, 1, fp);
-
-        fclose(fp);
-
-        return true;
-    } while (0);
-
-    return false;
-}
 
 bool FileUtils::init()
 {
@@ -625,13 +550,13 @@ static Data getData(const std::string& filename, bool forString)
     {
         return Data::Null;
     }
-
+    
     Data ret;
     unsigned char* buffer = nullptr;
     size_t size = 0;
     size_t readsize;
     const char* mode = nullptr;
-
+    
     if (forString)
         mode = "rt";
     else
@@ -647,7 +572,7 @@ static Data getData(const std::string& filename, bool forString)
         fseek(fp,0,SEEK_END);
         size = ftell(fp);
         fseek(fp,0,SEEK_SET);
-
+        
         if (forString)
         {
             buffer = (unsigned char*)malloc(sizeof(unsigned char) * (size + 1));
@@ -657,16 +582,16 @@ static Data getData(const std::string& filename, bool forString)
         {
             buffer = (unsigned char*)malloc(sizeof(unsigned char) * size);
         }
-
+        
         readsize = fread(buffer, sizeof(unsigned char), size, fp);
         fclose(fp);
-
+        
         if (forString && readsize < size)
         {
             buffer[readsize] = '\0';
         }
     } while (0);
-
+    
     if (nullptr == buffer || 0 == readsize)
     {
         CCLOG("Get data from file %s failed", filename.c_str());
@@ -675,7 +600,7 @@ static Data getData(const std::string& filename, bool forString)
     {
         ret.fastSet(buffer, readsize);
     }
-
+    
     return ret;
 }
 
@@ -683,8 +608,8 @@ std::string FileUtils::getStringFromFile(const std::string& filename)
 {
     Data data = getData(filename, true);
     if (data.isNull())
-        return "";
-
+    	return "";
+    
     std::string ret((const char*)data.getBytes());
     return ret;
 }
@@ -705,7 +630,7 @@ unsigned char* FileUtils::getFileData(const std::string& filename, const char* m
         const std::string fullPath = fullPathForFilename(filename);
         FILE *fp = fopen(getSuitableFOpen(fullPath).c_str(), mode);
         CC_BREAK_IF(!fp);
-
+        
         fseek(fp,0,SEEK_END);
         *size = ftell(fp);
         fseek(fp,0,SEEK_SET);
@@ -713,12 +638,12 @@ unsigned char* FileUtils::getFileData(const std::string& filename, const char* m
         *size = fread(buffer,sizeof(unsigned char), *size,fp);
         fclose(fp);
     } while (0);
-
+    
     if (!buffer)
     {
         std::string msg = "Get data from file(";
         msg.append(filename).append(") failed!");
-
+        
         CCLOG("%s", msg.c_str());
     }
     return buffer;
@@ -730,14 +655,14 @@ unsigned char* FileUtils::getFileDataFromZip(const std::string& zipFilePath, con
     unzFile file = nullptr;
     *size = 0;
 
-    do
+    do 
     {
         CC_BREAK_IF(zipFilePath.empty());
 
         file = unzOpen(zipFilePath.c_str());
         CC_BREAK_IF(!file);
 
-        // FIXME: Other platforms should use upstream minizip like mingw-w64
+        // FIXME: Other platforms should use upstream minizip like mingw-w64  
         #ifdef MINIZIP_FROM_SYSTEM
         int ret = unzLocateFile(file, filename.c_str(), NULL);
         #else
@@ -772,7 +697,7 @@ unsigned char* FileUtils::getFileDataFromZip(const std::string& zipFilePath, con
 std::string FileUtils::getNewFilename(const std::string &filename) const
 {
     std::string newFileName;
-
+    
     // in Lookup Filename dictionary ?
     auto iter = _filenameLookupDict.find(filename);
 
@@ -797,14 +722,14 @@ std::string FileUtils::getPathForFilename(const std::string& filename, const std
         file_path = filename.substr(0, pos+1);
         file = filename.substr(pos+1);
     }
-
+    
     // searchPath + file_path + resourceDirectory
     std::string path = searchPath;
     path += file_path;
     path += resolutionDirectory;
-
+    
     path = getFullPathForDirectoryAndFilename(path, file);
-
+    
     //CCLOG("getPathForFilename, fullPath = %s", path.c_str());
     return path;
 }
@@ -815,7 +740,7 @@ std::string FileUtils::fullPathForFilename(const std::string &filename) const
     {
         return "";
     }
-
+    
     if (isAbsolutePath(filename))
     {
         return filename;
@@ -827,28 +752,28 @@ std::string FileUtils::fullPathForFilename(const std::string &filename) const
     {
         return cacheIter->second;
     }
-
+    
     // Get the new file name.
     const std::string newFilename( getNewFilename(filename) );
-
-    std::string fullpath;
-
+    
+	std::string fullpath;
+    
     for (const auto& searchIt : _searchPathArray)
     {
         for (const auto& resolutionIt : _searchResolutionsOrderArray)
         {
             fullpath = this->getPathForFilename(newFilename, resolutionIt, searchIt);
-
+            
             if (fullpath.length() > 0)
             {
                 // Using the filename passed in as key.
                 _fullPathCache.insert(std::make_pair(filename, fullpath));
                 return fullpath;
             }
-
+            
         }
     }
-
+    
     if(isPopupNotify()){
         CCLOG("cocos2d: fullPathForFilename: No file found at %s. Possible missing file.", filename.c_str());
     }
@@ -874,12 +799,12 @@ void FileUtils::setSearchResolutionsOrder(const std::vector<std::string>& search
         {
             existDefault = true;
         }
-
+        
         if (resolutionDirectory.length() > 0 && resolutionDirectory[resolutionDirectory.length()-1] != '/')
         {
             resolutionDirectory += "/";
         }
-
+        
         _searchResolutionsOrderArray.push_back(resolutionDirectory);
     }
 
@@ -894,7 +819,7 @@ void FileUtils::addSearchResolutionsOrder(const std::string &order,const bool fr
     std::string resOrder = order;
     if (!resOrder.empty() && resOrder[resOrder.length()-1] != '/')
         resOrder.append("/");
-
+    
     if (front) {
         _searchResolutionsOrderArray.insert(_searchResolutionsOrderArray.begin(), resOrder);
     } else {
@@ -925,14 +850,14 @@ void FileUtils::setDefaultResourceRootPath(const std::string& path)
 void FileUtils::setSearchPaths(const std::vector<std::string>& searchPaths)
 {
     bool existDefaultRootPath = false;
-
+    
     _fullPathCache.clear();
     _searchPathArray.clear();
     for (const auto& iter : searchPaths)
     {
         std::string prefix;
         std::string path;
-
+        
         if (!isAbsolutePath(iter))
         { // Not an absolute path
             prefix = _defaultResRootPath;
@@ -948,7 +873,7 @@ void FileUtils::setSearchPaths(const std::vector<std::string>& searchPaths)
         }
         _searchPathArray.push_back(path);
     }
-
+    
     if (!existDefaultRootPath)
     {
         //CCLOG("Default root path doesn't exist, adding it.");
@@ -967,16 +892,6 @@ void FileUtils::addSearchPath(const std::string &searchpath,const bool front)
     {
         path += "/";
     }
-    
-    auto iter = std::find(_searchPathArray.begin(), _searchPathArray.end(), searchpath);
-    if (iter != _searchPathArray.cend())
-    {
-        if (front)
-            _searchPathArray.erase(iter);
-        else
-            return;
-    }
-
     if (front) {
         _searchPathArray.insert(_searchPathArray.begin(), path);
     } else {
@@ -986,7 +901,7 @@ void FileUtils::addSearchPath(const std::string &searchpath,const bool front)
 
 void FileUtils::setFilenameLookupDictionary(const ValueMap& filenameLookupDict)
 {
-    _fullPathCache.clear();
+    _fullPathCache.clear();    
     _filenameLookupDict = filenameLookupDict;
 }
 
@@ -1012,13 +927,13 @@ void FileUtils::loadFilenameLookupDictionaryFromFile(const std::string &filename
 
 std::string FileUtils::getFullPathForDirectoryAndFilename(const std::string& directory, const std::string& filename) const
 {
-    // get directory+filename, safely adding '/' as necessary
+    // get directory+filename, safely adding '/' as necessary 
     std::string ret = directory;
     if (directory.size() && directory[directory.size()-1] != '/'){
         ret += '/';
     }
     ret += filename;
-
+    
     // if the file doesn't exist, return an empty string
     if (!isFileExistInternal(ret)) {
         ret = "";
@@ -1026,6 +941,23 @@ std::string FileUtils::getFullPathForDirectoryAndFilename(const std::string& dir
     return ret;
 }
 
+std::string FileUtils::searchFullPathForFilename(const std::string& filename) const
+{
+    if (isAbsolutePath(filename))
+    {
+        return filename;
+    }
+    std::string path = fullPathForFilename(filename);
+    if (0 == path.compare(filename))
+    {
+        return "";
+    }
+    else
+    {
+        return path;
+    }
+}
+
 bool FileUtils::isFileExist(const std::string& filename) const
 {
     if (isAbsolutePath(filename))
@@ -1034,7 +966,7 @@ bool FileUtils::isFileExist(const std::string& filename) const
     }
     else
     {
-        std::string fullpath = fullPathForFilename(filename);
+        std::string fullpath = searchFullPathForFilename(filename);
         if (fullpath.empty())
             return false;
         else
@@ -1047,23 +979,46 @@ bool FileUtils::isAbsolutePath(const std::string& path) const
     return (path[0] == '/');
 }
 
+bool FileUtils::isDirectoryExistInternal(const std::string& dirPath) const
+{
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
+    WIN32_FILE_ATTRIBUTE_DATA wfad;
+    std::wstring wdirPath(dirPath.begin(), dirPath.end());
+    if (GetFileAttributesEx(wdirPath.c_str(), GetFileExInfoStandard, &wfad))
+	{
+		return true;
+	}
+	return false;
+#elif (CC_TARGET_PLATFORM != CC_PLATFORM_WIN32)
+    struct stat st;
+    if (stat(dirPath.c_str(), &st) == 0)
+    {
+        return S_ISDIR(st.st_mode);
+    }
+    return false;
+#else
+    CCASSERT(false, "FileUtils not support isDirectoryExistInternal");
+    return false;
+#endif
+}
+
 bool FileUtils::isDirectoryExist(const std::string& dirPath) const
 {
     CCASSERT(!dirPath.empty(), "Invalid path");
-
+    
     if (isAbsolutePath(dirPath))
     {
         return isDirectoryExistInternal(dirPath);
     }
-
+    
     // Already Cached ?
     auto cacheIter = _fullPathCache.find(dirPath);
     if( cacheIter != _fullPathCache.end() )
     {
         return isDirectoryExistInternal(cacheIter->second);
     }
-
-    std::string fullpath;
+    
+	std::string fullpath;
     for (const auto& searchIt : _searchPathArray)
     {
         for (const auto& resolutionIt : _searchResolutionsOrderArray)
@@ -1077,22 +1032,23 @@ bool FileUtils::isDirectoryExist(const std::string& dirPath) const
             }
         }
     }
+    
     return false;
 }
 
 bool FileUtils::createDirectory(const std::string& path)
 {
     CCASSERT(!path.empty(), "Invalid path");
-
+    
     if (isDirectoryExist(path))
         return true;
-
+    
     // Split the path
     size_t start = 0;
     size_t found = path.find_first_of("/\\", start);
     std::string subpath;
     std::vector<std::string> dirs;
-
+    
     if (found != std::string::npos)
     {
         while (true)
@@ -1115,45 +1071,27 @@ bool FileUtils::createDirectory(const std::string& path)
 
 
 #if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
-    WIN32_FILE_ATTRIBUTE_DATA wfad;
+	WIN32_FILE_ATTRIBUTE_DATA wfad;
     std::wstring wpath(path.begin(), path.end());
     if (!(GetFileAttributesEx(wpath.c_str(), GetFileExInfoStandard, &wfad)))
-    {
-        subpath = "";
-        for(unsigned int i = 0 ; i < dirs.size() ; ++i)
-        {
-            subpath += dirs[i];
-            if (i > 0 && !isDirectoryExist(subpath))
-            {
+	{
+		subpath = "";
+		for(unsigned int i = 0 ; i < dirs.size() ; ++i)
+		{
+			subpath += dirs[i];
+			if (i > 0 && !isDirectoryExist(subpath))
+			{
                 std::wstring wsubpath(subpath.begin(), subpath.end());
                 BOOL ret = CreateDirectory(wsubpath.c_str(), NULL);
-                if (!ret && ERROR_ALREADY_EXISTS != GetLastError())
-                {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
-#elif (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
-    if ((GetFileAttributesA(path.c_str())) == INVALID_FILE_ATTRIBUTES)
-    {
-        subpath = "";
-        for (unsigned int i = 0; i < dirs.size(); ++i)
-        {
-            subpath += dirs[i];
-            if (!isDirectoryExist(subpath))
-            {
-                BOOL ret = CreateDirectoryA(subpath.c_str(), NULL);
-                if (!ret && ERROR_ALREADY_EXISTS != GetLastError())
-                {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
-#else
+				if (!ret && ERROR_ALREADY_EXISTS != GetLastError())
+				{
+					return false;
+				}
+			}
+		}
+	}
+	return true;
+#elif (CC_TARGET_PLATFORM != CC_PLATFORM_WIN32)
     DIR *dir = NULL;
 
     // Create path recursively
@@ -1162,11 +1100,11 @@ bool FileUtils::createDirectory(const std::string& path)
     {
         subpath += dirs[i];
         dir = opendir(subpath.c_str());
-
+        
         if (!dir)
         {
             // directory doesn't exist, should create a new one
-
+            
             int ret = mkdir(subpath.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
             if (ret != 0 && (errno != EEXIST))
             {
@@ -1182,6 +1120,9 @@ bool FileUtils::createDirectory(const std::string& path)
         }
     }
     return true;
+#else
+    CCASSERT(false, "FileUtils not support createDirectory");
+    return false;
 #endif
 }
 
@@ -1193,7 +1134,7 @@ static int unlink_cb(const char *fpath, const struct stat *sb, int typeflag, str
     {
         log("Fail to remove: %s ",fpath);
     }
-
+    
     return ret;
 }
 #endif
@@ -1205,59 +1146,50 @@ bool FileUtils::removeDirectory(const std::string& path)
         CCLOGERROR("Fail to remove directory, path must termniate with '/': %s", path.c_str());
         return false;
     }
-
+    
     // Remove downloaded files
 
 #if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
     std::wstring wpath = std::wstring(path.begin(), path.end());
     std::wstring files = wpath +  L"*.*";
-    WIN32_FIND_DATA wfd;
-    HANDLE  search = FindFirstFileEx(files.c_str(), FindExInfoStandard, &wfd, FindExSearchNameMatch, NULL, 0);
-    bool ret=true;
-    if (search!=INVALID_HANDLE_VALUE)
-    {
-        BOOL find=true;
-        while (find)
-        {
-            //. ..
-            if(wfd.cFileName[0]!='.')
-            {
+	WIN32_FIND_DATA wfd;
+	HANDLE  search = FindFirstFileEx(files.c_str(), FindExInfoStandard, &wfd, FindExSearchNameMatch, NULL, 0);
+	bool ret=true;   
+	if (search!=INVALID_HANDLE_VALUE)   
+	{   
+		BOOL find=true;   
+		while (find)
+		{ 
+			//. ..
+			if(wfd.cFileName[0]!='.')  
+			{   
                 std::wstring temp = wpath + wfd.cFileName;
-                if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-                {
+				if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+				{
                     temp += '/';
                     ret = ret && this->removeDirectory(std::string(temp.begin(), temp.end()));
-                }
-                else
-                {
+				}
+				else
+				{   
                     SetFileAttributes(temp.c_str(), FILE_ATTRIBUTE_NORMAL);
                     ret = ret && DeleteFile(temp.c_str());
-                }
-            }
-            find = FindNextFile(search, &wfd);
-        }
-        FindClose(search);
-    }
+				}
+			}
+			find = FindNextFile(search, &wfd);
+		}
+		FindClose(search);
+	}
     if (ret && RemoveDirectory(wpath.c_str()))
     {
         return true;
     }
-    return false;
-#elif (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
-    std::string command = "cmd /c rd /s /q ";
-    // Path may include space.
-    command += "\"" + path + "\"";
-
-    if (WinExec(command.c_str(), SW_HIDE) > 31)
-        return true;
-    else
-        return false;
+	return false;
 #elif (CC_TARGET_PLATFORM == CC_PLATFORM_IOS) || (CC_TARGET_PLATFORM == CC_PLATFORM_MAC)
     if (nftw(path.c_str(),unlink_cb, 64, FTW_DEPTH | FTW_PHYS))
         return false;
     else
         return true;
-#else
+#elif (CC_TARGET_PLATFORM != CC_PLATFORM_WIN32)
     std::string command = "rm -r ";
     // Path may include space.
     command += "\"" + path + "\"";
@@ -1265,6 +1197,9 @@ bool FileUtils::removeDirectory(const std::string& path)
         return true;
     else
         return false;
+#else
+    CCASSERT(false, "FileUtils not support removeDirectory");
+    return false;
 #endif
 }
 
@@ -1275,33 +1210,19 @@ bool FileUtils::removeFile(const std::string &path)
 #if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
     std::wstring wpath(path.begin(), path.end());
     if (DeleteFile(wpath.c_str()))
-    {
-        return true;
-    }
-    return false;
-#elif (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
-    std::string command = "cmd /c del /q ";
-    std::string win32path = path;
-    int len = win32path.length();
-    for (int i = 0; i < len; ++i)
-    {
-        if (win32path[i] == '/')
-        {
-            win32path[i] = '\\';
-        }
-    }
-    command += win32path;
-
-    if (WinExec(command.c_str(), SW_HIDE) > 31)
-        return true;
-    else
-        return false;
-#else
+	{
+		return true;
+	}
+	return false;
+#elif (CC_TARGET_PLATFORM != CC_PLATFORM_WIN32)
     if (remove(path.c_str())) {
         return false;
     } else {
         return true;
     }
+#else
+    CCASSERT(false, "FileUtils not support removeFile");
+    return false;
 #endif
 }
 
@@ -1310,42 +1231,20 @@ bool FileUtils::renameFile(const std::string &path, const std::string &oldname,
     CCASSERT(!path.empty(), "Invalid path");
     std::string oldPath = path + oldname;
     std::string newPath = path + name;
-
+ 
     // Rename a file
 #if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
     std::regex pat("\\/");
     std::string _old = std::regex_replace(oldPath, pat, "\\");
     std::string _new = std::regex_replace(newPath, pat, "\\");
-    if (MoveFileEx(std::wstring(_old.begin(), _old.end()).c_str(),
+    if (MoveFileEx(std::wstring(_old.begin(), _old.end()).c_str(), 
         std::wstring(_new.begin(), _new.end()).c_str(),
         MOVEFILE_REPLACE_EXISTING & MOVEFILE_WRITE_THROUGH))
     {
         return true;
     }
     return false;
-#elif (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
-    std::regex pat("\\/");
-    std::string _old = std::regex_replace(oldPath, pat, "\\");
-    std::string _new = std::regex_replace(newPath, pat, "\\");
-
-    if(FileUtils::getInstance()->isFileExist(_new))
-    {
-        if (!DeleteFileA(_new.c_str()))
-        {
-            CCLOGERROR("Fail to delete file %s !Error code is 0x%x", newPath.c_str(), GetLastError());
-        }
-    }
-
-    if (MoveFileA(_old.c_str(), _new.c_str()))
-    {
-        return true;
-    }
-    else
-    {
-        CCLOGERROR("Fail to rename file %s to %s !Error code is 0x%x", oldPath.c_str(), newPath.c_str(), GetLastError());
-        return false;
-    }
-#else
+#elif (CC_TARGET_PLATFORM != CC_PLATFORM_WIN32)
     int errorCode = rename(oldPath.c_str(), newPath.c_str());
 
     if (0 != errorCode)
@@ -1354,25 +1253,28 @@ bool FileUtils::renameFile(const std::string &path, const std::string &oldname,
         return false;
     }
     return true;
+#else
+    CCASSERT(false, "FileUtils not support renameFile");
+    return false;
 #endif
 }
 
 long FileUtils::getFileSize(const std::string &filepath)
 {
     CCASSERT(!filepath.empty(), "Invalid path");
-
+    
     std::string fullpath = filepath;
     if (!isAbsolutePath(filepath))
     {
-        fullpath = fullPathForFilename(filepath);
+        fullpath = searchFullPathForFilename(filepath);
         if (fullpath.empty())
             return 0;
     }
-
+    
     struct stat info;
     // Get data associated with "crt_stat.c":
     int result = stat( fullpath.c_str(), &info );
-
+    
     // Check if statistics are valid:
     if( result != 0 )
     {
@@ -1460,7 +1362,6 @@ std::string FileUtils::getSuitableFOpen(const std::string& filenameUtf8) const
 {
     return filenameUtf8;
 }
-
 #endif
 
 NS_CC_END
diff --git a/cocos/platform/win32/CCFileUtils-win32.cpp b/cocos/platform/win32/CCFileUtils-win32.cpp
index 488e761052..5b948e2445 100644
--- a/cocos/platform/win32/CCFileUtils-win32.cpp
+++ b/cocos/platform/win32/CCFileUtils-win32.cpp
@@ -30,6 +30,7 @@ THE SOFTWARE.
 #include "platform/CCCommon.h"
 #include <Shlobj.h>
 #include <cstdlib>
+#include <regex>
 
 using namespace std;
 
@@ -56,6 +57,55 @@ static inline std::string convertPathFormatToUnixStyle(const std::string& path)
     return ret;
 }
 
+static std::wstring StringUtf8ToWideChar(const std::string& strUtf8)
+{
+    std::wstring ret;
+    if (!strUtf8.empty())
+    {
+        int nNum = MultiByteToWideChar(CP_UTF8, 0, strUtf8.c_str(), -1, nullptr, 0);
+        if (nNum)
+        {
+            WCHAR* wideCharString = new WCHAR[nNum + 1];
+            wideCharString[0] = 0;
+
+            nNum = MultiByteToWideChar(CP_UTF8, 0, strUtf8.c_str(), -1, wideCharString, nNum + 1);
+
+            ret = wideCharString;
+            delete[] wideCharString;
+        }
+        else
+        {
+            CCLOG("Wrong convert to WideChar code:0x%x", GetLastError());
+        }
+    }
+    return ret;
+}
+
+static std::string StringWideCharToUtf8(const std::wstring& strWideChar)
+{
+    std::string ret;
+    if (!strWideChar.empty())
+    {
+        int nNum = WideCharToMultiByte(CP_UTF8, 0, strWideChar.c_str(), -1, nullptr, 0, nullptr, FALSE);
+        if (nNum)
+        {
+            char* utf8String = new char[nNum + 1];
+            utf8String[0] = 0;
+
+            nNum = WideCharToMultiByte(CP_UTF8, 0, strWideChar.c_str(), -1, utf8String, nNum + 1, nullptr, FALSE);
+
+            ret = utf8String;
+            delete[] utf8String;
+        }
+        else
+        {
+            CCLOG("Wrong convert to Utf8 code:0x%x", GetLastError());
+        }
+    }
+
+    return ret;
+}
+
 static void _checkPath()
 {
     if (0 == s_resourcePath.length())
@@ -99,6 +149,17 @@ bool FileUtilsWin32::init()
     return FileUtils::init();
 }
 
+bool FileUtilsWin32::isDirectoryExistInternal(const std::string& dirPath) const
+{
+    unsigned long fAttrib = GetFileAttributes(StringUtf8ToWideChar(dirPath).c_str());
+    if (fAttrib != INVALID_FILE_ATTRIBUTES &&
+        (fAttrib & FILE_ATTRIBUTE_DIRECTORY))
+    {
+        return true;
+    }
+    return false;
+}
+
 bool FileUtilsWin32::isFileExistInternal(const std::string& strFilePath) const
 {
     if (0 == strFilePath.length())
@@ -112,10 +173,7 @@ bool FileUtilsWin32::isFileExistInternal(const std::string& strFilePath) const
         strPath.insert(0, _defaultResRootPath);
     }
 
-    WCHAR utf16Buf[CC_MAX_PATH] = {0};
-    MultiByteToWideChar(CP_UTF8, 0, strPath.c_str(), -1, utf16Buf, sizeof(utf16Buf)/sizeof(utf16Buf[0]));
-
-    DWORD attr = GetFileAttributesW(utf16Buf);
+    DWORD attr = GetFileAttributesW(StringUtf8ToWideChar(strPath).c_str());
     if(attr == INVALID_FILE_ATTRIBUTES || (attr & FILE_ATTRIBUTE_DIRECTORY))
         return false;   //  not a file
     return true;
@@ -206,10 +264,7 @@ static Data getData(const std::string& filename, bool forString)
         // check if the filename uses correct case characters
         CC_BREAK_IF(!checkFileName(fullPath, filename));
 
-        WCHAR wszBuf[CC_MAX_PATH] = {0};
-        MultiByteToWideChar(CP_UTF8, 0, fullPath.c_str(), -1, wszBuf, sizeof(wszBuf)/sizeof(wszBuf[0]));
-
-        HANDLE fileHandle = ::CreateFileW(wszBuf, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, nullptr);
+        HANDLE fileHandle = ::CreateFile(StringUtf8ToWideChar(fullPath).c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, nullptr);
         CC_BREAK_IF(fileHandle == INVALID_HANDLE_VALUE);
 
         size = ::GetFileSize(fileHandle, nullptr);
@@ -291,10 +346,7 @@ unsigned char* FileUtilsWin32::getFileData(const std::string& filename, const ch
          // check if the filename uses correct case characters
         CC_BREAK_IF(!checkFileName(fullPath, filename));
 
-        WCHAR wszBuf[CC_MAX_PATH] = {0};
-        MultiByteToWideChar(CP_UTF8, 0, fullPath.c_str(), -1, wszBuf, sizeof(wszBuf)/sizeof(wszBuf[0]));
-
-        HANDLE fileHandle = ::CreateFileW(wszBuf, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, nullptr);
+        HANDLE fileHandle = ::CreateFile(StringUtf8ToWideChar(fullPath).c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, nullptr);
         CC_BREAK_IF(fileHandle == INVALID_HANDLE_VALUE);
 
         *size = ::GetFileSize(fileHandle, nullptr);
@@ -351,49 +403,191 @@ string FileUtilsWin32::getWritablePath() const
     }
 
     // Get full path of executable, e.g. c:\Program Files (x86)\My Game Folder\MyGame.exe
-    char full_path[CC_MAX_PATH + 1];
-    ::GetModuleFileNameA(nullptr, full_path, CC_MAX_PATH + 1);
+    WCHAR full_path[CC_MAX_PATH + 1] = { 0 };
+    ::GetModuleFileName(nullptr, full_path, CC_MAX_PATH + 1);
 
     // Debug app uses executable directory; Non-debug app uses local app data directory
 //#ifndef _DEBUG
-        // Get filename of executable only, e.g. MyGame.exe
-        char *base_name = strrchr(full_path, '\\');
+    // Get filename of executable only, e.g. MyGame.exe
+    WCHAR *base_name = wcsrchr(full_path, '\\');
+    wstring retPath;
+    if(base_name)
+    {
+        WCHAR app_data_path[CC_MAX_PATH + 1];
 
-        if(base_name)
+        // Get local app data directory, e.g. C:\Documents and Settings\username\Local Settings\Application Data
+        if (SUCCEEDED(SHGetFolderPath(nullptr, CSIDL_LOCAL_APPDATA, nullptr, SHGFP_TYPE_CURRENT, app_data_path)))
         {
-            char app_data_path[CC_MAX_PATH + 1];
+            wstring ret(app_data_path);
 
-            // Get local app data directory, e.g. C:\Documents and Settings\username\Local Settings\Application Data
-            if (SUCCEEDED(SHGetFolderPathA(nullptr, CSIDL_LOCAL_APPDATA, nullptr, SHGFP_TYPE_CURRENT, app_data_path)))
+            // Adding executable filename, e.g. C:\Documents and Settings\username\Local Settings\Application Data\MyGame.exe
+            ret += base_name;
+
+            // Remove ".exe" extension, e.g. C:\Documents and Settings\username\Local Settings\Application Data\MyGame
+            ret = ret.substr(0, ret.rfind(L"."));
+
+            ret += L"\\";
+
+            // Create directory
+            if (SUCCEEDED(SHCreateDirectoryEx(nullptr, ret.c_str(), nullptr)))
             {
-                string ret((char*)app_data_path);
+                retPath = ret;
+            }
+        }
+    }
+    if (retPath.empty())
+//#endif // not defined _DEBUG
+    {
+        // If fetching of local app data directory fails, use the executable one
+        retPath = full_path;
 
-                // Adding executable filename, e.g. C:\Documents and Settings\username\Local Settings\Application Data\MyGame.exe
-                ret += base_name;
+        // remove xxx.exe
+        retPath = retPath.substr(0, retPath.rfind(L"\\") + 1);
+    }
 
-                // Remove ".exe" extension, e.g. C:\Documents and Settings\username\Local Settings\Application Data\MyGame
-                ret = ret.substr(0, ret.rfind("."));
+    return convertPathFormatToUnixStyle(StringWideCharToUtf8(retPath));
+}
 
-                ret += "\\";
+bool FileUtilsWin32::renameFile(const std::string &path, const std::string &oldname, const std::string &name)
+{
+    CCASSERT(!path.empty(), "Invalid path");
+    std::string oldPath = path + oldname;
+    std::string newPath = path + name;
 
-                // Create directory
-                if (SUCCEEDED(SHCreateDirectoryExA(nullptr, ret.c_str(), nullptr)))
+    std::regex pat("\\/");
+    std::string _old = std::regex_replace(oldPath, pat, "\\");
+    std::string _new = std::regex_replace(newPath, pat, "\\");
+
+    std::wstring _wNew = StringUtf8ToWideChar(_new);
+
+    if (FileUtils::getInstance()->isFileExist(_new))
+    {
+        if (!DeleteFile(_wNew.c_str()))
+        {
+            CCLOGERROR("Fail to delete file %s !Error code is 0x%x", newPath.c_str(), GetLastError());
+        }
+    }
+
+    if (MoveFile(StringUtf8ToWideChar(_old).c_str(), _wNew.c_str()))
+    {
+        return true;
+    }
+    else
+    {
+        CCLOGERROR("Fail to rename file %s to %s !Error code is 0x%x", oldPath.c_str(), newPath.c_str(), GetLastError());
+        return false;
+    }
+}
+
+bool FileUtilsWin32::createDirectory(const std::string& dirPath)
+{
+    CCASSERT(!dirPath.empty(), "Invalid path");
+
+    if (isDirectoryExist(dirPath))
+        return true;
+
+    std::wstring path = StringUtf8ToWideChar(dirPath);
+
+    // Split the path
+    size_t start = 0;
+    size_t found = path.find_first_of(L"/\\", start);
+    std::wstring subpath;
+    std::vector<std::wstring> dirs;
+
+    if (found != std::wstring::npos)
+    {
+        while (true)
+        {
+            subpath = path.substr(start, found - start + 1);
+            if (!subpath.empty())
+                dirs.push_back(subpath);
+            start = found + 1;
+            found = path.find_first_of(L"/\\", start);
+            if (found == std::wstring::npos)
+            {
+                if (start < path.length())
                 {
-                    return convertPathFormatToUnixStyle(ret);
+                    dirs.push_back(path.substr(start));
+                }
+                break;
+            }
+        }
+    }
+
+    if ((GetFileAttributes(path.c_str())) == INVALID_FILE_ATTRIBUTES)
+    {
+        subpath = L"";
+        for (unsigned int i = 0; i < dirs.size(); ++i)
+        {
+            subpath += dirs[i];
+
+            std::string utf8Path = StringWideCharToUtf8(subpath);
+            if (!isDirectoryExist(utf8Path))
+            {
+                BOOL ret = CreateDirectory(subpath.c_str(), NULL);
+                if (!ret && ERROR_ALREADY_EXISTS != GetLastError())
+                {
+                    CCLOGERROR("Fail create directory %s !Error code is 0x%x", utf8Path.c_str(), GetLastError());
+                    return false;
                 }
             }
         }
-//#endif // not defined _DEBUG
+    }
+    return true;
+}
 
-    // If fetching of local app data directory fails, use the executable one
-    string ret((char*)full_path);
+bool FileUtilsWin32::removeFile(const std::string &filepath)
+{
+    std::regex pat("\\/");
+    std::string win32path = std::regex_replace(filepath, pat, "\\");
 
-    // remove xxx.exe
-    ret =  ret.substr(0, ret.rfind("\\") + 1);
+    if (DeleteFile(StringUtf8ToWideChar(win32path).c_str()))
+    {
+        return true;
+    }
+    else
+    {
+        CCLOGERROR("Fail remove file %s !Error code is 0x%x", filepath.c_str(), GetLastError());
+        return false;
+    }
+}
 
-    ret = convertPathFormatToUnixStyle(ret);
-
-    return ret;
+bool FileUtilsWin32::removeDirectory(const std::string& dirPath)
+{
+    std::wstring wpath = StringUtf8ToWideChar(dirPath);
+    std::wstring files = wpath + L"*.*";
+    WIN32_FIND_DATA wfd;
+    HANDLE  search = FindFirstFileEx(files.c_str(), FindExInfoStandard, &wfd, FindExSearchNameMatch, NULL, 0);
+    bool ret = true;
+    if (search != INVALID_HANDLE_VALUE)
+    {
+        BOOL find = true;
+        while (find)
+        {
+            //. ..
+            if (wfd.cFileName[0] != '.')
+            {
+                std::wstring temp = wpath + wfd.cFileName;
+                if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+                {
+                    temp += '/';
+                    ret = ret && this->removeDirectory(StringWideCharToUtf8(temp));
+                }
+                else
+                {
+                    SetFileAttributes(temp.c_str(), FILE_ATTRIBUTE_NORMAL);
+                    ret = ret && DeleteFile(temp.c_str());
+                }
+            }
+            find = FindNextFile(search, &wfd);
+        }
+        FindClose(search);
+    }
+    if (ret && RemoveDirectory(wpath.c_str()))
+    {
+        return true;
+    }
+    return false;
 }
 
 NS_CC_END
diff --git a/cocos/platform/win32/CCFileUtils-win32.h b/cocos/platform/win32/CCFileUtils-win32.h
index 86e0f9d4d9..fc6f95e9c8 100644
--- a/cocos/platform/win32/CCFileUtils-win32.h
+++ b/cocos/platform/win32/CCFileUtils-win32.h
@@ -49,12 +49,53 @@ class CC_DLL FileUtilsWin32 : public FileUtils
 public:
     /* override funtions */
     bool init();
-    virtual std::string getWritablePath() const;
-    virtual bool isAbsolutePath(const std::string& strPath) const;
+    virtual std::string getWritablePath() const override;
+    virtual bool isAbsolutePath(const std::string& strPath) const override;
 protected:
 
     virtual bool isFileExistInternal(const std::string& strFilePath) const override;
+
+    /**
+    *  Renames a file under the given directory.
+    *
+    *  @param path     The parent directory path of the file, it must be an absolute path.
+    *  @param oldname  The current name of the file.
+    *  @param name     The new name of the file.
+    *  @return True if the file have been renamed successfully, false if not.
+    */
+    virtual bool renameFile(const std::string &path, const std::string &oldname, const std::string &name) override;
+
+    /**
+    *  Checks whether a directory exists without considering search paths and resolution orders.
+    *  @param dirPath The directory (with absolute path) to look up for
+    *  @return Returns true if the directory found at the given absolute path, otherwise returns false
+    */
     virtual bool isDirectoryExistInternal(const std::string& dirPath) const override;
+
+    /**
+    *  Removes a file.
+    *
+    *  @param filepath The full path of the file, it must be an absolute path.
+    *  @return True if the file have been removed successfully, false if not.
+    */
+    virtual bool removeFile(const std::string &filepath) override;
+
+    /**
+    *  Creates a directory.
+    *
+    *  @param dirPath The path of the directory, it must be an absolute path.
+    *  @return True if the directory have been created successfully, false if not.
+    */
+    virtual bool createDirectory(const std::string& dirPath) override;
+
+    /**
+    *  Removes a directory.
+    *
+    *  @param dirPath  The full path of the directory, it must be an absolute path.
+    *  @return True if the directory have been removed successfully, false if not.
+    */
+    virtual bool removeDirectory(const std::string& dirPath) override;
+    
     /**
      *  Gets resource file data
      *