Convert Pass()→std::move() in //chromeos

chromeos/network/onc/onc_validator.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 "chromeos/network/onc/onc_validator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 78 matching lines @@
                << "', but type '" << ValueTypeToString(signature.onc_type)
                << "' is required.";
     error_or_warning_found_ = *error = true;
     return scoped_ptr<base::Value>();
   }
 
   scoped_ptr<base::Value> repaired =
       Mapper::MapValue(signature, onc_value, error);
   if (repaired)
     CHECK_EQ(repaired->GetType(), signature.onc_type);
-  return repaired.Pass();
+  return repaired;
 }
 
 scoped_ptr<base::DictionaryValue> Validator::MapObject(
     const OncValueSignature& signature,
     const base::DictionaryValue& onc_object,
     bool* error) {
   scoped_ptr<base::DictionaryValue> repaired(new base::DictionaryValue);
 
   bool valid = ValidateObjectDefault(signature, onc_object, repaired.get());
   if (valid) {
@@ skipping 28 matching lines @@
     } else if (&signature == &kProxyLocationSignature) {
       valid = ValidateProxyLocation(repaired.get());
     } else if (&signature == &kEAPSignature) {
       valid = ValidateEAP(repaired.get());
     } else if (&signature == &kCertificateSignature) {
       valid = ValidateCertificate(repaired.get());
     }
   }
 
   if (valid) {
-    return repaired.Pass();
+    return repaired;
   } else {
     DCHECK(error_or_warning_found_);
     error_or_warning_found_ = *error = true;
     return scoped_ptr<base::DictionaryValue>();
   }
 }
 
 scoped_ptr<base::Value> Validator::MapField(
     const std::string& field_name,
     const OncValueSignature& object_signature,
@@ skipping 11 matching lines @@
   if (current_field_unknown) {
     error_or_warning_found_ = *found_unknown_field = true;
     std::string message = MessageHeader() + "Field name '" + field_name +
         "' is unknown.";
     if (error_on_unknown_field_)
       LOG(ERROR) << message;
     else
       LOG(WARNING) << message;
   }
 
-  return result.Pass();
+  return result;
 }
 
 scoped_ptr<base::ListValue> Validator::MapArray(
     const OncValueSignature& array_signature,
     const base::ListValue& onc_array,
     bool* nested_error) {
   bool nested_error_in_current_array = false;
   scoped_ptr<base::ListValue> result = Mapper::MapArray(
       array_signature, onc_array, &nested_error_in_current_array);
 
   // Drop individual networks and certificates instead of rejecting all of
   // the configuration.
   if (nested_error_in_current_array &&
       &array_signature != &kNetworkConfigurationListSignature &&
       &array_signature != &kCertificateListSignature) {
     *nested_error = nested_error_in_current_array;
   }
-  return result.Pass();
+  return result;
 }
 
 scoped_ptr<base::Value> Validator::MapEntry(int index,
                                             const OncValueSignature& signature,
                                             const base::Value& onc_value,
                                             bool* error) {
   std::string str = base::IntToString(index);
   path_.push_back(str);
   scoped_ptr<base::Value> result =
       Mapper::MapEntry(index, signature, onc_value, error);
   DCHECK_EQ(str, path_.back());
   path_.pop_back();
-  return result.Pass();
+  return result;
 }
 
 bool Validator::ValidateObjectDefault(const OncValueSignature& signature,
                                       const base::DictionaryValue& onc_object,
                                       base::DictionaryValue* result) {
   bool found_unknown_field = false;
   bool nested_error_occured = false;
   MapFields(signature, onc_object, &found_unknown_field, &nested_error_occured,
             result);
 
@@ skipping 808 matching lines @@
 }
 
 std::string Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : base::JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos