Access singletons with a new GetInstance() method instead of Singleton<T>.

base/i18n/file_util_icu.cc

 // Copyright (c) 2009 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.
 
 // File utilities that use the ICU library go in this file.
 
 #include "base/i18n/file_util_icu.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/sys_string_conversions.h"
 #include "build/build_config.h"
 #include "unicode/coll.h"
 #include "unicode/uniset.h"
 
 namespace {
 
 class IllegalCharacters {
  public:
+  static IllegalCharacters* GetInstance() {
+    return Singleton<IllegalCharacters>::get();
+  }
+
   bool contains(UChar32 ucs4) {
     return !!set->contains(ucs4);
   }
 
   bool containsNone(const string16 &s) {
     return !!set->containsNone(icu::UnicodeString(s.c_str(), s.size()));
   }
 
  private:
   friend class Singleton<IllegalCharacters>;
@@ skipping 35 matching lines @@
   set->add(0xFDD0, 0xFDEF);
   for (int i = 0; i <= 0x10; ++i) {
     int plane_base = 0x10000 * i;
     set->add(plane_base + 0xFFFE, plane_base + 0xFFFF);
   }
   set->freeze();
 }
 
 class LocaleAwareComparator {
  public:
-  LocaleAwareComparator() {
-    UErrorCode error_code = U_ZERO_ERROR;
-    // Use the default collator. The default locale should have been properly
-    // set by the time this constructor is called.
-    collator_.reset(icu::Collator::createInstance(error_code));
-    DCHECK(U_SUCCESS(error_code));
-    // Make it case-sensitive.
-    collator_->setStrength(icu::Collator::TERTIARY);
-    // Note: We do not set UCOL_NORMALIZATION_MODE attribute. In other words, we
-    // do not pay performance penalty to guarantee sort order correctness for
-    // non-FCD (http://unicode.org/notes/tn5/#FCD) file names. This should be a
-    // reasonable tradeoff because such file names should be rare and the sort
-    // order doesn't change much anyway.
+  static LocaleAwareComparator* GetInstance() {
+    return Singleton<LocaleAwareComparator>::get();
   }
 
   // Note: A similar function is available in l10n_util.
   // We cannot use it because base should not depend on l10n_util.
   // TODO(yuzo): Move some of l10n_util to base.
   int Compare(const string16& a, const string16& b) {
     // We are not sure if Collator::compare is thread-safe.
     // Use an AutoLock just in case.
     AutoLock auto_lock(lock_);
 
     UErrorCode error_code = U_ZERO_ERROR;
     UCollationResult result = collator_->compare(
         static_cast<const UChar*>(a.c_str()),
         static_cast<int>(a.length()),
         static_cast<const UChar*>(b.c_str()),
         static_cast<int>(b.length()),
         error_code);
     DCHECK(U_SUCCESS(error_code));
     return result;
   }
 
  private:
+  LocaleAwareComparator() {
+    UErrorCode error_code = U_ZERO_ERROR;
+    // Use the default collator. The default locale should have been properly
+    // set by the time this constructor is called.
+    collator_.reset(icu::Collator::createInstance(error_code));
+    DCHECK(U_SUCCESS(error_code));
+    // Make it case-sensitive.
+    collator_->setStrength(icu::Collator::TERTIARY);
+    // Note: We do not set UCOL_NORMALIZATION_MODE attribute. In other words, we
+    // do not pay performance penalty to guarantee sort order correctness for
+    // non-FCD (http://unicode.org/notes/tn5/#FCD) file names. This should be a
+    // reasonable tradeoff because such file names should be rare and the sort
+    // order doesn't change much anyway.
+  }
+
   scoped_ptr<icu::Collator> collator_;
   Lock lock_;
   friend struct DefaultSingletonTraits<LocaleAwareComparator>;
 
   DISALLOW_COPY_AND_ASSIGN(LocaleAwareComparator);
 };
 
 }  // namespace
 
 namespace file_util {
 
 bool IsFilenameLegal(const string16& file_name) {
-  return Singleton<IllegalCharacters>()->containsNone(file_name);
+  return IllegalCharacters::GetInstance()->containsNone(file_name);
 }
 
 void ReplaceIllegalCharactersInPath(FilePath::StringType* file_name,
                                     char replace_char) {
   DCHECK(file_name);
 
-  DCHECK(!(Singleton<IllegalCharacters>()->contains(replace_char)));
+  DCHECK(!(IllegalCharacters::GetInstance()->contains(replace_char)));
 
   // Remove leading and trailing whitespace.
   TrimWhitespace(*file_name, TRIM_ALL, file_name);
 
-  IllegalCharacters* illegal = Singleton<IllegalCharacters>::get();
+  IllegalCharacters* illegal = IllegalCharacters::GetInstance();
   int cursor = 0;  // The ICU macros expect an int.
   while (cursor < static_cast<int>(file_name->size())) {
     int char_begin = cursor;
     uint32 code_point;
 #if defined(OS_MACOSX)
     // Mac uses UTF-8 encoding for filenames.
     U8_NEXT(file_name->data(), cursor, static_cast<int>(file_name->length()),
             code_point);
 #elif defined(OS_WIN)
     // Windows uses UTF-16 encoding for filenames.
@@ skipping 15 matching lines @@
       // We just made the potentially multi-byte/word char into one that only
       // takes one byte/word, so need to adjust the cursor to point to the next
       // character again.
       cursor = char_begin + 1;
     }
   }
 }
 
 bool LocaleAwareCompareFilenames(const FilePath& a, const FilePath& b) {
 #if defined(OS_WIN)
-  return Singleton<LocaleAwareComparator>()->Compare(a.value().c_str(),
-                                                     b.value().c_str()) < 0;
+  return LocaleAwareComparator::GetInstance()->Compare(a.value().c_str(),
+                                                       b.value().c_str()) < 0;
 
 #elif defined(OS_POSIX)
   // On linux, the file system encoding is not defined. We assume
   // SysNativeMBToWide takes care of it.
   //
   // ICU's collator can take strings in OS native encoding. But we convert the
   // strings to UTF-16 ourselves to ensure conversion consistency.
   // TODO(yuzo): Perhaps we should define SysNativeMBToUTF16?
-  return Singleton<LocaleAwareComparator>()->Compare(
+  return LocaleAwareComparator::GetInstance()->Compare(
       WideToUTF16(base::SysNativeMBToWide(a.value().c_str())),
       WideToUTF16(base::SysNativeMBToWide(b.value().c_str()))) < 0;
 #else
   #error Not implemented on your system
 #endif
 }
 
 }  // namespace