Move path functions from file_util to FilePath object.

base/files/file_path.cc

 // Copyright (c) 2012 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/files/file_path.h"
 
 #include <string.h>
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 
 // These includes are just for the *Hack functions, and should be removed
 // when those functions are removed.
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/strings/sys_string_conversions.h"
+#include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
 #include "base/third_party/icu/icu_utf.h"
 #endif
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_MACOSX)
@@ skipping 485 matching lines @@
   return Append(ASCIIToUTF16(component.as_string()));
 #elif defined(OS_POSIX)
   return Append(component.as_string());
 #endif
 }
 
 bool FilePath::IsAbsolute() const {
   return IsPathAbsolute(path_);
 }
 
+FilePath FilePath::AsAbsolute() const {

[rvargas (doing something else), 2013/04/01 19:50:31]

I'm not sure moving this code here is a good idea. An explicit design parameter
of FilePath is that it doesn't ever touch the actual file system, relying
instead on pure inspection of what paths look like.

Operations that cannot be implemented without looking at disk were part of
file_util for that reason.

The other changes seem fine.

[brettw, 2013/04/01 22:42:24]

I thought that was the case but it didn't seem like anybody was following that
rule. and was just using AsAbsolute all over the place. But looking closer it
looks like that's only in the tests and we actually do a pretty good job of
keeping IsAbsolute calls off the UI thread.

I'll keep AsAbsolute there although I think I'll change it to return a copy
rather than modify the param in-place; I think that made the code cleaner when I
was doing this patch.

+  base::ThreadRestrictions::AssertIOAllowed();
+
+#if defined(OS_WIN)
+  wchar_t file_path[MAX_PATH];
+  if (!_wfullpath(file_path, path_.c_str(), MAX_PATH))
+    return FilePath();
+  return FilePath(file_path);
+#elif defined(OS_NACL)
+  // Nacl doesn't have realpath and there's not a lot you can do inside the
+  // sandbox with files.
+  // TODO(brettw) implement something more reasonable if we need it.
+  return *this;
+#elif defined(OS_POSIX)
+  char full_path[PATH_MAX];
+  if (realpath(path_.c_str(), full_path) == NULL)
+    return FilePath();
+  return FilePath(full_path);
+#endif
+}
+
+bool FilePath::EndsWithSeparator() const {
+  if (empty())
+    return false;
+  return IsSeparator(path_[path_.size() - 1]);
+}
+
+FilePath FilePath::AsEndingWithSeparator() const {
+  if (EndsWithSeparator())
+    return *this;
+
+  StringType path_str;
+  path_str.reserve(path_.length() + 1);  // Only allocate string once.
+
+  path_str = path_;
+  path_str.append(&kSeparators[0], 1);
+  return FilePath(path_str);
+}
+
 FilePath FilePath::StripTrailingSeparators() const {
   FilePath new_path(path_);
   new_path.StripTrailingSeparatorsInternal();
 
   return new_path;
 }
 
 bool FilePath::ReferencesParent() const {
   std::vector<StringType> components;
   GetComponents(&components);
@@ skipping 717 matching lines @@
 #else
   return *this;
 #endif
 }
 
 }  // namespace base
 
 void PrintTo(const base::FilePath& path, std::ostream* out) {
   *out << path.value();
 }