Use std::unique_ptr for base::DictionaryValue and base::ListValue's internal store.

components/policy/core/common/policy_test_utils.cc

 // Copyright 2013 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/common/policy_test_utils.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 37 matching lines @@
   if (!map.empty()) {
     base::DictionaryValue dict;
     for (PolicyMap::const_iterator it = map.begin(); it != map.end(); ++it)
       dict.SetWithoutPathExpansion(it->first, it->second.value->DeepCopy());
     LOG(WARNING) << "There are pre-existing policies in this machine: " << dict;
   }
   return map.empty();
 }
 
 #if defined(OS_IOS) || defined(OS_MACOSX)
-CFPropertyListRef ValueToProperty(const base::Value* value) {
-  switch (value->GetType()) {
+CFPropertyListRef ValueToProperty(const base::Value& value) {
+  switch (value.GetType()) {
     case base::Value::TYPE_NULL:
       return kCFNull;
 
     case base::Value::TYPE_BOOLEAN: {
       bool bool_value;
-      if (value->GetAsBoolean(&bool_value))
+      if (value.GetAsBoolean(&bool_value))
         return bool_value ? kCFBooleanTrue : kCFBooleanFalse;
       break;
     }
 
     case base::Value::TYPE_INTEGER: {
       int int_value;
-      if (value->GetAsInteger(&int_value)) {
+      if (value.GetAsInteger(&int_value)) {
         return CFNumberCreate(
             kCFAllocatorDefault, kCFNumberIntType, &int_value);
       }
       break;
     }
 
     case base::Value::TYPE_DOUBLE: {
       double double_value;
-      if (value->GetAsDouble(&double_value)) {
+      if (value.GetAsDouble(&double_value)) {
         return CFNumberCreate(
             kCFAllocatorDefault, kCFNumberDoubleType, &double_value);
       }
       break;
     }
 
     case base::Value::TYPE_STRING: {
       std::string string_value;
-      if (value->GetAsString(&string_value))
+      if (value.GetAsString(&string_value))
         return base::SysUTF8ToCFStringRef(string_value);
       break;
     }
 
     case base::Value::TYPE_DICTIONARY: {
       const base::DictionaryValue* dict_value;
-      if (value->GetAsDictionary(&dict_value)) {
+      if (value.GetAsDictionary(&dict_value)) {
         // |dict| is owned by the caller.
         CFMutableDictionaryRef dict =
             CFDictionaryCreateMutable(kCFAllocatorDefault,
                                       dict_value->size(),
                                       &kCFTypeDictionaryKeyCallBacks,
                                       &kCFTypeDictionaryValueCallBacks);
         for (base::DictionaryValue::Iterator iterator(*dict_value);
              !iterator.IsAtEnd(); iterator.Advance()) {
           // CFDictionaryAddValue() retains both |key| and |value|, so make sure
           // the references are balanced.
           base::ScopedCFTypeRef<CFStringRef> key(
               base::SysUTF8ToCFStringRef(iterator.key()));
           base::ScopedCFTypeRef<CFPropertyListRef> cf_value(
-              ValueToProperty(&iterator.value()));
+              ValueToProperty(iterator.value()));
           if (cf_value)
             CFDictionaryAddValue(dict, key, cf_value);
         }
         return dict;
       }
       break;
     }
 
     case base::Value::TYPE_LIST: {
       const base::ListValue* list;
-      if (value->GetAsList(&list)) {
+      if (value.GetAsList(&list)) {
         CFMutableArrayRef array =
             CFArrayCreateMutable(NULL, list->GetSize(), &kCFTypeArrayCallBacks);
-        for (base::ListValue::const_iterator it(list->begin());
-             it != list->end(); ++it) {
-          // CFArrayAppendValue() retains |value|, so make sure the reference
+        for (const value& entry : *list) {
+          // CFArrayAppendValue() retains |cf_value|, so make sure the reference
           // created by ValueToProperty() is released.
           base::ScopedCFTypeRef<CFPropertyListRef> cf_value(
-              ValueToProperty(*it));
+              ValueToProperty(*entry));
           if (cf_value)
             CFArrayAppendValue(array, cf_value);
         }
         return array;
       }
       break;
     }
 
     case base::Value::TYPE_BINARY:
       // This type isn't converted (though it can be represented as CFData)
@@ skipping 89 matching lines @@
      << "  \"scope\": " << e.scope << "," << std::endl
      << "  \"value\": " << value
      << "}";
   return os;
 }
 
 std::ostream& operator<<(std::ostream& os, const policy::PolicyNamespace& ns) {
   os << ns.domain << "/" << ns.component_id;
   return os;
 }