Convert Pass()→std::move() in //components/[n-z]*

components/search_engines/template_url_prepopulate_data.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 "components/search_engines/template_url_prepopulate_data.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 #include <locale.h>
 #endif
 
@@ skipping 996 matching lines @@
   data->date_created = base::Time();
   data->last_modified = base::Time();
   data->prepopulate_id = id;
   for (size_t i = 0; i < alternate_urls.GetSize(); ++i) {
     std::string alternate_url;
     alternate_urls.GetString(i, &alternate_url);
     DCHECK(!alternate_url.empty());
     data->alternate_urls.push_back(alternate_url);
   }
   data->search_terms_replacement_key = search_terms_replacement_key.as_string();
-  return data.Pass();
+  return data;
 }
 
 ScopedVector<TemplateURLData> GetPrepopulatedTemplateURLData(
     PrefService* prefs) {
   ScopedVector<TemplateURLData> t_urls;
   if (!prefs)
-    return t_urls.Pass();
+    return t_urls;
 
   const base::ListValue* list = prefs->GetList(prefs::kSearchProviderOverrides);
   if (!list)
-    return t_urls.Pass();
+    return t_urls;
 
   size_t num_engines = list->GetSize();
   for (size_t i = 0; i != num_engines; ++i) {
     const base::DictionaryValue* engine;
     base::string16 name;
     base::string16 keyword;
     std::string search_url;
     std::string favicon_url;
     std::string encoding;
     int id = -1;
@@ skipping 32 matching lines @@
       engine->GetString("search_terms_replacement_key",
           &search_terms_replacement_key);
       t_urls.push_back(MakePrepopulatedTemplateURLData(name, keyword,
           search_url, suggest_url, instant_url, image_url, new_tab_url,
           contextual_search_url, search_url_post_params,
           suggest_url_post_params, instant_url_post_params,
           image_url_post_params, favicon_url, encoding, *alternate_urls,
           search_terms_replacement_key, id).release());
     }
   }
-  return t_urls.Pass();
+  return t_urls;
 }
 
 bool SameDomain(const GURL& given_url, const GURL& prepopulated_url) {
   return prepopulated_url.is_valid() &&
       net::registry_controlled_domains::SameDomainOrHost(
           given_url, prepopulated_url,
           net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
 }
 
 }  // namespace
@@ skipping 14 matching lines @@
 }
 
 ScopedVector<TemplateURLData> GetPrepopulatedEngines(
     PrefService* prefs,
     size_t* default_search_provider_index) {
   // If there is a set of search engines in the preferences file, it overrides
   // the built-in set.
   *default_search_provider_index = 0;
   ScopedVector<TemplateURLData> t_urls = GetPrepopulatedTemplateURLData(prefs);
   if (!t_urls.empty())
-    return t_urls.Pass();
+    return t_urls;
 
   const PrepopulatedEngine** engines;
   size_t num_engines;
   GetPrepopulationSetFromCountryID(prefs, &engines, &num_engines);
   for (size_t i = 0; i != num_engines; ++i) {
     t_urls.push_back(
         MakeTemplateURLDataFromPrepopulatedEngine(*engines[i]).release());
   }
-  return t_urls.Pass();
+  return t_urls;
 }
 
 scoped_ptr<TemplateURLData> MakeTemplateURLDataFromPrepopulatedEngine(
     const PrepopulatedEngine& engine) {
   base::ListValue alternate_urls;
   if (engine.alternate_urls) {
     for (size_t i = 0; i < engine.alternate_urls_size; ++i)
       alternate_urls.AppendString(std::string(engine.alternate_urls[i]));
   }
 
@@ skipping 19 matching lines @@
   scoped_ptr<TemplateURLData> default_search_provider;
   size_t default_search_index;
   // This could be more efficient.  We are loading all the URLs to only keep
   // the first one.
   ScopedVector<TemplateURLData> loaded_urls =
       GetPrepopulatedEngines(prefs, &default_search_index);
   if (default_search_index < loaded_urls.size()) {
     default_search_provider.reset(loaded_urls[default_search_index]);
     loaded_urls.weak_erase(loaded_urls.begin() + default_search_index);
   }
-  return default_search_provider.Pass();
+  return default_search_provider;
 }
 
 SearchEngineType GetEngineType(const TemplateURL& url,
                                const SearchTermsData& search_terms_data) {
   // By calling ReplaceSearchTerms, we ensure that even TemplateURLs whose URLs
   // can't be directly inspected (e.g. due to containing {google:baseURL}) can
   // be converted to GURLs we can look at.
   GURL gurl(url.url_ref().ReplaceSearchTerms(TemplateURLRef::SearchTermsArgs(
       base::ASCIIToUTF16("x")), search_terms_data));
   return gurl.is_valid() ? GetEngineType(gurl) : SEARCH_ENGINE_OTHER;
@@ skipping 89 matching lines @@
         base::ToUpperASCII(locale_str[begin]),
         base::ToUpperASCII(locale_str[begin + 1]));
   }
 
   return kCountryIDUnknown;
 }
 
 #endif  // OS_*
 
 }  // namespace TemplateURLPrepopulateData