Add m-esr52 at 52.6.0

1 files changed, 244 insertions, 0 deletions

diff --git a/ipc/chromium/src/base/file_util.cc b/ipc/chromium/src/base/file_util.cc
new file mode 100644
index 0000000000..6f7d92f3ab
--- /dev/null
+++ b/ipc/chromium/src/base/file_util.cc
@@ -0,0 +1,244 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+// 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 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