The Tor Browser: ipc/chromium/src/base/file_util.cc@6474c204b198 (annotated)

ipc/chromium/src/base/file_util.cc@6474c204b198 (annotated)

ipc/chromium/src/base/file_util.cc

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // 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 "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 CopyDirectory(const std::wstring& from_path, const std::wstring& to_path,
                    bool recursive) {
   return CopyDirectory(FilePath::FromWStringHack(from_path),
                        FilePath::FromWStringHack(to_path),
                        recursive);
 }
 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, bool recursive) {
   return Delete(FilePath::FromWStringHack(path), recursive);
 }
 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

The Tor Browser / annotate

ipc/chromium/src/base/file_util.cc@6474c204b198 (annotated)

ipc/chromium/src/base/file_util.cc