Move functions for controlling Caps Lock to CapsLockDelegate from SystemTrayDelegate.
[chromium-blink-merge.git] / base / file_util.cc
blobabc755785d591cd816562aaac5901ecae1c4b9af
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.
5 #include "base/file_util.h"
7 #if defined(OS_WIN)
8 #include <io.h>
9 #endif
10 #include <stdio.h>
12 #include <fstream>
14 #include "base/file_path.h"
15 #include "base/logging.h"
16 #include "base/stringprintf.h"
17 #include "base/string_piece.h"
18 #include "base/string_util.h"
19 #include "base/utf_string_conversions.h"
21 namespace {
23 const FilePath::CharType kExtensionSeparator = FILE_PATH_LITERAL('.');
25 // The maximum number of 'uniquified' files we will try to create.
26 // This is used when the filename we're trying to download is already in use,
27 // so we create a new unique filename by appending " (nnn)" before the
28 // extension, where 1 <= nnn <= kMaxUniqueFiles.
29 // Also used by code that cleans up said files.
30 static const int kMaxUniqueFiles = 100;
32 } // namespace
34 namespace file_util {
36 bool g_bug108724_debug = false;
38 bool EndsWithSeparator(const FilePath& path) {
39 FilePath::StringType value = path.value();
40 if (value.empty())
41 return false;
43 return FilePath::IsSeparator(value[value.size() - 1]);
46 bool EnsureEndsWithSeparator(FilePath* path) {
47 if (!DirectoryExists(*path))
48 return false;
50 if (EndsWithSeparator(*path))
51 return true;
53 FilePath::StringType& path_str =
54 const_cast<FilePath::StringType&>(path->value());
55 path_str.append(&FilePath::kSeparators[0], 1);
57 return true;
60 void InsertBeforeExtension(FilePath* path, const FilePath::StringType& suffix) {
61 FilePath::StringType& value =
62 const_cast<FilePath::StringType&>(path->value());
64 const FilePath::StringType::size_type last_dot =
65 value.rfind(kExtensionSeparator);
66 const FilePath::StringType::size_type last_separator =
67 value.find_last_of(FilePath::StringType(FilePath::kSeparators));
69 if (last_dot == FilePath::StringType::npos ||
70 (last_separator != std::wstring::npos && last_dot < last_separator)) {
71 // The path looks something like "C:\pics.old\jojo" or "C:\pics\jojo".
72 // We should just append the suffix to the entire path.
73 value.append(suffix);
74 return;
77 value.insert(last_dot, suffix);
80 bool ContentsEqual(const FilePath& filename1, const FilePath& filename2) {
81 // We open the file in binary format even if they are text files because
82 // we are just comparing that bytes are exactly same in both files and not
83 // doing anything smart with text formatting.
84 std::ifstream file1(filename1.value().c_str(),
85 std::ios::in | std::ios::binary);
86 std::ifstream file2(filename2.value().c_str(),
87 std::ios::in | std::ios::binary);
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;
94 const int BUFFER_SIZE = 2056;
95 char buffer1[BUFFER_SIZE], buffer2[BUFFER_SIZE];
96 do {
97 file1.read(buffer1, BUFFER_SIZE);
98 file2.read(buffer2, BUFFER_SIZE);
100 if ((file1.eof() != file2.eof()) ||
101 (file1.gcount() != file2.gcount()) ||
102 (memcmp(buffer1, buffer2, file1.gcount()))) {
103 file1.close();
104 file2.close();
105 return false;
107 } while (!file1.eof() || !file2.eof());
109 file1.close();
110 file2.close();
111 return true;
114 bool TextContentsEqual(const FilePath& filename1, const FilePath& filename2) {
115 std::ifstream file1(filename1.value().c_str(), std::ios::in);
116 std::ifstream file2(filename2.value().c_str(), std::ios::in);
118 // Even if both files aren't openable (and thus, in some sense, "equal"),
119 // any unusable file yields a result of "false".
120 if (!file1.is_open() || !file2.is_open())
121 return false;
123 do {
124 std::string line1, line2;
125 getline(file1, line1);
126 getline(file2, line2);
128 // Check for mismatched EOF states, or any error state.
129 if ((file1.eof() != file2.eof()) ||
130 file1.bad() || file2.bad()) {
131 return false;
134 // Trim all '\r' and '\n' characters from the end of the line.
135 std::string::size_type end1 = line1.find_last_not_of("\r\n");
136 if (end1 == std::string::npos)
137 line1.clear();
138 else if (end1 + 1 < line1.length())
139 line1.erase(end1 + 1);
141 std::string::size_type end2 = line2.find_last_not_of("\r\n");
142 if (end2 == std::string::npos)
143 line2.clear();
144 else if (end2 + 1 < line2.length())
145 line2.erase(end2 + 1);
147 if (line1 != line2)
148 return false;
149 } while (!file1.eof() || !file2.eof());
151 return true;
154 bool ReadFileToString(const FilePath& path, std::string* contents) {
155 FILE* file = OpenFile(path, "rb");
156 if (!file) {
157 return false;
160 char buf[1 << 16];
161 size_t len;
162 while ((len = fread(buf, 1, sizeof(buf), file)) > 0) {
163 if (contents)
164 contents->append(buf, len);
166 CloseFile(file);
168 return true;
171 bool IsDirectoryEmpty(const FilePath& dir_path) {
172 FileEnumerator files(dir_path, false,
173 FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
174 if (files.Next().value().empty())
175 return true;
176 return false;
179 FILE* CreateAndOpenTemporaryFile(FilePath* path) {
180 FilePath directory;
181 if (!GetTempDir(&directory))
182 return NULL;
184 return CreateAndOpenTemporaryFileInDir(directory, path);
187 bool GetFileSize(const FilePath& file_path, int64* file_size) {
188 base::PlatformFileInfo info;
189 if (!GetFileInfo(file_path, &info))
190 return false;
191 *file_size = info.size;
192 return true;
195 bool IsDot(const FilePath& path) {
196 return FILE_PATH_LITERAL(".") == path.BaseName().value();
199 bool IsDotDot(const FilePath& path) {
200 return FILE_PATH_LITERAL("..") == path.BaseName().value();
203 bool TouchFile(const FilePath& path,
204 const base::Time& last_accessed,
205 const base::Time& last_modified) {
206 base::PlatformFile file =
207 base::CreatePlatformFile(path,
208 base::PLATFORM_FILE_OPEN |
209 base::PLATFORM_FILE_WRITE_ATTRIBUTES,
210 NULL, NULL);
211 if (file != base::kInvalidPlatformFileValue) {
212 bool result = base::TouchPlatformFile(file, last_accessed, last_modified);
213 base::ClosePlatformFile(file);
214 return result;
217 return false;
220 bool SetLastModifiedTime(const FilePath& path,
221 const base::Time& last_modified) {
222 return TouchFile(path, last_modified, last_modified);
225 bool CloseFile(FILE* file) {
226 if (file == NULL)
227 return true;
228 return fclose(file) == 0;
231 bool TruncateFile(FILE* file) {
232 if (file == NULL)
233 return false;
234 long current_offset = ftell(file);
235 if (current_offset == -1)
236 return false;
237 #if defined(OS_WIN)
238 int fd = _fileno(file);
239 if (_chsize(fd, current_offset) != 0)
240 return false;
241 #else
242 int fd = fileno(file);
243 if (ftruncate(fd, current_offset) != 0)
244 return false;
245 #endif
246 return true;
249 int GetUniquePathNumber(
250 const FilePath& path,
251 const FilePath::StringType& suffix) {
252 bool have_suffix = !suffix.empty();
253 if (!PathExists(path) &&
254 (!have_suffix || !PathExists(FilePath(path.value() + suffix)))) {
255 return 0;
258 FilePath new_path;
259 for (int count = 1; count <= kMaxUniqueFiles; ++count) {
260 new_path = path.InsertBeforeExtensionASCII(StringPrintf(" (%d)", count));
261 if (!PathExists(new_path) &&
262 (!have_suffix || !PathExists(FilePath(new_path.value() + suffix)))) {
263 return count;
267 return -1;
270 bool ContainsPath(const FilePath &parent, const FilePath& child) {
271 FilePath abs_parent = FilePath(parent);
272 FilePath abs_child = FilePath(child);
274 if (!file_util::AbsolutePath(&abs_parent) ||
275 !file_util::AbsolutePath(&abs_child))
276 return false;
278 #if defined(OS_WIN)
279 // file_util::AbsolutePath() does not flatten case on Windows, so we must do
280 // a case-insensitive compare.
281 if (!StartsWith(abs_child.value(), abs_parent.value(), false))
282 #else
283 if (!StartsWithASCII(abs_child.value(), abs_parent.value(), true))
284 #endif
285 return false;
287 // file_util::AbsolutePath() normalizes '/' to '\' on Windows, so we only need
288 // to check kSeparators[0].
289 if (abs_child.value().length() <= abs_parent.value().length() ||
290 abs_child.value()[abs_parent.value().length()] !=
291 FilePath::kSeparators[0])
292 return false;
294 return true;
297 int64 ComputeDirectorySize(const FilePath& root_path) {
298 int64 running_size = 0;
299 FileEnumerator file_iter(root_path, true, FileEnumerator::FILES);
300 for (FilePath current = file_iter.Next(); !current.empty();
301 current = file_iter.Next()) {
302 FileEnumerator::FindInfo info;
303 file_iter.GetFindInfo(&info);
304 #if defined(OS_WIN)
305 LARGE_INTEGER li = { info.nFileSizeLow, info.nFileSizeHigh };
306 running_size += li.QuadPart;
307 #else
308 running_size += info.stat.st_size;
309 #endif
311 return running_size;
314 int64 ComputeFilesSize(const FilePath& directory,
315 const FilePath::StringType& pattern) {
316 int64 running_size = 0;
317 FileEnumerator file_iter(directory, false, FileEnumerator::FILES, pattern);
318 for (FilePath current = file_iter.Next(); !current.empty();
319 current = file_iter.Next()) {
320 FileEnumerator::FindInfo info;
321 file_iter.GetFindInfo(&info);
322 #if defined(OS_WIN)
323 LARGE_INTEGER li = { info.nFileSizeLow, info.nFileSizeHigh };
324 running_size += li.QuadPart;
325 #else
326 running_size += info.stat.st_size;
327 #endif
329 return running_size;
332 ///////////////////////////////////////////////
333 // MemoryMappedFile
335 MemoryMappedFile::~MemoryMappedFile() {
336 CloseHandles();
339 bool MemoryMappedFile::Initialize(const FilePath& file_name) {
340 if (IsValid())
341 return false;
343 if (!MapFileToMemory(file_name)) {
344 CloseHandles();
345 return false;
348 return true;
351 bool MemoryMappedFile::Initialize(base::PlatformFile file) {
352 if (IsValid())
353 return false;
355 file_ = file;
357 if (!MapFileToMemoryInternal()) {
358 CloseHandles();
359 return false;
362 return true;
365 bool MemoryMappedFile::IsValid() const {
366 return data_ != NULL;
369 bool MemoryMappedFile::MapFileToMemory(const FilePath& file_name) {
370 file_ = base::CreatePlatformFile(
371 file_name, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
372 NULL, NULL);
374 if (file_ == base::kInvalidPlatformFileValue) {
375 DLOG(ERROR) << "Couldn't open " << file_name.value();
376 return false;
379 return MapFileToMemoryInternal();
382 ///////////////////////////////////////////////
383 // FileEnumerator
385 // Note: the main logic is in file_util_<platform>.cc
387 bool FileEnumerator::ShouldSkip(const FilePath& path) {
388 FilePath::StringType basename = path.BaseName().value();
389 return IsDot(path) || (IsDotDot(path) && !(INCLUDE_DOT_DOT & file_type_));
392 } // namespace