| OLD | NEW |
|---|
| (Empty) |
| 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 "base/files/file_util.h" | |
| 6 | |
| 7 #if defined(OS_WIN) | |
| 8 #include <io.h> | |
| 9 #endif | |
| 10 #include <stdio.h> | |
| 11 | |
| 12 #include <fstream> | |
| 13 #include <limits> | |
| 14 | |
| 15 #include "base/files/file_enumerator.h" | |
| 16 #include "base/files/file_path.h" | |
| 17 #include "base/logging.h" | |
| 18 #include "base/strings/string_piece.h" | |
| 19 #include "base/strings/string_util.h" | |
| 20 #include "base/strings/stringprintf.h" | |
| 21 #include "base/strings/utf_string_conversions.h" | |
| 22 | |
| 23 namespace base { | |
| 24 | |
| 25 #if !defined(OS_NACL_NONSFI) | |
| 26 namespace { | |
| 27 | |
| 28 // The maximum number of 'uniquified' files we will try to create. | |
| 29 // This is used when the filename we're trying to download is already in use, | |
| 30 // so we create a new unique filename by appending " (nnn)" before the | |
| 31 // extension, where 1 <= nnn <= kMaxUniqueFiles. | |
| 32 // Also used by code that cleans up said files. | |
| 33 static const int kMaxUniqueFiles = 100; | |
| 34 | |
| 35 } // namespace | |
| 36 | |
| 37 int64 ComputeDirectorySize(const FilePath& root_path) { | |
| 38 int64 running_size = 0; | |
| 39 FileEnumerator file_iter(root_path, true, FileEnumerator::FILES); | |
| 40 while (!file_iter.Next().empty()) | |
| 41 running_size += file_iter.GetInfo().GetSize(); | |
| 42 return running_size; | |
| 43 } | |
| 44 | |
| 45 bool Move(const FilePath& from_path, const FilePath& to_path) { | |
| 46 if (from_path.ReferencesParent() || to_path.ReferencesParent()) | |
| 47 return false; | |
| 48 return internal::MoveUnsafe(from_path, to_path); | |
| 49 } | |
| 50 | |
| 51 bool ContentsEqual(const FilePath& filename1, const FilePath& filename2) { | |
| 52 // We open the file in binary format even if they are text files because | |
| 53 // we are just comparing that bytes are exactly same in both files and not | |
| 54 // doing anything smart with text formatting. | |
| 55 std::ifstream file1(filename1.value().c_str(), | |
| 56 std::ios::in | std::ios::binary); | |
| 57 std::ifstream file2(filename2.value().c_str(), | |
| 58 std::ios::in | std::ios::binary); | |
| 59 | |
| 60 // Even if both files aren't openable (and thus, in some sense, "equal"), | |
| 61 // any unusable file yields a result of "false". | |
| 62 if (!file1.is_open() || !file2.is_open()) | |
| 63 return false; | |
| 64 | |
| 65 const int BUFFER_SIZE = 2056; | |
| 66 char buffer1[BUFFER_SIZE], buffer2[BUFFER_SIZE]; | |
| 67 do { | |
| 68 file1.read(buffer1, BUFFER_SIZE); | |
| 69 file2.read(buffer2, BUFFER_SIZE); | |
| 70 | |
| 71 if ((file1.eof() != file2.eof()) || | |
| 72 (file1.gcount() != file2.gcount()) || | |
| 73 (memcmp(buffer1, buffer2, static_cast<size_t>(file1.gcount())))) { | |
| 74 file1.close(); | |
| 75 file2.close(); | |
| 76 return false; | |
| 77 } | |
| 78 } while (!file1.eof() || !file2.eof()); | |
| 79 | |
| 80 file1.close(); | |
| 81 file2.close(); | |
| 82 return true; | |
| 83 } | |
| 84 | |
| 85 bool TextContentsEqual(const FilePath& filename1, const FilePath& filename2) { | |
| 86 std::ifstream file1(filename1.value().c_str(), std::ios::in); | |
| 87 std::ifstream file2(filename2.value().c_str(), std::ios::in); | |
| 88 | |
| 89 // Even if both files aren't openable (and thus, in some sense, "equal"), | |
| 90 // any unusable file yields a result of "false". | |
| 91 if (!file1.is_open() || !file2.is_open()) | |
| 92 return false; | |
| 93 | |
| 94 do { | |
| 95 std::string line1, line2; | |
| 96 getline(file1, line1); | |
| 97 getline(file2, line2); | |
| 98 | |
| 99 // Check for mismatched EOF states, or any error state. | |
| 100 if ((file1.eof() != file2.eof()) || | |
| 101 file1.bad() || file2.bad()) { | |
| 102 return false; | |
| 103 } | |
| 104 | |
| 105 // Trim all '\r' and '\n' characters from the end of the line. | |
| 106 std::string::size_type end1 = line1.find_last_not_of("\r\n"); | |
| 107 if (end1 == std::string::npos) | |
| 108 line1.clear(); | |
| 109 else if (end1 + 1 < line1.length()) | |
| 110 line1.erase(end1 + 1); | |
| 111 | |
| 112 std::string::size_type end2 = line2.find_last_not_of("\r\n"); | |
| 113 if (end2 == std::string::npos) | |
| 114 line2.clear(); | |
| 115 else if (end2 + 1 < line2.length()) | |
| 116 line2.erase(end2 + 1); | |
| 117 | |
| 118 if (line1 != line2) | |
| 119 return false; | |
| 120 } while (!file1.eof() || !file2.eof()); | |
| 121 | |
| 122 return true; | |
| 123 } | |
| 124 #endif // !defined(OS_NACL_NONSFI) | |
| 125 | |
| 126 bool ReadFileToString(const FilePath& path, | |
| 127 std::string* contents, | |
| 128 size_t max_size) { | |
| 129 if (contents) | |
| 130 contents->clear(); | |
| 131 if (path.ReferencesParent()) | |
| 132 return false; | |
| 133 FILE* file = OpenFile(path, "rb"); | |
| 134 if (!file) { | |
| 135 return false; | |
| 136 } | |
| 137 | |
| 138 const size_t kBufferSize = 1 << 16; | |
| 139 scoped_ptr<char[]> buf(new char[kBufferSize]); | |
| 140 size_t len; | |
| 141 size_t size = 0; | |
| 142 bool read_status = true; | |
| 143 | |
| 144 // Many files supplied in |path| have incorrect size (proc files etc). | |
| 145 // Hence, the file is read sequentially as opposed to a one-shot read. | |
| 146 while ((len = fread(buf.get(), 1, kBufferSize, file)) > 0) { | |
| 147 if (contents) | |
| 148 contents->append(buf.get(), std::min(len, max_size - size)); | |
| 149 | |
| 150 if ((max_size - size) < len) { | |
| 151 read_status = false; | |
| 152 break; | |
| 153 } | |
| 154 | |
| 155 size += len; | |
| 156 } | |
| 157 read_status = read_status && !ferror(file); | |
| 158 CloseFile(file); | |
| 159 | |
| 160 return read_status; | |
| 161 } | |
| 162 | |
| 163 bool ReadFileToString(const FilePath& path, std::string* contents) { | |
| 164 return ReadFileToString(path, contents, std::numeric_limits<size_t>::max()); | |
| 165 } | |
| 166 | |
| 167 #if !defined(OS_NACL_NONSFI) | |
| 168 bool IsDirectoryEmpty(const FilePath& dir_path) { | |
| 169 FileEnumerator files(dir_path, false, | |
| 170 FileEnumerator::FILES | FileEnumerator::DIRECTORIES); | |
| 171 if (files.Next().empty()) | |
| 172 return true; | |
| 173 return false; | |
| 174 } | |
| 175 | |
| 176 FILE* CreateAndOpenTemporaryFile(FilePath* path) { | |
| 177 FilePath directory; | |
| 178 if (!GetTempDir(&directory)) | |
| 179 return NULL; | |
| 180 | |
| 181 return CreateAndOpenTemporaryFileInDir(directory, path); | |
| 182 } | |
| 183 | |
| 184 bool CreateDirectory(const FilePath& full_path) { | |
| 185 return CreateDirectoryAndGetError(full_path, NULL); | |
| 186 } | |
| 187 | |
| 188 bool GetFileSize(const FilePath& file_path, int64* file_size) { | |
| 189 File::Info info; | |
| 190 if (!GetFileInfo(file_path, &info)) | |
| 191 return false; | |
| 192 *file_size = info.size; | |
| 193 return true; | |
| 194 } | |
| 195 | |
| 196 bool TouchFile(const FilePath& path, | |
| 197 const Time& last_accessed, | |
| 198 const Time& last_modified) { | |
| 199 int flags = File::FLAG_OPEN | File::FLAG_WRITE_ATTRIBUTES; | |
| 200 | |
| 201 #if defined(OS_WIN) | |
| 202 // On Windows, FILE_FLAG_BACKUP_SEMANTICS is needed to open a directory. | |
| 203 if (DirectoryExists(path)) | |
| 204 flags |= File::FLAG_BACKUP_SEMANTICS; | |
| 205 #endif // OS_WIN | |
| 206 | |
| 207 File file(path, flags); | |
| 208 if (!file.IsValid()) | |
| 209 return false; | |
| 210 | |
| 211 return file.SetTimes(last_accessed, last_modified); | |
| 212 } | |
| 213 #endif // !defined(OS_NACL_NONSFI) | |
| 214 | |
| 215 bool CloseFile(FILE* file) { | |
| 216 if (file == NULL) | |
| 217 return true; | |
| 218 return fclose(file) == 0; | |
| 219 } | |
| 220 | |
| 221 #if !defined(OS_NACL_NONSFI) | |
| 222 bool TruncateFile(FILE* file) { | |
| 223 if (file == NULL) | |
| 224 return false; | |
| 225 long current_offset = ftell(file); | |
| 226 if (current_offset == -1) | |
| 227 return false; | |
| 228 #if defined(OS_WIN) | |
| 229 int fd = _fileno(file); | |
| 230 if (_chsize(fd, current_offset) != 0) | |
| 231 return false; | |
| 232 #else | |
| 233 int fd = fileno(file); | |
| 234 if (ftruncate(fd, current_offset) != 0) | |
| 235 return false; | |
| 236 #endif | |
| 237 return true; | |
| 238 } | |
| 239 | |
| 240 int GetUniquePathNumber(const FilePath& path, | |
| 241 const FilePath::StringType& suffix) { | |
| 242 bool have_suffix = !suffix.empty(); | |
| 243 if (!PathExists(path) && | |
| 244 (!have_suffix || !PathExists(FilePath(path.value() + suffix)))) { | |
| 245 return 0; | |
| 246 } | |
| 247 | |
| 248 FilePath new_path; | |
| 249 for (int count = 1; count <= kMaxUniqueFiles; ++count) { | |
| 250 new_path = path.InsertBeforeExtensionASCII(StringPrintf(" (%d)", count)); | |
| 251 if (!PathExists(new_path) && | |
| 252 (!have_suffix || !PathExists(FilePath(new_path.value() + suffix)))) { | |
| 253 return count; | |
| 254 } | |
| 255 } | |
| 256 | |
| 257 return -1; | |
| 258 } | |
| 259 #endif // !defined(OS_NACL_NONSFI) | |
| 260 | |
| 261 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
