Revert 30149 - The existing file_util::AbsolutePath() function was already do...

base/file_path.cc

 // Copyright (c) 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_path.h"
 #include "base/logging.h"
 
 // These includes are just for the *Hack functions, and should be removed
 // when those functions are removed.
 #include "base/string_piece.h"
@@ skipping 140 matching lines @@
 }
 
 bool FilePath::operator!=(const FilePath& that) const {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   return !EqualDriveLetterCaseInsensitive(this->path_, that.path_);
 #else  // defined(FILE_PATH_USES_DRIVE_LETTERS)
   return path_ != that.path_;
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 }
 
+bool FilePath::AppendAndResolveRelative(const FilePath& relative_path,
+                                        FilePath* path) const {
+  DCHECK(path);
+  if (!path || relative_path.IsAbsolute())
+    return false;
+
+  FilePath full_path = Append(relative_path);
+  // Is it worth looking for parent references?
+  if (!full_path.ReferencesParent()) {
+    *path = full_path;
+    return true;
+  }
+
+  // If the parent has a drive letter, then we must not remove the first
+  // component, which is the drive letter.
+  bool drive_letter = (FindDriveLetter(full_path.path_) !=
+                       FilePath::StringType::npos);
+
+  std::vector<FilePath::StringType> components;
+  full_path.GetComponents(&components);
+  std::vector<FilePath::StringType>::iterator it = components.begin();
+  // Start by removing any kCurrentDirectory component, since they may
+  // fool us into not going back to the appropriate parent level.
+  for (; it != components.end(); ++it) {
+    if (*it == kCurrentDirectory) {
+      // erase returns an iterator to the next component.
+      it = components.erase(it);
+      // So now, go back to previous iterator,
+      // so that we can appropriately process the next one as we loop.
+      --it;
+    }
+  }
+
+  // Now parse the component looking for kParentDirectory and remove them as
+  // well as the previous component.
+  it = components.begin();
+  for (; it != components.end(); ++it) {
+    if (*it == kParentDirectory) {
+      // Did we reach the beginning?
+      if (it == components.begin() ||
+          (drive_letter && (it - 1) == components.begin())) {
+        return false;
+      }
+      // Remove the previous component, as well as the current one.
+      std::vector<FilePath::StringType>::iterator previous = it - 1;
+      // Unless the previous is at the beginning.
+      if (previous == components.begin() ||
+          (drive_letter && (previous - 1) == components.begin())) {
+        return false;
+      }
+      // vector::erase doesn't erase _Last, it erases [_First, _Last[,
+      // so we must increment current which we want erased.
+      it = components.erase(previous, it + 1);
+      // And go back to previous so that we can process the next one as we loop.
+      --it;
+    }
+  }
+
+  // Now reconstruct the path with the components that were left in.
+  it = components.begin();
+  // We start with the first component, in case it is absolute
+  // and absolute paths can't be appended.
+  *path = FilePath(*it);
+  for (++it; it != components.end(); ++it)
+    *path = path->Append(*it);
+
+  return true;
+}
+
 bool FilePath::IsParent(const FilePath& child) const {
   return AppendRelativePath(child, NULL);
 }
 
 bool FilePath::AppendRelativePath(const FilePath& child,
                                   FilePath* path) const {
   std::vector<FilePath::StringType> parent_components;
   std::vector<FilePath::StringType> child_components;
   GetComponents(&parent_components);
   child.GetComponents(&child_components);
@@ skipping 306 matching lines @@
 
   std::vector<FilePath::StringType>::const_iterator it = components.begin();
   for (; it != components.end(); ++it) {
     const FilePath::StringType& component = *it;
     if (component == kParentDirectory)
       return true;
   }
   return false;
 }