Move more uses of string16 to specify base::

ui/base/l10n/l10n_util_collator.h

 // Copyright (c) 2011 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.
 
 #ifndef UI_BASE_L10N_L10N_UTIL_COLLATOR_H_
 #define UI_BASE_L10N_L10N_UTIL_COLLATOR_H_
 
 #include <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
 
 #include "base/i18n/string_compare.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/icu/source/i18n/unicode/coll.h"
 #include "ui/base/ui_export.h"
 
 namespace l10n_util {
 
 // Used by SortStringsUsingMethod. Invokes a method on the objects passed to
 // operator (), comparing the string results using a collator.
 template <class T, class Method>
 class StringMethodComparatorWithCollator
-    : public std::binary_function<const string16&,
-                                  const string16&,
+    : public std::binary_function<const base::string16&,
+                                  const base::string16&,
                                   bool> {
  public:
   StringMethodComparatorWithCollator(icu::Collator* collator, Method method)
       : collator_(collator),
         method_(method) { }
 
   // Returns true if lhs preceeds rhs.
   bool operator() (T* lhs_t, T* rhs_t) {
     return base::i18n::CompareString16WithCollator(collator_,
         (lhs_t->*method_)(), (rhs_t->*method_)()) == UCOL_LESS;
   }
 
  private:
   icu::Collator* collator_;
   Method method_;
 };
 
 // Used by SortStringsUsingMethod. Invokes a method on the objects passed to
 // operator (), comparing the string results using <.
 template <class T, class Method>
-class StringMethodComparator : public std::binary_function<const string16&,
-                                                           const string16&,
-                                                           bool> {
+class StringMethodComparator
+    : public std::binary_function<const base::string16&,
+                                  const base::string16&,
+                                  bool> {
  public:
   explicit StringMethodComparator(Method method) : method_(method) { }
 
   // Returns true if lhs preceeds rhs.
   bool operator() (T* lhs_t, T* rhs_t) {
     return (lhs_t->*method_)() < (rhs_t->*method_)();
   }
 
  private:
   Method method_;
@@ skipping 27 matching lines @@
 template <class Element>
 class StringComparator : public std::binary_function<const Element&,
                                                      const Element&,
                                                      bool> {
  public:
   explicit StringComparator(icu::Collator* collator)
       : collator_(collator) { }
 
   // Returns true if lhs precedes rhs.
   bool operator()(const Element& lhs, const Element& rhs) {
-    const string16& lhs_string_key = lhs.GetStringKey();
-    const string16& rhs_string_key = rhs.GetStringKey();
+    const base::string16& lhs_string_key = lhs.GetStringKey();
+    const base::string16& rhs_string_key = rhs.GetStringKey();
 
-    return StringComparator<string16>(collator_)(lhs_string_key,
+    return StringComparator<base::string16>(collator_)(lhs_string_key,
                                                  rhs_string_key);
   }
 
  private:
   icu::Collator* collator_;
 };
 
 // Specialization of operator() method for string16 version.
 template <> UI_EXPORT
-bool StringComparator<string16>::operator()(const string16& lhs,
-                                            const string16& rhs);
+bool StringComparator<base::string16>::operator()(const base::string16& lhs,
+                                                  const base::string16& rhs);
 
 // In place sorting of |elements| of a vector according to the string key of
 // each element in the vector by using collation rules for |locale|.
 // |begin_index| points to the start position of elements in the vector which
 // want to be sorted. |end_index| points to the end position of elements in the
 // vector which want to be sorted
 template <class Element>
 void SortVectorWithStringKey(const std::string& locale,
                              std::vector<Element>* elements,
                              unsigned int begin_index,
@@ skipping 20 matching lines @@
 void SortVectorWithStringKey(const std::string& locale,
                              std::vector<Element>* elements,
                              bool needs_stable_sort) {
   SortVectorWithStringKey<Element>(locale, elements, 0, elements->size(),
                                    needs_stable_sort);
 }
 
 }  // namespace l10n_util
 
 #endif  // UI_BASE_L10N_L10N_UTIL_COLLATOR_H_