Write new Starts/EndsWith and convert FilePath functions to StringPiece.

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"
@@ skipping 13 matching lines @@
 #endif
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
 namespace base {
 
-typedef FilePath::StringType StringType;
+using StringType = FilePath::StringType;
+using StringPieceType = FilePath::StringPieceType;
 
 namespace {
 
 const char* const kCommonDoubleExtensionSuffixes[] = { "gz", "z", "bz2", "bz" };
 const char* const kCommonDoubleExtensions[] = { "user.js" };
 
 const FilePath::CharType kStringTerminator = FILE_PATH_LITERAL('\0');
 
 // If this FilePath contains a drive letter specification, returns the
 // position of the last character of the drive letter specification,
 // otherwise returns npos.  This can only be true on Windows, when a pathname
 // begins with a letter followed by a colon.  On other platforms, this always
 // returns npos.
-StringType::size_type FindDriveLetter(const StringType& path) {
+StringPieceType::size_type FindDriveLetter(StringPieceType path) {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   // This is dependent on an ASCII-based character set, but that's a
   // reasonable assumption.  iswalpha can be too inclusive here.
   if (path.length() >= 2 && path[1] == L':' &&
       ((path[0] >= L'A' && path[0] <= L'Z') ||
        (path[0] >= L'a' && path[0] <= L'z'))) {
     return 1;
   }
 #endif  // FILE_PATH_USES_DRIVE_LETTERS
   return StringType::npos;
 }
 
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
-bool EqualDriveLetterCaseInsensitive(const StringType& a,
-                                     const StringType& b) {
+bool EqualDriveLetterCaseInsensitive(StringPieceType a, StringPieceType b) {
   size_t a_letter_pos = FindDriveLetter(a);
   size_t b_letter_pos = FindDriveLetter(b);
 
   if (a_letter_pos == StringType::npos || b_letter_pos == StringType::npos)
     return a == b;
 
-  StringType a_letter(a.substr(0, a_letter_pos + 1));
-  StringType b_letter(b.substr(0, b_letter_pos + 1));
-  if (!StartsWith(a_letter, b_letter, false))
+  StringPieceType a_letter(a.substr(0, a_letter_pos + 1));
+  StringPieceType b_letter(b.substr(0, b_letter_pos + 1));
+  if (!StartsWith(a_letter, b_letter, CompareCase::INSENSITIVE_ASCII))
     return false;
 
-  StringType a_rest(a.substr(a_letter_pos + 1));
-  StringType b_rest(b.substr(b_letter_pos + 1));
+  StringPieceType a_rest(a.substr(a_letter_pos + 1));
+  StringPieceType b_rest(b.substr(b_letter_pos + 1));
   return a_rest == b_rest;
 }
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 
-bool IsPathAbsolute(const StringType& path) {
+bool IsPathAbsolute(StringPieceType path) {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   StringType::size_type letter = FindDriveLetter(path);
   if (letter != StringType::npos) {
     // Look for a separator right after the drive specification.
     return path.length() > letter + 1 &&
         FilePath::IsSeparator(path[letter + 1]);
   }
   // Look for a pair of leading separators.
   return path.length() > 1 &&
       FilePath::IsSeparator(path[0]) && FilePath::IsSeparator(path[1]);
@@ skipping 78 matching lines @@
 }
 
 }  // namespace
 
 FilePath::FilePath() {
 }
 
 FilePath::FilePath(const FilePath& that) : path_(that.path_) {
 }
 
-FilePath::FilePath(const StringType& path) : path_(path) {
+FilePath::FilePath(StringPieceType path) {
+  path.CopyToString(&path_);
   StringType::size_type nul_pos = path_.find(kStringTerminator);
   if (nul_pos != StringType::npos)
     path_.erase(nul_pos, StringType::npos);
 }
 
 FilePath::~FilePath() {
 }
 
 FilePath& FilePath::operator=(const FilePath& that) {
   path_ = that.path_;
@@ skipping 81 matching lines @@
       parent_components.begin();
   std::vector<StringType>::const_iterator child_comp =
       child_components.begin();
 
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   // Windows can access case sensitive filesystems, so component
   // comparisions must be case sensitive, but drive letters are
   // never case sensitive.
   if ((FindDriveLetter(*parent_comp) != StringType::npos) &&
       (FindDriveLetter(*child_comp) != StringType::npos)) {
-    if (!StartsWith(*parent_comp, *child_comp, false))
+    if (!StartsWith(*parent_comp, *child_comp, CompareCase::INSENSITIVE_ASCII))
       return false;
     ++parent_comp;
     ++child_comp;
   }
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 
   while (parent_comp != parent_components.end()) {
     if (*parent_comp != *child_comp)
       return false;
     ++parent_comp;
@@ skipping 104 matching lines @@
   if (FinalExtension().empty())
     return *this;
 
   const StringType::size_type dot = FinalExtensionSeparatorPosition(path_);
   if (dot == StringType::npos)
     return *this;
 
   return FilePath(path_.substr(0, dot));
 }
 
-FilePath FilePath::InsertBeforeExtension(const StringType& suffix) const {
+FilePath FilePath::InsertBeforeExtension(StringPieceType suffix) const {
   if (suffix.empty())
     return FilePath(path_);
 
   if (IsEmptyOrSpecialCase(BaseName().value()))
     return FilePath();
 
   StringType ext = Extension();
   StringType ret = RemoveExtension().value();
-  ret.append(suffix);
+  suffix.AppendToString(&ret);
   ret.append(ext);
   return FilePath(ret);
 }
 
-FilePath FilePath::InsertBeforeExtensionASCII(const StringPiece& suffix)
+FilePath FilePath::InsertBeforeExtensionASCII(StringPiece suffix)
     const {
   DCHECK(IsStringASCII(suffix));
 #if defined(OS_WIN)
-  return InsertBeforeExtension(ASCIIToUTF16(suffix.as_string()));
+  return InsertBeforeExtension(ASCIIToUTF16(suffix));
 #elif defined(OS_POSIX)
-  return InsertBeforeExtension(suffix.as_string());
+  return InsertBeforeExtension(suffix);
 #endif
 }
 
-FilePath FilePath::AddExtension(const StringType& extension) const {
+FilePath FilePath::AddExtension(StringPieceType extension) const {
   if (IsEmptyOrSpecialCase(BaseName().value()))
     return FilePath();
 
   // If the new extension is "" or ".", then just return the current FilePath.
-  if (extension.empty() || extension == StringType(1, kExtensionSeparator))
+  if (extension.empty() ||
+      (extension.size() == 1 && extension[0] == kExtensionSeparator))
     return *this;
 
   StringType str = path_;
   if (extension[0] != kExtensionSeparator &&
       *(str.end() - 1) != kExtensionSeparator) {
     str.append(1, kExtensionSeparator);
   }
-  str.append(extension);
+  extension.AppendToString(&str);
   return FilePath(str);
 }
 
-FilePath FilePath::ReplaceExtension(const StringType& extension) const {
+FilePath FilePath::ReplaceExtension(StringPieceType extension) const {
   if (IsEmptyOrSpecialCase(BaseName().value()))
     return FilePath();
 
   FilePath no_ext = RemoveExtension();
   // If the new extension is "" or ".", then just remove the current extension.
-  if (extension.empty() || extension == StringType(1, kExtensionSeparator))
+  if (extension.empty() ||
+      (extension.size() == 1 && extension[0] == kExtensionSeparator))
     return no_ext;
 
   StringType str = no_ext.value();
   if (extension[0] != kExtensionSeparator)
     str.append(1, kExtensionSeparator);
-  str.append(extension);
+  extension.AppendToString(&str);
   return FilePath(str);
 }
 
-bool FilePath::MatchesExtension(const StringType& extension) const {
+bool FilePath::MatchesExtension(StringPieceType extension) const {
   DCHECK(extension.empty() || extension[0] == kExtensionSeparator);
 
   StringType current_extension = Extension();
 
   if (current_extension.length() != extension.length())
     return false;
 
   return FilePath::CompareEqualIgnoreCase(extension, current_extension);
 }
 
-FilePath FilePath::Append(const StringType& component) const {
-  const StringType* appended = &component;
+FilePath FilePath::Append(StringPieceType component) const {
+  StringPieceType appended = component;
   StringType without_nuls;
 
   StringType::size_type nul_pos = component.find(kStringTerminator);
-  if (nul_pos != StringType::npos) {
-    without_nuls = component.substr(0, nul_pos);
-    appended = &without_nuls;
+  if (nul_pos != StringPieceType::npos) {
+    component.substr(0, nul_pos).CopyToString(&without_nuls);
+    appended = StringPieceType(without_nuls);
   }
 
-  DCHECK(!IsPathAbsolute(*appended));
+  DCHECK(!IsPathAbsolute(appended));
 
   if (path_.compare(kCurrentDirectory) == 0) {
     // Append normally doesn't do any normalization, but as a special case,
     // when appending to kCurrentDirectory, just return a new path for the
     // component argument.  Appending component to kCurrentDirectory would
     // serve no purpose other than needlessly lengthening the path, and
     // it's likely in practice to wind up with FilePath objects containing
     // only kCurrentDirectory when calling DirName on a single relative path
     // component.
-    return FilePath(*appended);
+    return FilePath(appended);
   }
 
   FilePath new_path(path_);
   new_path.StripTrailingSeparatorsInternal();
 
   // Don't append a separator if the path is empty (indicating the current
   // directory) or if the path component is empty (indicating nothing to
   // append).
-  if (appended->length() > 0 && new_path.path_.length() > 0) {
+  if (appended.length() > 0 && new_path.path_.length() > 0) {
     // Don't append a separator if the path still ends with a trailing
     // separator after stripping (indicating the root directory).
     if (!IsSeparator(new_path.path_[new_path.path_.length() - 1])) {
       // Don't append a separator if the path is just a drive letter.
       if (FindDriveLetter(new_path.path_) + 1 != new_path.path_.length()) {
         new_path.path_.append(1, kSeparators[0]);
       }
     }
   }
 
-  new_path.path_.append(*appended);
+  appended.AppendToString(&new_path.path_);
   return new_path;
 }
 
 FilePath FilePath::Append(const FilePath& component) const {
   return Append(component.value());
 }
 
-FilePath FilePath::AppendASCII(const StringPiece& component) const {
+FilePath FilePath::AppendASCII(StringPiece component) const {
   DCHECK(base::IsStringASCII(component));
 #if defined(OS_WIN)
-  return Append(ASCIIToUTF16(component.as_string()));
+  return Append(ASCIIToUTF16(component));
 #elif defined(OS_POSIX)
-  return Append(component.as_string());
+  return Append(component);
 #endif
 }
 
 bool FilePath::IsAbsolute() const {
   return IsPathAbsolute(path_);
 }
 
 bool FilePath::EndsWithSeparator() const {
   if (empty())
     return false;
@@ skipping 134 matching lines @@
     return false;
 #endif
 
   if (path_.find(kStringTerminator) != StringType::npos)
     return false;
 
   return true;
 }
 
 #if defined(OS_WIN)
-// Windows specific implementation of file string comparisons
+// Windows specific implementation of file string comparisons.
 
-int FilePath::CompareIgnoreCase(const StringType& string1,
-                                const StringType& string2) {
+int FilePath::CompareIgnoreCase(StringPieceType string1,
+                                StringPieceType string2) {
   // Perform character-wise upper case comparison rather than using the
   // fully Unicode-aware CompareString(). For details see:
   // http://blogs.msdn.com/michkap/archive/2005/10/17/481600.aspx
-  StringType::const_iterator i1 = string1.begin();
-  StringType::const_iterator i2 = string2.begin();
-  StringType::const_iterator string1end = string1.end();
-  StringType::const_iterator string2end = string2.end();
+  StringPieceType::const_iterator i1 = string1.begin();
+  StringPieceType::const_iterator i2 = string2.begin();
+  StringPieceType::const_iterator string1end = string1.end();
+  StringPieceType::const_iterator string2end = string2.end();
   for ( ; i1 != string1end && i2 != string2end; ++i1, ++i2) {
     wchar_t c1 =
         (wchar_t)LOWORD(::CharUpperW((LPWSTR)(DWORD_PTR)MAKELONG(*i1, 0)));
     wchar_t c2 =
         (wchar_t)LOWORD(::CharUpperW((LPWSTR)(DWORD_PTR)MAKELONG(*i2, 0)));
     if (c1 < c2)
       return -1;
     if (c1 > c2)
       return 1;
   }
   if (i1 != string1end)
     return 1;
   if (i2 != string2end)
     return -1;
   return 0;
 }
 
 #elif defined(OS_MACOSX)
-// Mac OS X specific implementation of file string comparisons
+// Mac OS X specific implementation of file string comparisons.
 
 // cf. http://developer.apple.com/mac/library/technotes/tn/tn1150.html#UnicodeSubtleties
 //
 // "When using CreateTextEncoding to create a text encoding, you should set
 // the TextEncodingBase to kTextEncodingUnicodeV2_0, set the
 // TextEncodingVariant to kUnicodeCanonicalDecompVariant, and set the
 // TextEncodingFormat to kUnicode16BitFormat. Using these values ensures that
 // the Unicode will be in the same form as on an HFS Plus volume, even as the
 // Unicode standard evolves."
 //
@@ skipping 423 matching lines @@
       int lookup_offset = lower_case_table[codepoint >> 8];
       if (lookup_offset != 0)
         codepoint = lower_case_table[lookup_offset + (codepoint & 0x00FF)];
       // Note: codepoint1 may be again 0 at this point if the character was
       // an ignorable.
     }
   }
   return codepoint;
 }
 
-}  // anonymous namespace
+}  // namespace
 
 // Special UTF-8 version of FastUnicodeCompare. Cf:
 // http://developer.apple.com/mac/library/technotes/tn/tn1150.html#StringComparisonAlgorithm
 // The input strings must be in the special HFS decomposed form.
-int FilePath::HFSFastUnicodeCompare(const StringType& string1,
-                                    const StringType& string2) {
+int FilePath::HFSFastUnicodeCompare(StringPieceType string1,
+                                    StringPieceType string2) {
   int length1 = string1.length();
   int length2 = string2.length();
   int index1 = 0;
   int index2 = 0;
 
   for (;;) {
-    int codepoint1 = HFSReadNextNonIgnorableCodepoint(string1.c_str(),
+    int codepoint1 = HFSReadNextNonIgnorableCodepoint(string1.data(),
                                                       length1,
                                                       &index1);
-    int codepoint2 = HFSReadNextNonIgnorableCodepoint(string2.c_str(),
+    int codepoint2 = HFSReadNextNonIgnorableCodepoint(string2.data(),
                                                       length2,
                                                       &index2);
     if (codepoint1 != codepoint2)
       return (codepoint1 < codepoint2) ? -1 : 1;
     if (codepoint1 == 0) {
       DCHECK_EQ(index1, length1);
       DCHECK_EQ(index2, length2);
       return 0;
     }
   }
 }
 
-StringType FilePath::GetHFSDecomposedForm(const StringType& string) {
+StringType FilePath::GetHFSDecomposedForm(StringPieceType string) {
   ScopedCFTypeRef<CFStringRef> cfstring(
       CFStringCreateWithBytesNoCopy(
           NULL,
-          reinterpret_cast<const UInt8*>(string.c_str()),
+          reinterpret_cast<const UInt8*>(string.data()),
           string.length(),
           kCFStringEncodingUTF8,
           false,
           kCFAllocatorNull));
   // Query the maximum length needed to store the result. In most cases this
   // will overestimate the required space. The return value also already
   // includes the space needed for a terminating 0.
   CFIndex length = CFStringGetMaximumSizeOfFileSystemRepresentation(cfstring);
   DCHECK_GT(length, 0);  // should be at least 1 for the 0-terminator.
   // Reserve enough space for CFStringGetFileSystemRepresentation to write into.
   // Also set the length to the maximum so that we can shrink it later.
   // (Increasing rather than decreasing it would clobber the string contents!)
   StringType result;
   result.reserve(length);
   result.resize(length - 1);
   Boolean success = CFStringGetFileSystemRepresentation(cfstring,
                                                         &result[0],
                                                         length);
   if (success) {
     // Reduce result.length() to actual string length.
     result.resize(strlen(result.c_str()));
   } else {
     // An error occurred -> clear result.
     result.clear();
   }
   return result;
 }
 
-int FilePath::CompareIgnoreCase(const StringType& string1,
-                                const StringType& string2) {
+int FilePath::CompareIgnoreCase(StringPieceType string1,
+                                StringPieceType string2) {
   // Quick checks for empty strings - these speed things up a bit and make the
   // following code cleaner.
   if (string1.empty())
     return string2.empty() ? 0 : -1;
   if (string2.empty())
     return 1;
 
   StringType hfs1 = GetHFSDecomposedForm(string1);
   StringType hfs2 = GetHFSDecomposedForm(string2);
 
   // GetHFSDecomposedForm() returns an empty string in an error case.
   if (hfs1.empty() || hfs2.empty()) {
     NOTREACHED();
     ScopedCFTypeRef<CFStringRef> cfstring1(
         CFStringCreateWithBytesNoCopy(
             NULL,
-            reinterpret_cast<const UInt8*>(string1.c_str()),
+            reinterpret_cast<const UInt8*>(string1.data()),
             string1.length(),
             kCFStringEncodingUTF8,
             false,
             kCFAllocatorNull));
     ScopedCFTypeRef<CFStringRef> cfstring2(
         CFStringCreateWithBytesNoCopy(
             NULL,
-            reinterpret_cast<const UInt8*>(string2.c_str()),
+            reinterpret_cast<const UInt8*>(string2.data()),
             string2.length(),
             kCFStringEncodingUTF8,
             false,
             kCFAllocatorNull));
     return CFStringCompare(cfstring1,
                            cfstring2,
                            kCFCompareCaseInsensitive);
   }
 
   return HFSFastUnicodeCompare(hfs1, hfs2);
 }
 
 #else  // << WIN. MACOSX | other (POSIX) >>
 
 // Generic (POSIX) implementation of file string comparison.
 // TODO(rolandsteiner) check if this is sufficient/correct.
-int FilePath::CompareIgnoreCase(const StringType& string1,
-                                const StringType& string2) {
-  int comparison = strcasecmp(string1.c_str(), string2.c_str());
+int FilePath::CompareIgnoreCase(StringPieceType string1,
+                                StringPieceType string2) {
+  int comparison = strcasecmp(string1.data(), string2.data());
   if (comparison < 0)
     return -1;
   if (comparison > 0)
     return 1;
   return 0;
 }
 
 #endif  // OS versions of CompareIgnoreCase()
 
 
@@ skipping 37 matching lines @@
 #endif
 }
 
 #if defined(OS_ANDROID)
 bool FilePath::IsContentUri() const {
   return StartsWithASCII(path_, "content://", false /*case_sensitive*/);
 }
 #endif
 
 }  // namespace base