Remove raw DictionaryValue::Set in //components

components/flags_ui/flags_state.cc

 // Copyright 2015 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/flags_ui/flags_state.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/flags_ui/feature_entry.h"
 #include "components/flags_ui/flags_storage.h"
 #include "components/flags_ui/flags_ui_switches.h"
@@ skipping 144 matching lines @@
         if (enabled_entries.count(entry.NameForOption(i)) > 0)
           return false;
       }
       return true;
   }
   NOTREACHED();
   return true;
 }
 
 // Returns the Value representing the choice data in the specified entry.
-base::Value* CreateOptionsData(const FeatureEntry& entry,
-                               const std::set<std::string>& enabled_entries) {
+std::unique_ptr<base::Value> CreateOptionsData(
+    const FeatureEntry& entry,
+    const std::set<std::string>& enabled_entries) {
   DCHECK(entry.type == FeatureEntry::MULTI_VALUE ||
          entry.type == FeatureEntry::ENABLE_DISABLE_VALUE ||
          entry.type == FeatureEntry::FEATURE_VALUE ||
          entry.type == FeatureEntry::FEATURE_WITH_PARAMS_VALUE);
-  base::ListValue* result = new base::ListValue;
+  auto result = base::MakeUnique<base::ListValue>();
   for (int i = 0; i < entry.num_options; ++i) {
-    std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+    auto value = base::MakeUnique<base::DictionaryValue>();
     const std::string name = entry.NameForOption(i);
     value->SetString("internal_name", name);
     value->SetString("description", entry.DescriptionForOption(i));
     value->SetBoolean("selected", enabled_entries.count(name) > 0);
     result->Append(std::move(value));
   }
-  return result;
+  return std::move(result);
 }
 
 // Registers variation parameters specified by |feature_variation_params| for
 // the field trial named |feature_trial_name|, unless a group for this trial has
 // already been created (e.g. via command-line switches that take precedence
 // over about:flags). In the trial, the function creates a new constant group
 // called |kTrialGroupAboutFlags|.
 base::FieldTrial* RegisterFeatureVariationParameters(
     const std::string& feature_trial_name,
     const std::map<std::string, std::string>& feature_variation_params) {
@@ skipping 304 matching lines @@
     const FeatureEntry& entry = feature_entries_[i];
     if (skip_feature_entry.Run(entry))
       continue;
 
     std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
     data->SetString("internal_name", entry.internal_name);
     data->SetString("name", base::StringPiece(entry.visible_name));
     data->SetString("description",
                     base::StringPiece(entry.visible_description));
 
-    base::ListValue* supported_platforms = new base::ListValue();
-    AddOsStrings(entry.supported_platforms, supported_platforms);
-    data->Set("supported_platforms", supported_platforms);
+    auto supported_platforms = base::MakeUnique<base::ListValue>();
+    AddOsStrings(entry.supported_platforms, supported_platforms.get());
+    data->Set("supported_platforms", std::move(supported_platforms));
     // True if the switch is not currently passed.
     bool is_default_value = IsDefaultValue(entry, enabled_entries);
     data->SetBoolean("is_default", is_default_value);
 
     switch (entry.type) {
       case FeatureEntry::SINGLE_VALUE:
       case FeatureEntry::SINGLE_DISABLE_VALUE:
         data->SetBoolean(
             "enabled",
             (!is_default_value && entry.type == FeatureEntry::SINGLE_VALUE) ||
@@ skipping 264 matching lines @@
                               state == FeatureEntry::FeatureState::ENABLED,
                               name_to_switch_map);
           }
         }
         break;
     }
   }
 }
 
 }  // namespace flags_ui