Get rid of kPathSeparator on windows.

base/file_util.cc

 // Copyright (c) 2006-2008 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"
 
 #include <stdio.h>
 
 #include <fstream>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "unicode/uniset.h"
 
 #include "base/string_piece.h"
 #include "base/sys_string_conversions.h"
 
+namespace {
+
+const FilePath::CharType kExtensionSeparator = FILE_PATH_LITERAL('.');
+
+}
+
 namespace file_util {
 
 void PathComponents(const FilePath& path,
                     std::vector<FilePath::StringType>* components) {
   DCHECK(components);
   if (!components)
     return;
 
   FilePath::StringType path_str = path.value();
   FilePath::StringType::size_type start = 0;
@@ skipping 37 matching lines @@
   path_str.append(&FilePath::kSeparators[0], 1);
 
   return true;
 }
 
 void TrimTrailingSeparator(std::wstring* dir) {
   while (dir->length() > 1 && EndsWithSeparator(dir))
     dir->resize(dir->length() - 1);
 }
 
-std::wstring GetFilenameFromPath(const std::wstring& path) {
-  // TODO(erikkay): fix this - it's not using kPathSeparator, but win unit test
-  // are exercising '/' as a path separator as well.
-  std::wstring::size_type pos = path.find_last_of(L"\\/");
-  return std::wstring(path, pos == std::wstring::npos ? 0 : pos + 1);
-}
-
 std::wstring GetFileExtensionFromPath(const std::wstring& path) {
   std::wstring file_name = GetFilenameFromPath(path);
   std::wstring::size_type last_dot = file_name.rfind(L'.');
   return std::wstring(last_dot == std::wstring::npos ? 
       L"" : 
       file_name, last_dot+1);
 }
 
 std::wstring GetFilenameWithoutExtensionFromPath(const std::wstring& path) {
   std::wstring file_name = GetFilenameFromPath(path);
   std::wstring::size_type last_dot = file_name.rfind(L'.');
   return file_name.substr(0, last_dot);
 }
 
+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);
+}
+
 void ReplaceIllegalCharacters(std::wstring* file_name, int replace_char) {
   DCHECK(file_name);
 
   // Control characters, formatting characters, non-characters, and
   // some printable ASCII characters regarded as dangerous ('"*/:<>?\\').
   // See  http://blogs.msdn.com/michkap/archive/2006/11/03/941420.aspx
   // and http://msdn2.microsoft.com/en-us/library/Aa365247.aspx
   // TODO(jungshik): Revisit the set. ZWJ and ZWNJ are excluded because they
   // are legitimate in Arabic and some S/SE Asian scripts. However, when used
   // elsewhere, they can be confusing/problematic.
@@ skipping 181 matching lines @@
 bool GetCurrentDirectory(std::wstring* path_str) {
   FilePath path;
   if (!GetCurrentDirectory(&path))
     return false;
   *path_str = path.ToWStringHack();
   return true;
 }
 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* 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;
 }
@@ skipping 30 matching lines @@
   FilePath directory = path.DirName();
   // If there is no separator, we will get back kCurrentDirectory.
   // In this case, clear dir.
   if (directory == path || directory.value() == FilePath::kCurrentDirectory)
     dir->clear();
   else
     *dir = directory.ToWStringHack();
 }
 }  // namespace