Append a trailing slash on file directory URLs. Thus a link to /directory wil...

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"
 
 namespace file_util {
 
 const wchar_t kExtensionSeparator = L'.';
 
 void PathComponents(const std::wstring& path,
                     std::vector<std::wstring>* components) {
   DCHECK(components != NULL);
   if (components == NULL)
     return;
   std::wstring::size_type start = 0;
   std::wstring::size_type end = path.find(kPathSeparator, start);
 
   // Special case the "/" or "\" directory.  On Windows with a drive letter,
-  // this code path won't hit, but the right thing should still happen.  
+  // this code path won't hit, but the right thing should still happen.
   // "E:\foo" will turn into "E:","foo".
   if (end == start) {
     components->push_back(std::wstring(path, 0, 1));
     start = end + 1;
     end = path.find(kPathSeparator, start);
   }
   while (end != std::wstring::npos) {
     std::wstring component = std::wstring(path, start, end - start);
     components->push_back(component);
     start = end + 1;
     end = path.find(kPathSeparator, start);
   }
   std::wstring component = std::wstring(path, start);
   components->push_back(component);
 }
-  
-bool EndsWithSeparator(std::wstring* path) {
-  return EndsWithSeparator(*path);
+
+bool EndsWithSeparator(const FilePath& file_path) {
+  std::wstring path = file_path.ToWStringHack();
+  bool is_sep = (path.length() > 0 &&
+      path[path.length() - 1] == kPathSeparator);
+  return is_sep;
 }
-  
-bool EndsWithSeparator(const std::wstring& path) {
-  bool is_sep = (path.length() > 0 && 
-      (path)[path.length() - 1] == kPathSeparator);
-  return is_sep;
+
+bool EnsureEndsWithSeparator(FilePath* path) {
+  if (!DirectoryExists(*path))
+    return false;
+
+  if (EndsWithSeparator(*path))
+    return true;
+
+  FilePath::StringType& path_str =
+      const_cast<FilePath::StringType&>(path->value());
+  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);
 }
 
 void UpOneDirectory(std::wstring* dir) {
   TrimTrailingSeparator(dir);
 
@@ skipping 244 matching lines @@
 bool AbsolutePath(std::wstring* path_str) {
   FilePath path(FilePath::FromWStringHack(*path_str));
   if (!AbsolutePath(&path))
     return false;
   *path_str = path.ToWStringHack();
   return true;
 }
 bool Delete(const std::wstring& path, bool recursive) {
   return Delete(FilePath::FromWStringHack(path), recursive);
 }
+bool EndsWithSeparator(std::wstring* path) {
+  return EndsWithSeparator(FilePath::FromWStringHack(*path));
+}
+bool EndsWithSeparator(const std::wstring& path) {
+  return EndsWithSeparator(FilePath::FromWStringHack(path));
+}
 bool Move(const std::wstring& from_path, const std::wstring& to_path) {
   return Move(FilePath::FromWStringHack(from_path),
               FilePath::FromWStringHack(to_path));
 }
 bool CopyFile(const std::wstring& from_path, const std::wstring& to_path) {
   return CopyFile(FilePath::FromWStringHack(from_path),
                   FilePath::FromWStringHack(to_path));
 }
 bool CopyDirectory(const std::wstring& from_path, const std::wstring& to_path,
                    bool recursive) {
@@ skipping 44 matching lines @@
 }
 FILE* OpenFile(const std::wstring& filename, const char* mode) {
   return OpenFile(FilePath::FromWStringHack(filename), mode);
 }
 bool SetCurrentDirectory(const std::wstring& directory) {
   return SetCurrentDirectory(FilePath::FromWStringHack(directory));
 }
 
 }  // namespace