LCOV - app.info - ipc/chromium/src/base/file_util.cc

LCOV - code coverage report
| Current view: | directory - ipc/chromium/src/base - file_util.cc (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 237 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 45 | 0 | 0.0 %

           1                 : // Copyright (c) 2006-2009 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 "base/file_util.h"
           6                 :
           7                 : #if defined(OS_WIN)
           8                 : #include <io.h>
           9                 : #endif
          10                 : #include <stdio.h>
          11                 : #if defined(ANDROID) || defined(OS_POSIX)
          12                 : #include <unistd.h>
          13                 : #endif
          14                 :
          15                 : #include <fstream>
          16                 :
          17                 : #include "base/file_path.h"
          18                 : #include "base/logging.h"
          19                 : #include "base/string_util.h"
          20                 :
          21                 : #include "base/string_piece.h"
          22                 : #include "base/sys_string_conversions.h"
          23                 :
          24                 : namespace {
          25                 :
          26                 : const FilePath::CharType kExtensionSeparator = FILE_PATH_LITERAL('.');
          27                 :
          28                 : }  // namespace
          29                 :
          30                 : namespace file_util {
          31                 :
          32               0 : void PathComponents(const FilePath& path,
          33                 :                     std::vector<FilePath::StringType>* components) {
          34               0 :   DCHECK(components);
          35               0 :   if (!components)
          36               0 :     return;
          37                 :
          38               0 :   FilePath::StringType path_str = path.value();
          39               0 :   FilePath::StringType::size_type start = 0;
          40                 :   FilePath::StringType::size_type end =
          41               0 :       path_str.find_first_of(FilePath::kSeparators);
          42                 :
          43                 :   // If the path starts with a separator, add it to components.
          44               0 :   if (end == start) {
          45               0 :     components->push_back(FilePath::StringType(path_str, 0, 1));
          46               0 :     start = end + 1;
          47               0 :     end = path_str.find_first_of(FilePath::kSeparators, start);
          48                 :   }
          49               0 :   while (end != FilePath::StringType::npos) {
          50                 :     FilePath::StringType component =
          51               0 :         FilePath::StringType(path_str, start, end - start);
          52               0 :     components->push_back(component);
          53               0 :     start = end + 1;
          54               0 :     end = path_str.find_first_of(FilePath::kSeparators, start);
          55                 :   }
          56                 :
          57               0 :   components->push_back(FilePath::StringType(path_str, start));
          58                 : }
          59                 :
          60               0 : bool EndsWithSeparator(const FilePath& path) {
          61               0 :   FilePath::StringType value = path.value();
          62               0 :   if (value.empty())
          63               0 :     return false;
          64                 :
          65               0 :   return FilePath::IsSeparator(value[value.size() - 1]);
          66                 : }
          67                 :
          68               0 : bool EnsureEndsWithSeparator(FilePath* path) {
          69               0 :   if (!DirectoryExists(*path))
          70               0 :     return false;
          71                 :
          72               0 :   if (EndsWithSeparator(*path))
          73               0 :     return true;
          74                 :
          75                 :   FilePath::StringType& path_str =
          76               0 :       const_cast<FilePath::StringType&>(path->value());
          77               0 :   path_str.append(&FilePath::kSeparators[0], 1);
          78                 :
          79               0 :   return true;
          80                 : }
          81                 :
          82               0 : void TrimTrailingSeparator(std::wstring* dir) {
          83               0 :   while (dir->length() > 1 && EndsWithSeparator(dir))
          84               0 :     dir->resize(dir->length() - 1);
          85               0 : }
          86                 :
          87               0 : FilePath::StringType GetFileExtensionFromPath(const FilePath& path) {
          88               0 :   FilePath::StringType file_name = path.BaseName().value();
          89                 :   const FilePath::StringType::size_type last_dot =
          90               0 :       file_name.rfind(kExtensionSeparator);
          91                 :   return FilePath::StringType(last_dot == FilePath::StringType::npos ?
          92                 :                               FILE_PATH_LITERAL("") :
          93               0 :                               file_name, last_dot+1);
          94                 : }
          95                 :
          96               0 : void InsertBeforeExtension(FilePath* path, const FilePath::StringType& suffix) {
          97                 :   FilePath::StringType& value =
          98               0 :       const_cast<FilePath::StringType&>(path->value());
          99                 :
         100                 :   const FilePath::StringType::size_type last_dot =
         101               0 :       value.rfind(kExtensionSeparator);
         102                 :   const FilePath::StringType::size_type last_separator =
         103               0 :       value.find_last_of(FilePath::StringType(FilePath::kSeparators));
         104                 :
         105               0 :   if (last_dot == FilePath::StringType::npos ||
         106                 :       (last_separator != std::wstring::npos && last_dot < last_separator)) {
         107                 :     // The path looks something like "C:\pics.old\jojo" or "C:\pics\jojo".
         108                 :     // We should just append the suffix to the entire path.
         109               0 :     value.append(suffix);
         110               0 :     return;
         111                 :   }
         112                 :
         113               0 :   value.insert(last_dot, suffix);
         114                 : }
         115                 :
         116               0 : void ReplaceExtension(FilePath* path, const FilePath::StringType& extension) {
         117               0 :   FilePath::StringType clean_extension;
         118                 :   // If the new extension is "" or ".", then we will just remove the current
         119                 :   // extension.
         120               0 :   if (!extension.empty() &&
         121               0 :       extension != FilePath::StringType(&kExtensionSeparator, 1)) {
         122               0 :     if (extension[0] != kExtensionSeparator)
         123               0 :       clean_extension.append(&kExtensionSeparator, 1);
         124               0 :     clean_extension.append(extension);
         125                 :   }
         126                 :
         127                 :   FilePath::StringType& value =
         128               0 :       const_cast<FilePath::StringType&>(path->value());
         129                 :   const FilePath::StringType::size_type last_dot =
         130               0 :       value.rfind(kExtensionSeparator);
         131                 :   const FilePath::StringType::size_type last_separator =
         132               0 :       value.find_last_of(FilePath::StringType(FilePath::kSeparators));
         133                 :
         134                 :   // Erase the current extension, if any.
         135               0 :   if ((last_dot > last_separator ||
         136                 :       last_separator == FilePath::StringType::npos) &&
         137                 :       last_dot != FilePath::StringType::npos)
         138               0 :     value.erase(last_dot);
         139                 :
         140               0 :   value.append(clean_extension);
         141               0 : }
         142                 :
         143               0 : bool ContentsEqual(const FilePath& filename1, const FilePath& filename2) {
         144                 :   // We open the file in binary format even if they are text files because
         145                 :   // we are just comparing that bytes are exactly same in both files and not
         146                 :   // doing anything smart with text formatting.
         147               0 :   std::ifstream file1, file2;
         148                 :
         149               0 :   filename1.OpenInputStream(file1);
         150               0 :   filename2.OpenInputStream(file2);
         151                 :
         152                 :   // Even if both files aren't openable (and thus, in some sense, "equal"),
         153                 :   // any unusable file yields a result of "false".
         154               0 :   if (!file1.is_open() || !file2.is_open())
         155               0 :     return false;
         156                 :
         157               0 :   const int BUFFER_SIZE = 2056;
         158                 :   char buffer1[BUFFER_SIZE], buffer2[BUFFER_SIZE];
         159               0 :   do {
         160               0 :     file1.read(buffer1, BUFFER_SIZE);
         161               0 :     file2.read(buffer2, BUFFER_SIZE);
         162                 :
         163               0 :     if ((file1.eof() && !file2.eof()) ||
         164               0 :         (!file1.eof() && file2.eof()) ||
         165               0 :         (file1.gcount() != file2.gcount()) ||
         166               0 :         (memcmp(buffer1, buffer2, file1.gcount()))) {
         167               0 :       file1.close();
         168               0 :       file2.close();
         169               0 :       return false;
         170                 :     }
         171               0 :   } while (!file1.eof() && !file2.eof());
         172                 :
         173               0 :   file1.close();
         174               0 :   file2.close();
         175               0 :   return true;
         176                 : }
         177                 :
         178               0 : bool ReadFileToString(const FilePath& path, std::string* contents) {
         179               0 :   FILE* file = OpenFile(path, "rb");
         180               0 :   if (!file) {
         181               0 :     return false;
         182                 :   }
         183                 :
         184                 :   char buf[1 << 16];
         185                 :   size_t len;
         186               0 :   while ((len = fread(buf, 1, sizeof(buf), file)) > 0) {
         187               0 :     contents->append(buf, len);
         188                 :   }
         189               0 :   CloseFile(file);
         190                 :
         191               0 :   return true;
         192                 : }
         193                 :
         194               0 : FILE* CreateAndOpenTemporaryFile(FilePath* path) {
         195               0 :   FilePath directory;
         196               0 :   if (!GetTempDir(&directory))
         197               0 :     return false;
         198                 :
         199               0 :   return CreateAndOpenTemporaryFileInDir(directory, path);
         200                 : }
         201                 :
         202               0 : bool GetFileSize(const FilePath& file_path, int64* file_size) {
         203                 :   FileInfo info;
         204               0 :   if (!GetFileInfo(file_path, &info))
         205               0 :     return false;
         206               0 :   *file_size = info.size;
         207               0 :   return true;
         208                 : }
         209                 :
         210               0 : bool CloseFile(FILE* file) {
         211               0 :   if (file == NULL)
         212               0 :     return true;
         213               0 :   return fclose(file) == 0;
         214                 : }
         215                 :
         216               0 : bool TruncateFile(FILE* file) {
         217               0 :   if (file == NULL)
         218               0 :     return false;
         219               0 :   long current_offset = ftell(file);
         220               0 :   if (current_offset == -1)
         221               0 :     return false;
         222                 : #if defined(OS_WIN)
         223                 :   int fd = _fileno(file);
         224                 :   if (_chsize(fd, current_offset) != 0)
         225                 :     return false;
         226                 : #else
         227               0 :   int fd = fileno(file);
         228               0 :   if (ftruncate(fd, current_offset) != 0)
         229               0 :     return false;
         230                 : #endif
         231               0 :   return true;
         232                 : }
         233                 :
         234               0 : bool ContainsPath(const FilePath &parent, const FilePath& child) {
         235               0 :   FilePath abs_parent = FilePath(parent);
         236               0 :   FilePath abs_child = FilePath(child);
         237                 :
         238               0 :   if (!file_util::AbsolutePath(&abs_parent) ||
         239               0 :       !file_util::AbsolutePath(&abs_child))
         240               0 :     return false;
         241                 :
         242                 : #if defined(OS_WIN)
         243                 :   // file_util::AbsolutePath() does not flatten case on Windows, so we must do
         244                 :   // a case-insensitive compare.
         245                 :   if (!StartsWith(abs_child.value(), abs_parent.value(), false))
         246                 : #else
         247               0 :   if (!StartsWithASCII(abs_child.value(), abs_parent.value(), true))
         248                 : #endif
         249               0 :     return false;
         250                 :
         251                 :   // file_util::AbsolutePath() normalizes '/' to '\' on Windows, so we only need
         252                 :   // to check kSeparators[0].
         253               0 :   if (abs_child.value().length() <= abs_parent.value().length() ||
         254               0 :       abs_child.value()[abs_parent.value().length()] !=
         255               0 :           FilePath::kSeparators[0])
         256               0 :     return false;
         257                 :
         258               0 :   return true;
         259                 : }
         260                 :
         261                 : ///////////////////////////////////////////////
         262                 : // MemoryMappedFile
         263                 :
         264               0 : MemoryMappedFile::~MemoryMappedFile() {
         265               0 :   CloseHandles();
         266               0 : }
         267                 :
         268               0 : bool MemoryMappedFile::Initialize(const FilePath& file_name) {
         269               0 :   if (IsValid())
         270               0 :     return false;
         271                 :
         272               0 :   if (!MapFileToMemory(file_name)) {
         273               0 :     CloseHandles();
         274               0 :     return false;
         275                 :   }
         276                 :
         277               0 :   return true;
         278                 : }
         279                 :
         280               0 : bool MemoryMappedFile::IsValid() {
         281               0 :   return data_ != NULL;
         282                 : }
         283                 :
         284                 : // Deprecated functions ----------------------------------------------------
         285                 :
         286               0 : bool ReadFileToString(const std::wstring& path, std::string* contents) {
         287               0 :   return ReadFileToString(FilePath::FromWStringHack(path), contents);
         288                 : }
         289                 :
         290               0 : bool AbsolutePath(std::wstring* path_str) {
         291               0 :   FilePath path(FilePath::FromWStringHack(*path_str));
         292               0 :   if (!AbsolutePath(&path))
         293               0 :     return false;
         294               0 :   *path_str = path.ToWStringHack();
         295               0 :   return true;
         296                 : }
         297               0 : void AppendToPath(std::wstring* path, const std::wstring& new_ending) {
         298               0 :   if (!path) {
         299               0 :     NOTREACHED();
         300               0 :     return;  // Don't crash in this function in release builds.
         301                 :   }
         302                 :
         303               0 :   if (!EndsWithSeparator(path))
         304               0 :     path->push_back(FilePath::kSeparators[0]);
         305               0 :   path->append(new_ending);
         306                 : }
         307               0 : bool CopyDirectory(const std::wstring& from_path, const std::wstring& to_path,
         308                 :                    bool recursive) {
         309               0 :   return CopyDirectory(FilePath::FromWStringHack(from_path),
         310               0 :                        FilePath::FromWStringHack(to_path),
         311               0 :                        recursive);
         312                 : }
         313               0 : bool ContentsEqual(const std::wstring& filename1,
         314                 :                    const std::wstring& filename2) {
         315               0 :   return ContentsEqual(FilePath::FromWStringHack(filename1),
         316               0 :                        FilePath::FromWStringHack(filename2));
         317                 : }
         318               0 : bool CopyFile(const std::wstring& from_path, const std::wstring& to_path) {
         319               0 :   return CopyFile(FilePath::FromWStringHack(from_path),
         320               0 :                   FilePath::FromWStringHack(to_path));
         321                 : }
         322               0 : bool CreateDirectory(const std::wstring& full_path) {
         323               0 :   return CreateDirectory(FilePath::FromWStringHack(full_path));
         324                 : }
         325               0 : bool CreateNewTempDirectory(const std::wstring& prefix,
         326                 :                             std::wstring* new_temp_path) {
         327                 : #if defined(OS_WIN)
         328                 :   FilePath::StringType dir_prefix(prefix);
         329                 : #elif defined(OS_POSIX)
         330               0 :   FilePath::StringType dir_prefix = WideToUTF8(prefix);
         331                 : #endif
         332               0 :   FilePath temp_path;
         333               0 :   if (!CreateNewTempDirectory(dir_prefix, &temp_path))
         334               0 :     return false;
         335               0 :   *new_temp_path = temp_path.ToWStringHack();
         336               0 :   return true;
         337                 : }
         338               0 : bool CreateTemporaryFileName(std::wstring* temp_file) {
         339               0 :   FilePath temp_file_path;
         340               0 :   if (!CreateTemporaryFileName(&temp_file_path))
         341               0 :     return false;
         342               0 :   *temp_file = temp_file_path.ToWStringHack();
         343               0 :   return true;
         344                 : }
         345               0 : bool Delete(const std::wstring& path, bool recursive) {
         346               0 :   return Delete(FilePath::FromWStringHack(path), recursive);
         347                 : }
         348               0 : bool DirectoryExists(const std::wstring& path) {
         349               0 :   return DirectoryExists(FilePath::FromWStringHack(path));
         350                 : }
         351               0 : bool EndsWithSeparator(std::wstring* path) {
         352               0 :   return EndsWithSeparator(FilePath::FromWStringHack(*path));
         353                 : }
         354               0 : bool EndsWithSeparator(const std::wstring& path) {
         355               0 :   return EndsWithSeparator(FilePath::FromWStringHack(path));
         356                 : }
         357               0 : bool GetCurrentDirectory(std::wstring* path_str) {
         358               0 :   FilePath path;
         359               0 :   if (!GetCurrentDirectory(&path))
         360               0 :     return false;
         361               0 :   *path_str = path.ToWStringHack();
         362               0 :   return true;
         363                 : }
         364               0 : std::wstring GetFileExtensionFromPath(const std::wstring& path) {
         365                 :   FilePath::StringType extension =
         366               0 :       GetFileExtensionFromPath(FilePath::FromWStringHack(path));
         367                 : #if defined(OS_WIN)
         368                 :   return extension;
         369                 : #elif defined(OS_POSIX)
         370               0 :   return UTF8ToWide(extension);
         371                 : #endif
         372                 : }
         373               0 : bool GetFileInfo(const std::wstring& file_path, FileInfo* results) {
         374               0 :   return GetFileInfo(FilePath::FromWStringHack(file_path), results);
         375                 : }
         376               0 : std::wstring GetFilenameFromPath(const std::wstring& path) {
         377               0 :   if (path.empty() || EndsWithSeparator(path))
         378               0 :     return std::wstring();
         379                 :
         380               0 :   return FilePath::FromWStringHack(path).BaseName().ToWStringHack();
         381                 : }
         382               0 : bool GetFileSize(const std::wstring& file_path, int64* file_size) {
         383               0 :   return GetFileSize(FilePath::FromWStringHack(file_path), file_size);
         384                 : }
         385               0 : bool GetTempDir(std::wstring* path_str) {
         386               0 :   FilePath path;
         387               0 :   if (!GetTempDir(&path))
         388               0 :     return false;
         389               0 :   *path_str = path.ToWStringHack();
         390               0 :   return true;
         391                 : }
         392               0 : bool Move(const std::wstring& from_path, const std::wstring& to_path) {
         393               0 :   return Move(FilePath::FromWStringHack(from_path),
         394               0 :               FilePath::FromWStringHack(to_path));
         395                 : }
         396               0 : FILE* OpenFile(const std::wstring& filename, const char* mode) {
         397               0 :   return OpenFile(FilePath::FromWStringHack(filename), mode);
         398                 : }
         399               0 : bool PathExists(const std::wstring& path) {
         400               0 :   return PathExists(FilePath::FromWStringHack(path));
         401                 : }
         402               0 : bool PathIsWritable(const std::wstring& path) {
         403               0 :   return PathIsWritable(FilePath::FromWStringHack(path));
         404                 : }
         405               0 : int ReadFile(const std::wstring& filename, char* data, int size) {
         406               0 :   return ReadFile(FilePath::FromWStringHack(filename), data, size);
         407                 : }
         408               0 : bool SetCurrentDirectory(const std::wstring& directory) {
         409               0 :   return SetCurrentDirectory(FilePath::FromWStringHack(directory));
         410                 : }
         411               0 : void UpOneDirectory(std::wstring* dir) {
         412               0 :   FilePath path = FilePath::FromWStringHack(*dir);
         413               0 :   FilePath directory = path.DirName();
         414                 :   // If there is no separator, we will get back kCurrentDirectory.
         415                 :   // In this case don't change |dir|.
         416               0 :   if (directory.value() != FilePath::kCurrentDirectory)
         417               0 :     *dir = directory.ToWStringHack();
         418               0 : }
         419               0 : void UpOneDirectoryOrEmpty(std::wstring* dir) {
         420               0 :   FilePath path = FilePath::FromWStringHack(*dir);
         421               0 :   FilePath directory = path.DirName();
         422                 :   // If there is no separator, we will get back kCurrentDirectory.
         423                 :   // In this case, clear dir.
         424               0 :   if (directory == path || directory.value() == FilePath::kCurrentDirectory)
         425               0 :     dir->clear();
         426                 :   else
         427               0 :     *dir = directory.ToWStringHack();
         428               0 : }
         429               0 : int WriteFile(const std::wstring& filename, const char* data, int size) {
         430               0 :   return WriteFile(FilePath::FromWStringHack(filename), data, size);
         431                 : }
         432                 : }  // namespace

Generated by: LCOV version 1.7