split file path constants out for split link

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 {
 
-#if defined(FILE_PATH_USES_WIN_SEPARATORS)
-const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("\\/");
-#else  // FILE_PATH_USES_WIN_SEPARATORS
-const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("/");
-#endif  // FILE_PATH_USES_WIN_SEPARATORS
-
-const FilePath::CharType FilePath::kCurrentDirectory[] = FILE_PATH_LITERAL(".");
-const FilePath::CharType FilePath::kParentDirectory[] = FILE_PATH_LITERAL("..");
-
-const FilePath::CharType FilePath::kExtensionSeparator = FILE_PATH_LITERAL('.');
-
 typedef FilePath::StringType StringType;
 
 namespace {
 
 const char* kCommonDoubleExtensionSuffixes[] = { "gz", "z", "bz2" };
 const char* kCommonDoubleExtensions[] = { "user.js" };
 
 const FilePath::CharType kStringTerminator = FILE_PATH_LITERAL('\0');
 
 // If this FilePath contains a drive letter specification, returns the
@@ skipping 77 matching lines @@
       path.rfind(FilePath::kExtensionSeparator);
 
   // No extension, or the extension is the whole filename.
   if (last_dot == StringType::npos || last_dot == 0U)
     return last_dot;
 
   const StringType::size_type penultimate_dot =
       path.rfind(FilePath::kExtensionSeparator, last_dot - 1);
   const StringType::size_type last_separator =
       path.find_last_of(FilePath::kSeparators, last_dot - 1,
-                        arraysize(FilePath::kSeparators) - 1);
+                        FilePath::kSeparatorsLength - 1);
 
   if (penultimate_dot == StringType::npos ||
       (last_separator != StringType::npos &&
        penultimate_dot < last_separator)) {
     return last_dot;
   }
 
   for (size_t i = 0; i < arraysize(kCommonDoubleExtensions); ++i) {
     StringType extension(path, penultimate_dot + 1);
     if (LowerCaseEqualsASCII(extension, kCommonDoubleExtensions[i]))
@@ skipping 57 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)
 }
 
 // static
 bool FilePath::IsSeparator(CharType character) {
-  for (size_t i = 0; i < arraysize(kSeparators) - 1; ++i) {
+  for (size_t i = 0; i < kSeparatorsLength - 1; ++i) {
     if (character == kSeparators[i]) {
       return true;
     }
   }
 
   return false;
 }
 
 void FilePath::GetComponents(std::vector<StringType>* components) const {
   DCHECK(components);
@@ skipping 87 matching lines @@
   new_path.StripTrailingSeparatorsInternal();
 
   // The drive letter, if any, always needs to remain in the output.  If there
   // is no drive letter, as will always be the case on platforms which do not
   // support drive letters, letter will be npos, or -1, so the comparisons and
   // resizes below using letter will still be valid.
   StringType::size_type letter = FindDriveLetter(new_path.path_);
 
   StringType::size_type last_separator =
       new_path.path_.find_last_of(kSeparators, StringType::npos,
-                                  arraysize(kSeparators) - 1);
+                                  kSeparatorsLength - 1);
   if (last_separator == StringType::npos) {
     // path_ is in the current directory.
     new_path.path_.resize(letter + 1);
   } else if (last_separator == letter + 1) {
     // path_ is in the root directory.
     new_path.path_.resize(letter + 2);
   } else if (last_separator == letter + 2 &&
              IsSeparator(new_path.path_[letter + 1])) {
     // path_ is in "//" (possibly with a drive letter); leave the double
     // separator intact indicating alternate root.
@@ skipping 17 matching lines @@
   // The drive letter, if any, is always stripped.
   StringType::size_type letter = FindDriveLetter(new_path.path_);
   if (letter != StringType::npos) {
     new_path.path_.erase(0, letter + 1);
   }
 
   // Keep everything after the final separator, but if the pathname is only
   // one character and it's a separator, leave it alone.
   StringType::size_type last_separator =
       new_path.path_.find_last_of(kSeparators, StringType::npos,
-                                  arraysize(kSeparators) - 1);
+                                  kSeparatorsLength - 1);
   if (last_separator != StringType::npos &&
       last_separator < new_path.path_.length() - 1) {
     new_path.path_.erase(0, last_separator + 1);
   }
 
   return new_path;
 }
 
 StringType FilePath::Extension() const {
   FilePath base(BaseName());
@@ skipping 885 matching lines @@
         !IsSeparator(path_[start - 1])) {
       path_.resize(pos - 1);
       last_stripped = pos;
     }
   }
 }
 
 FilePath FilePath::NormalizePathSeparators() const {
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
   StringType copy = path_;
-  for (size_t i = 1; i < arraysize(kSeparators); ++i) {
+  for (size_t i = 1; i < kSeparatorsLength; ++i) {
     std::replace(copy.begin(), copy.end(), kSeparators[i], kSeparators[0]);
   }
   return FilePath(copy);
 #else
   return *this;
 #endif
 }
 
 }  // namespace base
 
 void PrintTo(const base::FilePath& path, std::ostream* out) {
   *out << path.value();
 }