Remove SetWithoutPathExpansion

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>
@@ skipping 58 matching lines @@
 
   // Recurse into nested dictionaries.
   for (base::DictionaryValue::Iterator it(policy); !it.IsAtEnd();
        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());
+    result_editable->SetWithoutPathExpansion(it.key(),
+                                             GetEditableFlags(*child_policy));
   }
   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;
 
@@ skipping 41 matching lines @@
                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());
+          result->SetWithoutPathExpansion(key, std::move(merged_value));
       }
     }
     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.
@@ skipping 255 matching lines @@
       }
       LOG(ERROR) << "Field has no effective value: " << key;
       return nullptr;
     }
 
     std::unique_ptr<base::DictionaryValue> augmented_value(
         new base::DictionaryValue);
 
     if (values.active_setting) {
       augmented_value->SetWithoutPathExpansion(
-          ::onc::kAugmentationActiveSetting, values.active_setting->DeepCopy());
+          ::onc::kAugmentationActiveSetting,
+          values.active_setting->CreateDeepCopy());
     }
 
     if (!which_effective.empty()) {
       augmented_value->SetStringWithoutPathExpansion(
           ::onc::kAugmentationEffectiveSetting, which_effective);
     }
 
     // Prevent credentials from being forwarded in cleartext to
     // UI. User/shared credentials are not stored separately, so they cannot
     // leak here.
     bool is_credential = onc::FieldIsCredential(*signature_, key);
     if (!is_credential) {
       if (values.user_policy) {
         augmented_value->SetWithoutPathExpansion(
-            ::onc::kAugmentationUserPolicy, values.user_policy->DeepCopy());
+            ::onc::kAugmentationUserPolicy,
+            values.user_policy->CreateDeepCopy());
       }
       if (values.device_policy) {
         augmented_value->SetWithoutPathExpansion(
             ::onc::kAugmentationDevicePolicy,
-            values.device_policy->DeepCopy());
+            values.device_policy->CreateDeepCopy());
       }
     }
     if (values.user_setting) {
       augmented_value->SetWithoutPathExpansion(
-          ::onc::kAugmentationUserSetting, values.user_setting->DeepCopy());
+          ::onc::kAugmentationUserSetting,
+          values.user_setting->CreateDeepCopy());
     }
     if (values.shared_setting) {
       augmented_value->SetWithoutPathExpansion(
           ::onc::kAugmentationSharedSetting,
-          values.shared_setting->DeepCopy());
+          values.shared_setting->CreateDeepCopy());
     }
     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())
@@ skipping 47 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