Replace scoped_ptr with std::unique_ptr in //ui

ui/base/l10n/formatter.cc

 // Copyright 2014 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 "ui/base/l10n/formatter.h"
 
 #include <limits.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "third_party/icu/source/common/unicode/unistr.h"
 #include "third_party/icu/source/i18n/unicode/msgfmt.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/strings/grit/ui_strings.h"
 
 namespace ui {
 
 UI_BASE_EXPORT bool formatter_force_fallback = false;
 
 struct Pluralities {
@@ skipping 113 matching lines @@
   " other{# days and }"
 };
 static const Pluralities IDS_DURATION_HOUR_2ND = {
   IDS_TIME_HOURS_2ND,
   "one{# hour}",
   " other{# hours}"
 };
 
 namespace {
 
-scoped_ptr<icu::PluralRules> BuildPluralRules() {
+std::unique_ptr<icu::PluralRules> BuildPluralRules() {
   UErrorCode err = U_ZERO_ERROR;
-  scoped_ptr<icu::PluralRules> rules(
+  std::unique_ptr<icu::PluralRules> rules(
       icu::PluralRules::forLocale(icu::Locale::getDefault(), err));
   if (U_FAILURE(err)) {
     err = U_ZERO_ERROR;
     icu::UnicodeString fallback_rules("one: n is 1", -1, US_INV);
     rules.reset(icu::PluralRules::createRules(fallback_rules, err));
     DCHECK(U_SUCCESS(err));
   }
   return rules;
 }
 
@@ skipping 65 matching lines @@
   UErrorCode error = U_ZERO_ERROR;
   FormatNumberInPlural(*detailed_format_[units][0], value_1,
                        formatted_string, &error);
   DCHECK(U_SUCCESS(error));
   FormatNumberInPlural(*detailed_format_[units][1], value_2,
                         formatted_string, &error);
   DCHECK(U_SUCCESS(error));
   return;
 }
 
-scoped_ptr<icu::MessageFormat> Formatter::CreateFallbackFormat(
+std::unique_ptr<icu::MessageFormat> Formatter::CreateFallbackFormat(
     const icu::PluralRules& rules,
     const Pluralities& pluralities) const {
   icu::UnicodeString pattern("{NUMBER, plural, ");
   if (rules.isKeyword(UNICODE_STRING_SIMPLE("one")))
     pattern += icu::UnicodeString(pluralities.fallback_one);
   pattern += icu::UnicodeString(pluralities.fallback_other);
   pattern.append(UChar(0x7du));  // "}" = U+007D
 
   UErrorCode error = U_ZERO_ERROR;
-  scoped_ptr<icu::MessageFormat> format(
+  std::unique_ptr<icu::MessageFormat> format(
       new icu::MessageFormat(pattern, error));
   DCHECK(U_SUCCESS(error));
   return format;
 }
 
-scoped_ptr<icu::MessageFormat> Formatter::InitFormat(
+std::unique_ptr<icu::MessageFormat> Formatter::InitFormat(
     const Pluralities& pluralities) {
   if (!formatter_force_fallback) {
     base::string16 pattern = l10n_util::GetStringUTF16(pluralities.id);
     UErrorCode error = U_ZERO_ERROR;
-    scoped_ptr<icu::MessageFormat> format(new icu::MessageFormat(
+    std::unique_ptr<icu::MessageFormat> format(new icu::MessageFormat(
         icu::UnicodeString(FALSE, pattern.data(), pattern.length()), error));
     DCHECK(U_SUCCESS(error));
     if (format.get())
       return format;
   }
 
-  scoped_ptr<icu::PluralRules> rules(BuildPluralRules());
+  std::unique_ptr<icu::PluralRules> rules(BuildPluralRules());
   return CreateFallbackFormat(*rules, pluralities);
 }
 
 const Formatter* FormatterContainer::Get(TimeFormat::Format format,
                                          TimeFormat::Length length) const {
   DCHECK(formatter_[format][length])
       << "Combination of FORMAT_ELAPSED and LENGTH_LONG is not implemented!";
   return formatter_[format][length].get();
 }
 
@@ skipping 41 matching lines @@
 
 void FormatterContainer::Shutdown() {
   for (int format = 0; format < TimeFormat::FORMAT_COUNT; ++format) {
     for (int length = 0; length < TimeFormat::LENGTH_COUNT; ++length) {
       formatter_[format][length].reset();
     }
   }
 }
 
 }  // namespace ui