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

components/policy/core/browser/configuration_policy_handler.cc

 // Copyright (c) 2012 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/configuration_policy_handler.h"
 
 #include <stddef.h>
-
 #include <algorithm>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/prefs/pref_value_map.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "components/policy/core/browser/policy_error_map.h"
@@ skipping 124 matching lines @@
 
   if (output)
     *output = value;
   return true;
 }
 
 
 // StringMappingListPolicyHandler implementation -----------------------------
 
 StringMappingListPolicyHandler::MappingEntry::MappingEntry(
-    const char* policy_value, scoped_ptr<base::Value> map)
-    : enum_value(policy_value), mapped_value(map.Pass()) {}
+    const char* policy_value,
+    scoped_ptr<base::Value> map)
+    : enum_value(policy_value), mapped_value(std::move(map)) {}
 
 StringMappingListPolicyHandler::MappingEntry::~MappingEntry() {}
 
 StringMappingListPolicyHandler::StringMappingListPolicyHandler(
     const char* policy_name,
     const char* pref_path,
     const GenerateMapCallback& callback)
     : TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST),
       pref_path_(pref_path),
       map_getter_(callback) {}
 
 StringMappingListPolicyHandler::~StringMappingListPolicyHandler() {}
 
 bool StringMappingListPolicyHandler::CheckPolicySettings(
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
   const base::Value* value;
   return CheckAndGetValue(policies, errors, &value) &&
       Convert(value, NULL, errors);
 }
 
 void StringMappingListPolicyHandler::ApplyPolicySettings(
     const PolicyMap& policies,
     PrefValueMap* prefs) {
   if (!pref_path_)
     return;
   const base::Value* value = policies.GetValue(policy_name());
   scoped_ptr<base::ListValue> list(new base::ListValue());
   if (value && Convert(value, list.get(), NULL))
-    prefs->SetValue(pref_path_, list.Pass());
+    prefs->SetValue(pref_path_, std::move(list));
 }
 
 bool StringMappingListPolicyHandler::Convert(const base::Value* input,
                                              base::ListValue* output,
                                              PolicyErrorMap* errors) {
   if (!input)
     return true;
 
   const base::ListValue* list_value = NULL;
   if (!input->GetAsList(&list_value)) {
@@ skipping 38 matching lines @@
 
   scoped_ptr<base::Value> return_value;
   for (ScopedVector<MappingEntry>::const_iterator it = map_.begin();
        it != map_.end(); ++it) {
     const MappingEntry* mapping_entry = *it;
     if (mapping_entry->enum_value == entry_value) {
       return_value = make_scoped_ptr(mapping_entry->mapped_value->DeepCopy());
       break;
     }
   }
-  return return_value.Pass();
+  return return_value;
 }
 
 // IntRangePolicyHandler implementation ----------------------------------------
 
 IntRangePolicyHandler::IntRangePolicyHandler(const char* policy_name,
                                              const char* pref_path,
                                              int min,
                                              int max,
                                              bool clamp)
     : IntRangePolicyHandlerBase(policy_name, min, max, clamp),
@@ skipping 174 matching lines @@
 
 // LegacyPoliciesDeprecatingPolicyHandler implementation -----------------------
 
 // TODO(binjin): Add a new common base class for SchemaValidatingPolicyHandler
 // and TypeCheckingPolicyHandler representing policy handlers for a single
 // policy, and use it as the type of |new_policy_handler|.
 // http://crbug.com/345299
 LegacyPoliciesDeprecatingPolicyHandler::LegacyPoliciesDeprecatingPolicyHandler(
     ScopedVector<ConfigurationPolicyHandler> legacy_policy_handlers,
     scoped_ptr<SchemaValidatingPolicyHandler> new_policy_handler)
-    : legacy_policy_handlers_(legacy_policy_handlers.Pass()),
-      new_policy_handler_(new_policy_handler.Pass()) {
-}
+    : legacy_policy_handlers_(std::move(legacy_policy_handlers)),
+      new_policy_handler_(std::move(new_policy_handler)) {}
 
 LegacyPoliciesDeprecatingPolicyHandler::
     ~LegacyPoliciesDeprecatingPolicyHandler() {
 }
 
 bool LegacyPoliciesDeprecatingPolicyHandler::CheckPolicySettings(
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
   if (policies.Get(new_policy_handler_->policy_name())) {
     return new_policy_handler_->CheckPolicySettings(policies, errors);
@@ skipping 32 matching lines @@
     }
   }
 }
 void LegacyPoliciesDeprecatingPolicyHandler::ApplyPolicySettings(
     const policy::PolicyMap& /* policies */,
     PrefValueMap* /* prefs */) {
   NOTREACHED();
 }
 
 }  // namespace policy