foo (1).user.js, not foo.user (1).js.

base/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/file_path.h"
 
 #include <string.h>
 #include <algorithm>
 
 #include "base/basictypes.h"
@@ skipping 26 matching lines @@
 
 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* kCommonDoubleExtensions[] = { "gz", "z", "bz2" };
+const char* kCommonDoubleExtensionSuffixes[] = { "gz", "z", "bz2" };
+const char* kCommonDoubleExtensions[] = { "user.js" };
 
 // 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) {
 #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.
@@ skipping 65 matching lines @@
   if (path == FilePath::kCurrentDirectory || path == FilePath::kParentDirectory)
     return StringType::npos;
 
   const StringType::size_type last_dot =
       path.rfind(FilePath::kExtensionSeparator);
 
   // No extension, or the extension is the whole filename.
   if (last_dot == StringType::npos || last_dot == 0U)
     return last_dot;
 
-  // Special case .<extension1>.<extension2>, but only if the final extension
-  // is one of a few common double extensions.
-  StringType extension(path, last_dot + 1);
-  bool is_common_double_extension = false;
-  for (size_t i = 0; i < arraysize(kCommonDoubleExtensions); ++i) {
-    if (LowerCaseEqualsASCII(extension, kCommonDoubleExtensions[i]))
-      is_common_double_extension = true;
-  }
-  if (!is_common_double_extension)
-    return last_dot;
-
-  // Check that <extension1> is 1-4 characters, otherwise fall back to
-  // <extension2>.
   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);
-  if (penultimate_dot != StringType::npos &&
-      (last_separator == StringType::npos ||
-      penultimate_dot > last_separator) &&
-      last_dot - penultimate_dot <= 5U &&
-      last_dot - penultimate_dot > 1U) {
-    return penultimate_dot;
+
+  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]))
+      return penultimate_dot;
+  }
+
+  StringType extension(path, last_dot + 1);
+  for (size_t i = 0; i < arraysize(kCommonDoubleExtensionSuffixes); ++i) {
+    if (LowerCaseEqualsASCII(extension, kCommonDoubleExtensionSuffixes[i])) {
+      if ((last_dot - penultimate_dot) <= 5U &&
+          (last_dot - penultimate_dot) > 1U) {
+        return penultimate_dot;
+      }
+    }
   }
 
   return last_dot;
 }
 
 // Returns true if path is "", ".", or "..".
 bool IsEmptyOrSpecialCase(const StringType& path) {
   // Special cases "", ".", and ".."
   if (path.empty() || path == FilePath::kCurrentDirectory ||
       path == FilePath::kParentDirectory) {
@@ skipping 1055 matching lines @@
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
   StringType copy = path_;
   for (size_t i = 1; i < arraysize(kSeparators); ++i) {
     std::replace(copy.begin(), copy.end(), kSeparators[i], kSeparators[0]);
   }
   return FilePath(copy);
 #else
   return *this;
 #endif
 }