mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-19 19:29:32 +00:00
244 lines
7.5 KiB
C++
244 lines
7.5 KiB
C++
// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include <sys/types.h>
|
|
#include "base/file_util.h"
|
|
|
|
#if defined(OS_WIN)
|
|
#include <io.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#if defined(ANDROID) || defined(OS_POSIX)
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include <fstream>
|
|
|
|
#include "base/file_path.h"
|
|
#include "base/logging.h"
|
|
#include "base/string_util.h"
|
|
|
|
#include "base/string_piece.h"
|
|
#include "base/sys_string_conversions.h"
|
|
|
|
namespace {
|
|
|
|
const FilePath::CharType kExtensionSeparator = FILE_PATH_LITERAL('.');
|
|
|
|
} // namespace
|
|
|
|
namespace file_util {
|
|
|
|
bool EndsWithSeparator(const FilePath& path) {
|
|
FilePath::StringType value = path.value();
|
|
if (value.empty())
|
|
return false;
|
|
|
|
return FilePath::IsSeparator(value[value.size() - 1]);
|
|
}
|
|
|
|
void TrimTrailingSeparator(std::wstring* dir) {
|
|
while (dir->length() > 1 && EndsWithSeparator(dir))
|
|
dir->resize(dir->length() - 1);
|
|
}
|
|
|
|
FilePath::StringType GetFileExtensionFromPath(const FilePath& path) {
|
|
FilePath::StringType file_name = path.BaseName().value();
|
|
const FilePath::StringType::size_type last_dot =
|
|
file_name.rfind(kExtensionSeparator);
|
|
return FilePath::StringType(last_dot == FilePath::StringType::npos ?
|
|
FILE_PATH_LITERAL("") :
|
|
file_name, last_dot+1);
|
|
}
|
|
|
|
void InsertBeforeExtension(FilePath* path, const FilePath::StringType& suffix) {
|
|
FilePath::StringType& value =
|
|
const_cast<FilePath::StringType&>(path->value());
|
|
|
|
const FilePath::StringType::size_type last_dot =
|
|
value.rfind(kExtensionSeparator);
|
|
const FilePath::StringType::size_type last_separator =
|
|
value.find_last_of(FilePath::StringType(FilePath::kSeparators));
|
|
|
|
if (last_dot == FilePath::StringType::npos ||
|
|
(last_separator != std::wstring::npos && last_dot < last_separator)) {
|
|
// The path looks something like "C:\pics.old\jojo" or "C:\pics\jojo".
|
|
// We should just append the suffix to the entire path.
|
|
value.append(suffix);
|
|
return;
|
|
}
|
|
|
|
value.insert(last_dot, suffix);
|
|
}
|
|
|
|
void ReplaceExtension(FilePath* path, const FilePath::StringType& extension) {
|
|
FilePath::StringType clean_extension;
|
|
// If the new extension is "" or ".", then we will just remove the current
|
|
// extension.
|
|
if (!extension.empty() &&
|
|
extension != FilePath::StringType(&kExtensionSeparator, 1)) {
|
|
if (extension[0] != kExtensionSeparator)
|
|
clean_extension.append(&kExtensionSeparator, 1);
|
|
clean_extension.append(extension);
|
|
}
|
|
|
|
FilePath::StringType& value =
|
|
const_cast<FilePath::StringType&>(path->value());
|
|
const FilePath::StringType::size_type last_dot =
|
|
value.rfind(kExtensionSeparator);
|
|
const FilePath::StringType::size_type last_separator =
|
|
value.find_last_of(FilePath::StringType(FilePath::kSeparators));
|
|
|
|
// Erase the current extension, if any.
|
|
if ((last_dot > last_separator ||
|
|
last_separator == FilePath::StringType::npos) &&
|
|
last_dot != FilePath::StringType::npos)
|
|
value.erase(last_dot);
|
|
|
|
value.append(clean_extension);
|
|
}
|
|
|
|
FILE* CreateAndOpenTemporaryFile(FilePath* path) {
|
|
FilePath directory;
|
|
if (!GetTempDir(&directory))
|
|
return NULL;
|
|
|
|
return CreateAndOpenTemporaryFileInDir(directory, path);
|
|
}
|
|
|
|
bool GetFileSize(const FilePath& file_path, int64_t* file_size) {
|
|
FileInfo info;
|
|
if (!GetFileInfo(file_path, &info))
|
|
return false;
|
|
*file_size = info.size;
|
|
return true;
|
|
}
|
|
|
|
bool CloseFile(FILE* file) {
|
|
if (file == NULL)
|
|
return true;
|
|
return fclose(file) == 0;
|
|
}
|
|
|
|
// Deprecated functions ----------------------------------------------------
|
|
|
|
bool AbsolutePath(std::wstring* path_str) {
|
|
FilePath path(FilePath::FromWStringHack(*path_str));
|
|
if (!AbsolutePath(&path))
|
|
return false;
|
|
*path_str = path.ToWStringHack();
|
|
return true;
|
|
}
|
|
void AppendToPath(std::wstring* path, const std::wstring& new_ending) {
|
|
if (!path) {
|
|
NOTREACHED();
|
|
return; // Don't crash in this function in release builds.
|
|
}
|
|
|
|
if (!EndsWithSeparator(path))
|
|
path->push_back(FilePath::kSeparators[0]);
|
|
path->append(new_ending);
|
|
}
|
|
bool CopyFile(const std::wstring& from_path, const std::wstring& to_path) {
|
|
return CopyFile(FilePath::FromWStringHack(from_path),
|
|
FilePath::FromWStringHack(to_path));
|
|
}
|
|
bool CreateDirectory(const std::wstring& full_path) {
|
|
return CreateDirectory(FilePath::FromWStringHack(full_path));
|
|
}
|
|
bool CreateNewTempDirectory(const std::wstring& prefix,
|
|
std::wstring* new_temp_path) {
|
|
#if defined(OS_WIN)
|
|
FilePath::StringType dir_prefix(prefix);
|
|
#elif defined(OS_POSIX)
|
|
FilePath::StringType dir_prefix = WideToUTF8(prefix);
|
|
#endif
|
|
FilePath temp_path;
|
|
if (!CreateNewTempDirectory(dir_prefix, &temp_path))
|
|
return false;
|
|
*new_temp_path = temp_path.ToWStringHack();
|
|
return true;
|
|
}
|
|
bool CreateTemporaryFileName(std::wstring* temp_file) {
|
|
FilePath temp_file_path;
|
|
if (!CreateTemporaryFileName(&temp_file_path))
|
|
return false;
|
|
*temp_file = temp_file_path.ToWStringHack();
|
|
return true;
|
|
}
|
|
bool Delete(const std::wstring& path) {
|
|
return Delete(FilePath::FromWStringHack(path));
|
|
}
|
|
bool DirectoryExists(const std::wstring& path) {
|
|
return DirectoryExists(FilePath::FromWStringHack(path));
|
|
}
|
|
bool EndsWithSeparator(std::wstring* path) {
|
|
return EndsWithSeparator(FilePath::FromWStringHack(*path));
|
|
}
|
|
bool EndsWithSeparator(const std::wstring& path) {
|
|
return EndsWithSeparator(FilePath::FromWStringHack(path));
|
|
}
|
|
bool GetCurrentDirectory(std::wstring* path_str) {
|
|
FilePath path;
|
|
if (!GetCurrentDirectory(&path))
|
|
return false;
|
|
*path_str = path.ToWStringHack();
|
|
return true;
|
|
}
|
|
std::wstring GetFileExtensionFromPath(const std::wstring& path) {
|
|
FilePath::StringType extension =
|
|
GetFileExtensionFromPath(FilePath::FromWStringHack(path));
|
|
#if defined(OS_WIN)
|
|
return extension;
|
|
#elif defined(OS_POSIX)
|
|
return UTF8ToWide(extension);
|
|
#endif
|
|
}
|
|
bool GetFileInfo(const std::wstring& file_path, FileInfo* results) {
|
|
return GetFileInfo(FilePath::FromWStringHack(file_path), results);
|
|
}
|
|
std::wstring GetFilenameFromPath(const std::wstring& path) {
|
|
if (path.empty() || EndsWithSeparator(path))
|
|
return std::wstring();
|
|
|
|
return FilePath::FromWStringHack(path).BaseName().ToWStringHack();
|
|
}
|
|
bool GetFileSize(const std::wstring& file_path, int64_t* file_size) {
|
|
return GetFileSize(FilePath::FromWStringHack(file_path), file_size);
|
|
}
|
|
bool GetTempDir(std::wstring* path_str) {
|
|
FilePath path;
|
|
if (!GetTempDir(&path))
|
|
return false;
|
|
*path_str = path.ToWStringHack();
|
|
return true;
|
|
}
|
|
FILE* OpenFile(const std::wstring& filename, const char* mode) {
|
|
return OpenFile(FilePath::FromWStringHack(filename), mode);
|
|
}
|
|
bool PathExists(const std::wstring& path) {
|
|
return PathExists(FilePath::FromWStringHack(path));
|
|
}
|
|
bool PathIsWritable(const std::wstring& path) {
|
|
return PathIsWritable(FilePath::FromWStringHack(path));
|
|
}
|
|
int ReadFile(const std::wstring& filename, char* data, int size) {
|
|
return ReadFile(FilePath::FromWStringHack(filename), data, size);
|
|
}
|
|
bool SetCurrentDirectory(const std::wstring& directory) {
|
|
return SetCurrentDirectory(FilePath::FromWStringHack(directory));
|
|
}
|
|
void UpOneDirectory(std::wstring* dir) {
|
|
FilePath path = FilePath::FromWStringHack(*dir);
|
|
FilePath directory = path.DirName();
|
|
// If there is no separator, we will get back kCurrentDirectory.
|
|
// In this case don't change |dir|.
|
|
if (directory.value() != FilePath::kCurrentDirectory)
|
|
*dir = directory.ToWStringHack();
|
|
}
|
|
int WriteFile(const std::wstring& filename, const char* data, int size) {
|
|
return WriteFile(FilePath::FromWStringHack(filename), data, size);
|
|
}
|
|
} // namespace
|