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

components/policy/core/browser/url_blacklist_manager.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/policy/core/browser/url_blacklist_manager.h"
 
 #include <stdint.h>
-
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 40 matching lines @@
 const size_t kMaxFiltersPerPolicy = 1000;
 
 // A task that builds the blacklist on a background thread.
 scoped_ptr<URLBlacklist> BuildBlacklist(
     scoped_ptr<base::ListValue> block,
     scoped_ptr<base::ListValue> allow,
     URLBlacklist::SegmentURLCallback segment_url) {
   scoped_ptr<URLBlacklist> blacklist(new URLBlacklist(segment_url));
   blacklist->Block(block.get());
   blacklist->Allow(allow.get());
-  return blacklist.Pass();
+  return blacklist;
 }
 
 // Tokenise the parameter |query| and add appropriate query element matcher
 // conditions to the |query_conditions|.
 void ProcessQueryToConditions(
     url_matcher::URLMatcherConditionFactory* condition_factory,
     const std::string& query,
     bool allow,
     std::set<URLQueryElementMatcherCondition>* query_conditions) {
   url::Component query_left = url::MakeRange(0, query.length());
@@ skipping 273 matching lines @@
   if (!scheme.empty())
     scheme_filter.reset(new URLMatcherSchemeFilter(scheme));
 
   scoped_ptr<URLMatcherPortFilter> port_filter;
   if (port != 0) {
     std::vector<URLMatcherPortFilter::Range> ranges;
     ranges.push_back(URLMatcherPortFilter::CreateRange(port));
     port_filter.reset(new URLMatcherPortFilter(ranges));
   }
 
-  return new URLMatcherConditionSet(id,
-                                    conditions,
-                                    query_conditions,
-                                    scheme_filter.Pass(),
-                                    port_filter.Pass());
+  return new URLMatcherConditionSet(id, conditions, query_conditions,
+                                    std::move(scheme_filter),
+                                    std::move(port_filter));
 }
 
 // static
 bool URLBlacklist::FilterTakesPrecedence(const FilterComponents& lhs,
                                          const FilterComponents& rhs) {
   // The "*" wildcard is the lowest priority filter.
   if (rhs.IsBlacklistWildcard())
     return true;
 
   if (lhs.match_subdomains && !rhs.match_subdomains)
@@ skipping 99 matching lines @@
       base::Bind(&BuildBlacklist,
                  base::Passed(&block),
                  base::Passed(&allow),
                  segment_url_),
       base::Bind(&URLBlacklistManager::SetBlacklist,
                  io_weak_ptr_factory_.GetWeakPtr()));
 }
 
 void URLBlacklistManager::SetBlacklist(scoped_ptr<URLBlacklist> blacklist) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
-  blacklist_ = blacklist.Pass();
+  blacklist_ = std::move(blacklist);
 }
 
 bool URLBlacklistManager::IsURLBlocked(const GURL& url) const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   return blacklist_->IsURLBlocked(url);
 }
 
 bool URLBlacklistManager::ShouldBlockRequestForFrame(const GURL& url,
                                                      int* reason) const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   bool block = false;
   if (override_blacklist_.Run(url, &block, reason))
     return block;
 
   *reason = net::ERR_BLOCKED_BY_ADMINISTRATOR;
   return IsURLBlocked(url);
 }
 
 // static
 void URLBlacklistManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(policy_prefs::kUrlBlacklist);
   registry->RegisterListPref(policy_prefs::kUrlWhitelist);
 }
 
 }  // namespace policy