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

chromeos/network/onc/onc_merger.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_merger.h"
 
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/values.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "components/onc/onc_constants.h"
 
 namespace chromeos {
 namespace onc {
@@ skipping 51 matching lines @@
        it.Advance()) {
     const base::DictionaryValue* child_policy = NULL;
     if (it.key() == ::onc::kRecommended ||
         !it.value().GetAsDictionary(&child_policy)) {
       continue;
     }
 
     result_editable->SetWithoutPathExpansion(
         it.key(), GetEditableFlags(*child_policy).release());
   }
-  return result_editable.Pass();
+  return result_editable;
 }
 
 // This is the base class for merging a list of DictionaryValues in
 // parallel. See MergeDictionaries function.
 class MergeListOfDictionaries {
  public:
   typedef std::vector<const base::DictionaryValue*> DictPtrs;
 
   MergeListOfDictionaries() {
   }
@@ skipping 25 matching lines @@
           DictPtrs nested_dicts;
           for (DictPtrs::const_iterator it_inner = dicts.begin();
                it_inner != dicts.end(); ++it_inner) {
             const base::DictionaryValue* nested_dict = NULL;
             if (*it_inner)
               (*it_inner)->GetDictionaryWithoutPathExpansion(key, &nested_dict);
             nested_dicts.push_back(nested_dict);
           }
           DictionaryPtr merged_dict(MergeNestedDictionaries(key, nested_dicts));
           if (!merged_dict->empty())
-            merged_value = merged_dict.Pass();
+            merged_value = std::move(merged_dict);
         } else {
           std::vector<const base::Value*> values;
           for (DictPtrs::const_iterator it_inner = dicts.begin();
                it_inner != dicts.end(); ++it_inner) {
             const base::Value* value = NULL;
             if (*it_inner)
               (*it_inner)->GetWithoutPathExpansion(key, &value);
             values.push_back(value);
           }
           merged_value = MergeListOfValues(key, values);
         }
 
         if (merged_value)
           result->SetWithoutPathExpansion(key, merged_value.release());
       }
     }
-    return result.Pass();
+    return result;
   }
 
  protected:
   // This function is called by MergeDictionaries for each list of values that
   // are located at the same path in each of the dictionaries. The order of the
   // values is the same as of the given dictionaries |dicts|. If a dictionary
   // doesn't contain a path then it's value is NULL.
   virtual scoped_ptr<base::Value> MergeListOfValues(
       const std::string& key,
       const std::vector<const base::Value*>& values) = 0;
@@ skipping 236 matching lines @@
         MergeToEffective::MergeValues(key, values, &which_effective);
 
     if (IsReadOnlyField(*signature_, key)) {
       // Don't augment read-only fields (GUID and Type).
       if (effective_value) {
         // DCHECK that all provided fields are identical.
         DCHECK(AllPresentValuesEqual(values, *effective_value))
             << "Values do not match: " << key
             << " Effective: " << *effective_value;
         // Return the un-augmented field.
-        return effective_value.Pass();
+        return effective_value;
       }
       if (values.active_setting) {
         // Unmanaged networks have assigned (active) values.
         return make_scoped_ptr(values.active_setting->DeepCopy());
       }
       LOG(ERROR) << "Field has no effective value: " << key;
       return nullptr;
     }
 
     scoped_ptr<base::DictionaryValue> augmented_value(
@@ skipping 36 matching lines @@
     if (HasUserPolicy() && values.user_editable) {
       augmented_value->SetBooleanWithoutPathExpansion(
           ::onc::kAugmentationUserEditable, true);
     }
     if (HasDevicePolicy() && values.device_editable) {
       augmented_value->SetBooleanWithoutPathExpansion(
           ::onc::kAugmentationDeviceEditable, true);
     }
     if (augmented_value->empty())
       augmented_value.reset();
-    return augmented_value.Pass();
+    return std::move(augmented_value);
   }
 
   // MergeListOfDictionaries override.
   DictionaryPtr MergeNestedDictionaries(const std::string& key,
                                         const DictPtrs& dicts) override {
     DictionaryPtr result;
     if (signature_) {
       const OncValueSignature* enclosing_signature = signature_;
       signature_ = NULL;
 
       const OncFieldSignature* field =
           GetFieldSignature(*enclosing_signature, key);
       if (field)
         signature_ = field->value_signature;
       result = MergeToEffective::MergeNestedDictionaries(key, dicts);
 
       signature_ = enclosing_signature;
     } else {
       result = MergeToEffective::MergeNestedDictionaries(key, dicts);
     }
-    return result.Pass();
+    return result;
   }
 
  private:
   const OncValueSignature* signature_;
   DISALLOW_COPY_AND_ASSIGN(MergeToAugmented);
 };
 
 }  // namespace
 
 DictionaryPtr MergeSettingsAndPoliciesToEffective(
@@ skipping 14 matching lines @@
     const base::DictionaryValue* shared_settings,
     const base::DictionaryValue* active_settings) {
   MergeToAugmented merger;
   return merger.MergeDictionaries(
       signature, user_policy, device_policy, user_settings, shared_settings,
       active_settings);
 }
 
 }  // namespace onc
 }  // namespace chromeos