Convert Pass()→std::move() 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 <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 133 matching lines @@
 scoped_ptr<icu::PluralRules> BuildPluralRules() {
   UErrorCode err = U_ZERO_ERROR;
   scoped_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.Pass();
+  return rules;
 }
 
 void FormatNumberInPlural(const icu::MessageFormat& format, int number,
                           icu::UnicodeString* result, UErrorCode* err) {
   if (U_FAILURE(*err)) return;
   icu::Formattable formattable(number);
   icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE);
   format.format(&formattable, 1, *result, ignore, *err);
   DCHECK(U_SUCCESS(*err));
   return;
@@ skipping 70 matching lines @@
   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(
       new icu::MessageFormat(pattern, error));
   DCHECK(U_SUCCESS(error));
-  return format.Pass();
+  return format;
 }
 
 scoped_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(
         icu::UnicodeString(FALSE, pattern.data(), pattern.length()), error));
     DCHECK(U_SUCCESS(error));
     if (format.get())
-      return format.Pass();
+      return format;
   }
 
   scoped_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!";
@@ skipping 44 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