Remove raw base::DictionaryValue::SetWithoutPathExpansion

chromeos/network/onc/onc_translator_shill_to_onc.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 <string>
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translation_tables.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/shill_property_util.h"
@@ skipping 183 matching lines @@
     TranslateAndAddNestedObject(::onc::openvpn::kVerifyX509);
 
   // Shill supports only one RemoteCertKU but ONC requires a list. If existing,
   // wraps the value into a list.
   std::string certKU;
   if (shill_dictionary_->GetStringWithoutPathExpansion(
           shill::kOpenVPNRemoteCertKUProperty, &certKU)) {
     std::unique_ptr<base::ListValue> certKUs(new base::ListValue);
     certKUs->AppendString(certKU);
     onc_object_->SetWithoutPathExpansion(::onc::openvpn::kRemoteCertKU,
-                                         certKUs.release());
+                                         std::move(certKUs));
   }
 
   for (const OncFieldSignature* field_signature = onc_signature_->fields;
        field_signature->onc_field_name != NULL; ++field_signature) {
     const std::string& onc_field_name = field_signature->onc_field_name;
     if (onc_field_name == ::onc::openvpn::kRemoteCertKU ||
         onc_field_name == ::onc::openvpn::kServerCAPEMs) {
       CopyProperty(field_signature);
       continue;
     }
@@ skipping 17 matching lines @@
           shill_str, field_signature->value_signature->onc_type);
 
       if (translated.get() == NULL) {
         LOG(ERROR) << "Shill property '" << shill_property_name
                    << "' with value " << *shill_value
                    << " couldn't be converted to base::Value::Type "
                    << field_signature->value_signature->onc_type << ": "
                    << GetName();
       } else {
         onc_object_->SetWithoutPathExpansion(onc_field_name,
-                                             translated.release());
+                                             std::move(translated));
       }
     } else {
       LOG(ERROR) << "Shill property '" << shill_property_name << "' has value "
                  << *shill_value << ", but expected a string: " << GetName();
     }
   }
 }
 
 void ShillToONCTranslator::TranslateIPsec() {
   CopyPropertiesAccordingToSignature();
@@ skipping 318 matching lines @@
   if (shill_dictionary_->GetStringWithoutPathExpansion(
           shill::kProxyConfigProperty, &proxy_config_str) &&
       !proxy_config_str.empty()) {
     std::unique_ptr<base::DictionaryValue> proxy_config_value(
         ReadDictionaryFromJson(proxy_config_str));
     if (proxy_config_value) {
       std::unique_ptr<base::DictionaryValue> proxy_settings =
           ConvertProxyConfigToOncProxySettings(std::move(proxy_config_value));
       if (proxy_settings) {
         onc_object_->SetWithoutPathExpansion(
-            ::onc::network_config::kProxySettings, proxy_settings.release());
+            ::onc::network_config::kProxySettings, std::move(proxy_settings));
       }
     }
   }
 }
 
 void ShillToONCTranslator::TranslateIPConfig() {
   CopyPropertiesAccordingToSignature();
   std::string shill_ip_method;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kMethodProperty,
                                                    &shill_ip_method);
@@ skipping 59 matching lines @@
     NOTREACHED() << "Unable to find signature for field: " << onc_field_name;
     return;
   }
   ShillToONCTranslator nested_translator(dictionary, onc_source_,
                                          *field_signature->value_signature,
                                          network_state_);
   std::unique_ptr<base::DictionaryValue> nested_object =
       nested_translator.CreateTranslatedONCObject();
   if (nested_object->empty())
     return;
-  onc_object_->SetWithoutPathExpansion(onc_field_name, nested_object.release());
+  onc_object_->SetWithoutPathExpansion(onc_field_name,
+                                       std::move(nested_object));
 }
 
 void ShillToONCTranslator::SetNestedOncValue(
     const std::string& onc_dictionary_name,
     const std::string& onc_field_name,
     const base::Value& value) {
-  base::DictionaryValue* nested;
+  base::DictionaryValue* nested = nullptr;
   if (!onc_object_->GetDictionaryWithoutPathExpansion(onc_dictionary_name,
                                                       &nested)) {
-    nested = new base::DictionaryValue;
-    onc_object_->SetWithoutPathExpansion(onc_dictionary_name, nested);
+    nested = onc_object_->SetDictionaryWithoutPathExpansion(
+        onc_dictionary_name, base::MakeUnique<base::DictionaryValue>());
   }
-  nested->SetWithoutPathExpansion(onc_field_name, value.DeepCopy());
+  nested->SetWithoutPathExpansion(onc_field_name,
+                                  base::MakeUnique<base::Value>(value));
 }
 
 void ShillToONCTranslator::TranslateAndAddListOfObjects(
     const std::string& onc_field_name,
     const base::ListValue& list) {
   const OncFieldSignature* field_signature =
       GetFieldSignature(*onc_signature_, onc_field_name);
   if (field_signature->value_signature->onc_type != base::Value::Type::LIST) {
     LOG(ERROR) << "ONC Field name: '" << onc_field_name << "' has type '"
                << field_signature->value_signature->onc_type
@@ skipping 14 matching lines @@
     std::unique_ptr<base::DictionaryValue> nested_object =
         nested_translator.CreateTranslatedONCObject();
     // If the nested object couldn't be parsed, simply omit it.
     if (nested_object->empty())
       continue;
     result->Append(std::move(nested_object));
   }
   // If there are no entries in the list, there is no need to expose this field.
   if (result->empty())
     return;
-  onc_object_->SetWithoutPathExpansion(onc_field_name, result.release());
+  onc_object_->SetWithoutPathExpansion(onc_field_name, std::move(result));
 }
 
 void ShillToONCTranslator::CopyPropertiesAccordingToSignature() {
   CopyPropertiesAccordingToSignature(onc_signature_);
 }
 
 void ShillToONCTranslator::CopyPropertiesAccordingToSignature(
     const OncValueSignature* value_signature) {
   if (value_signature->base_signature)
     CopyPropertiesAccordingToSignature(value_signature->base_signature);
@@ skipping 20 matching lines @@
   if (shill_value->GetType() != field_signature->value_signature->onc_type) {
     LOG(ERROR) << "Shill property '" << shill_property_name << "' with value "
                << *shill_value << " has base::Value::Type "
                << shill_value->GetType() << " but ONC field '"
                << field_signature->onc_field_name << "' requires type "
                << field_signature->value_signature->onc_type << ": "
                << GetName();
     return;
   }
 
-  onc_object_->SetWithoutPathExpansion(field_signature->onc_field_name,
-                                       shill_value->DeepCopy());
+  onc_object_->SetWithoutPathExpansion(
+      field_signature->onc_field_name,
+      base::MakeUnique<base::Value>(*shill_value));
 }
 
 void ShillToONCTranslator::TranslateWithTableAndSet(
     const std::string& shill_property_name,
     const StringTranslationEntry table[],
     const std::string& onc_field_name) {
   std::string shill_value;
   if (!shill_dictionary_->GetStringWithoutPathExpansion(shill_property_name,
                                                         &shill_value)) {
     return;
@@ skipping 23 matching lines @@
     const NetworkState* network_state) {
   CHECK(onc_signature != NULL);
 
   ShillToONCTranslator translator(shill_dictionary, onc_source, *onc_signature,
                                   network_state);
   return translator.CreateTranslatedONCObject();
 }
 
 }  // namespace onc
 }  // namespace chromeos