Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/tracing/background_tracing_config_impl.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 "content/browser/tracing/background_tracing_config_impl.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/values.h"
@@ skipping 99 matching lines @@
     case BackgroundTracingConfigImpl::PREEMPTIVE:
       dict->SetString(kConfigModeKey, kConfigModePreemptive);
       dict->SetString(kConfigCategoryKey,
                       CategoryPresetToString(category_preset_));
       break;
     case BackgroundTracingConfigImpl::REACTIVE:
       dict->SetString(kConfigModeKey, kConfigModeReactive);
       break;
   }
 
-  scoped_ptr<base::ListValue> configs_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> configs_list(new base::ListValue());
   for (const auto& it : rules_) {
-    scoped_ptr<base::DictionaryValue> config_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> config_dict(
+        new base::DictionaryValue());
     DCHECK(it);
     it->IntoDict(config_dict.get());
     configs_list->Append(std::move(config_dict));
   }
 
   dict->Set(kConfigsKey, std::move(configs_list));
 
   if (!scenario_name_.empty())
     dict->SetString(kConfigScenarioName, scenario_name_);
   if (!enable_blink_features_.empty())
     dict->SetString(kConfigEnableBlinkFeatures, enable_blink_features_);
   if (!disable_blink_features_.empty())
     dict->SetString(kConfigDisableBlinkFeatures, disable_blink_features_);
 }
 
 void BackgroundTracingConfigImpl::AddPreemptiveRule(
     const base::DictionaryValue* dict) {
-  scoped_ptr<BackgroundTracingRule> rule =
+  std::unique_ptr<BackgroundTracingRule> rule =
       BackgroundTracingRule::PreemptiveRuleFromDict(dict);
   if (rule)
     rules_.push_back(std::move(rule));
 }
 
 void BackgroundTracingConfigImpl::AddReactiveRule(
     const base::DictionaryValue* dict,
     BackgroundTracingConfigImpl::CategoryPreset category_preset) {
-  scoped_ptr<BackgroundTracingRule> rule =
+  std::unique_ptr<BackgroundTracingRule> rule =
       BackgroundTracingRule::ReactiveRuleFromDict(dict, category_preset);
   if (rule)
     rules_.push_back(std::move(rule));
 }
 
-scoped_ptr<BackgroundTracingConfigImpl> BackgroundTracingConfigImpl::FromDict(
-    const base::DictionaryValue* dict) {
+std::unique_ptr<BackgroundTracingConfigImpl>
+BackgroundTracingConfigImpl::FromDict(const base::DictionaryValue* dict) {
   DCHECK(dict);
 
   std::string mode;
   if (!dict->GetString(kConfigModeKey, &mode))
     return nullptr;
 
-  scoped_ptr<BackgroundTracingConfigImpl> config;
+  std::unique_ptr<BackgroundTracingConfigImpl> config;
 
   if (mode == kConfigModePreemptive) {
     config = PreemptiveFromDict(dict);
   } else if (mode == kConfigModeReactive) {
     config = ReactiveFromDict(dict);
   } else {
     return nullptr;
   }
 
   if (config) {
     dict->GetString(kConfigScenarioName, &config->scenario_name_);
     dict->GetString(kConfigEnableBlinkFeatures,
                     &config->enable_blink_features_);
     dict->GetString(kConfigDisableBlinkFeatures,
                     &config->disable_blink_features_);
   }
 
   return config;
 }
 
-scoped_ptr<BackgroundTracingConfigImpl>
+std::unique_ptr<BackgroundTracingConfigImpl>
 BackgroundTracingConfigImpl::PreemptiveFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
-  scoped_ptr<BackgroundTracingConfigImpl> config(
+  std::unique_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfigImpl::PREEMPTIVE));
 
   std::string category_preset_string;
   if (!dict->GetString(kConfigCategoryKey, &category_preset_string))
     return nullptr;
 
   if (!StringToCategoryPreset(category_preset_string,
                               &config->category_preset_))
     return nullptr;
 
   const base::ListValue* configs_list = nullptr;
   if (!dict->GetList(kConfigsKey, &configs_list))
     return nullptr;
 
   for (const auto& it : *configs_list) {
     const base::DictionaryValue* config_dict = nullptr;
     if (!it->GetAsDictionary(&config_dict))
       return nullptr;
 
     config->AddPreemptiveRule(config_dict);
   }
 
   if (config->rules().empty())
     return nullptr;
 
   return config;
 }
 
-scoped_ptr<BackgroundTracingConfigImpl>
+std::unique_ptr<BackgroundTracingConfigImpl>
 BackgroundTracingConfigImpl::ReactiveFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
-  scoped_ptr<BackgroundTracingConfigImpl> config(
+  std::unique_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfigImpl::REACTIVE));
 
   const base::ListValue* configs_list = nullptr;
   if (!dict->GetList(kConfigsKey, &configs_list))
     return nullptr;
 
   for (const auto& it : *configs_list) {
     const base::DictionaryValue* config_dict = nullptr;
     if (!it->GetAsDictionary(&config_dict))
       return nullptr;
 
     std::string category_preset_string;
     if (!config_dict->GetString(kConfigCategoryKey, &category_preset_string))
       return nullptr;
 
     BackgroundTracingConfigImpl::CategoryPreset new_category_preset;
     if (!StringToCategoryPreset(category_preset_string, &new_category_preset))
       return nullptr;
 
     config->AddReactiveRule(config_dict, new_category_preset);
   }
 
   if (config->rules().empty())
     return nullptr;
 
   return config;
 }
 
 }  // namspace content