Replace scoped_ptr with std::unique_ptr in //ui

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 <stddef.h>
 
 #include <algorithm>
 #include <functional>
+#include <memory>
 #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_base_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:
@@ skipping 31 matching lines @@
 
 // Sorts the objects in |elements| using the method |method|, which must return
 // a string. Sorting is done using a collator, unless a collator can not be
 // found in which case the strings are sorted using the operator <.
 template <class T, class Method>
 void SortStringsUsingMethod(const std::string& locale,
                             std::vector<T*>* elements,
                             Method method) {
   UErrorCode error = U_ZERO_ERROR;
   icu::Locale loc(locale.c_str());
-  scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(loc, error));
+  std::unique_ptr<icu::Collator> collator(
+      icu::Collator::createInstance(loc, error));
   if (U_FAILURE(error)) {
     sort(elements->begin(), elements->end(),
          StringMethodComparator<T, Method>(method));
     return;
   }
 
   std::sort(elements->begin(), elements->end(),
       StringMethodComparatorWithCollator<T, Method>(collator.get(), method));
 }
 
@@ skipping 42 matching lines @@
 template <class Element>
 void SortVectorWithStringKey(const std::string& locale,
                              std::vector<Element>* elements,
                              size_t begin_index,
                              size_t end_index,
                              bool needs_stable_sort) {
   DCHECK_LT(begin_index, end_index);
   DCHECK_LE(end_index, elements->size());
   UErrorCode error = U_ZERO_ERROR;
   icu::Locale loc(locale.c_str());
-  scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(loc, error));
+  std::unique_ptr<icu::Collator> collator(
+      icu::Collator::createInstance(loc, error));
   if (U_FAILURE(error))
     collator.reset();
   StringComparator<Element> c(collator.get());
   if (needs_stable_sort) {
     stable_sort(elements->begin() + begin_index,
                 elements->begin() + end_index,
                 c);
   } else {
     sort(elements->begin() + begin_index, elements->begin() + end_index, c);
   }
 }
 
 template <class Element>
 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_