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

content/browser/tracing/background_tracing_rule.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_rule.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/statistics_recorder.h"
@@ skipping 74 matching lines @@
 }
 
 namespace {
 
 class NamedTriggerRule : public BackgroundTracingRule {
  private:
   NamedTriggerRule(const std::string& named_event)
       : named_event_(named_event) {}
 
  public:
-  static scoped_ptr<BackgroundTracingRule> Create(
+  static std::unique_ptr<BackgroundTracingRule> Create(
       const base::DictionaryValue* dict) {
     std::string trigger_name;
     if (!dict->GetString(kConfigRuleTriggerNameKey, &trigger_name))
       return nullptr;
 
-    return scoped_ptr<BackgroundTracingRule>(
+    return std::unique_ptr<BackgroundTracingRule>(
         new NamedTriggerRule(trigger_name));
   }
 
   void IntoDict(base::DictionaryValue* dict) const override {
     DCHECK(dict);
     BackgroundTracingRule::IntoDict(dict);
     dict->SetString(kConfigRuleKey, kPreemptiveConfigRuleMonitorNamed);
     dict->SetString(kConfigRuleTriggerNameKey, named_event_.c_str());
   }
 
@@ skipping 13 matching lines @@
                 int histogram_upper_value,
                 bool repeat,
                 int trigger_delay)
       : histogram_name_(histogram_name),
         histogram_lower_value_(histogram_lower_value),
         histogram_upper_value_(histogram_upper_value),
         repeat_(repeat),
         trigger_delay_(trigger_delay) {}
 
  public:
-  static scoped_ptr<BackgroundTracingRule> Create(
+  static std::unique_ptr<BackgroundTracingRule> Create(
       const base::DictionaryValue* dict) {
     std::string histogram_name;
     if (!dict->GetString(kConfigRuleHistogramNameKey, &histogram_name))
       return nullptr;
 
     // Optional parameter, so we don't need to check if the key exists.
     bool repeat = true;
     dict->GetBoolean(kConfigRuleHistogramRepeatKey, &repeat);
 
     int histogram_lower_value;
     int histogram_upper_value = std::numeric_limits<int>::max();
 
     if (!dict->GetInteger(kConfigRuleHistogramValue1Key,
                           &histogram_lower_value)) {
       // Check for the old naming.
       if (!dict->GetInteger(kConfigRuleHistogramValueOldKey,
                             &histogram_lower_value))
         return nullptr;
     }
 
     dict->GetInteger(kConfigRuleHistogramValue2Key, &histogram_upper_value);
 
     if (histogram_lower_value >= histogram_upper_value)
       return nullptr;
 
     int trigger_delay = -1;
     dict->GetInteger(kConfigRuleTriggerDelay, &trigger_delay);
 
-    return scoped_ptr<BackgroundTracingRule>(
+    return std::unique_ptr<BackgroundTracingRule>(
         new HistogramRule(histogram_name, histogram_lower_value,
                           histogram_upper_value, repeat, trigger_delay));
   }
 
   ~HistogramRule() override {
     base::StatisticsRecorder::ClearCallback(histogram_name_);
     TracingControllerImpl::GetInstance()->RemoveTraceMessageFilterObserver(
         this);
   }
 
@@ skipping 81 matching lines @@
 };
 
 class ReactiveTraceForNSOrTriggerOrFullRule : public BackgroundTracingRule {
  private:
   ReactiveTraceForNSOrTriggerOrFullRule(
       const std::string& named_event,
       BackgroundTracingConfigImpl::CategoryPreset category_preset)
       : named_event_(named_event), category_preset_(category_preset) {}
 
  public:
-  static scoped_ptr<BackgroundTracingRule> Create(
+  static std::unique_ptr<BackgroundTracingRule> Create(
       const base::DictionaryValue* dict,
       BackgroundTracingConfigImpl::CategoryPreset category_preset) {
     std::string trigger_name;
     if (!dict->GetString(kConfigRuleTriggerNameKey, &trigger_name))
       return nullptr;
 
-    return scoped_ptr<BackgroundTracingRule>(
+    return std::unique_ptr<BackgroundTracingRule>(
         new ReactiveTraceForNSOrTriggerOrFullRule(trigger_name,
                                                   category_preset));
   }
 
   // BackgroundTracingRule implementation
   void IntoDict(base::DictionaryValue* dict) const override {
     DCHECK(dict);
     BackgroundTracingRule::IntoDict(dict);
     dict->SetString(
         kConfigCategoryKey,
@@ skipping 27 matching lines @@
       BackgroundTracingConfigImpl::CategoryPreset category_preset,
       int timeout_min,
       int timeout_max)
       : category_preset_(category_preset),
         timeout_min_(timeout_min),
         timeout_max_(timeout_max) {
     named_event_ = GenerateUniqueName();
   }
 
  public:
-  static scoped_ptr<BackgroundTracingRule> Create(
+  static std::unique_ptr<BackgroundTracingRule> Create(
       const base::DictionaryValue* dict,
       BackgroundTracingConfigImpl::CategoryPreset category_preset) {
     int timeout_min;
     if (!dict->GetInteger(kConfigRuleRandomIntervalTimeoutMin, &timeout_min))
       return nullptr;
 
     int timeout_max;
     if (!dict->GetInteger(kConfigRuleRandomIntervalTimeoutMax, &timeout_max))
       return nullptr;
 
     if (timeout_min > timeout_max)
       return nullptr;
 
-    return scoped_ptr<BackgroundTracingRule>(
+    return std::unique_ptr<BackgroundTracingRule>(
         new ReactiveTraceAtRandomIntervalsRule(category_preset, timeout_min,
                                                timeout_max));
   }
   ~ReactiveTraceAtRandomIntervalsRule() override {}
 
   void IntoDict(base::DictionaryValue* dict) const override {
     DCHECK(dict);
     BackgroundTracingRule::IntoDict(dict);
     dict->SetString(
         kConfigCategoryKey,
@@ skipping 58 matching lines @@
   std::string named_event_;
   base::OneShotTimer trigger_timer_;
   BackgroundTracingConfigImpl::CategoryPreset category_preset_;
   BackgroundTracingManagerImpl::TriggerHandle handle_;
   int timeout_min_;
   int timeout_max_;
 };
 
 }  // namespace
 
-scoped_ptr<BackgroundTracingRule> BackgroundTracingRule::PreemptiveRuleFromDict(
+std::unique_ptr<BackgroundTracingRule>
+BackgroundTracingRule::PreemptiveRuleFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
   std::string type;
   if (!dict->GetString(kConfigRuleKey, &type))
     return nullptr;
 
-  scoped_ptr<BackgroundTracingRule> tracing_rule;
+  std::unique_ptr<BackgroundTracingRule> tracing_rule;
   if (type == kPreemptiveConfigRuleMonitorNamed)
     tracing_rule = NamedTriggerRule::Create(dict);
   else if (type == kPreemptiveConfigRuleMonitorHistogram)
     tracing_rule = HistogramRule::Create(dict);
 
   if (tracing_rule)
     tracing_rule->Setup(dict);
 
   return tracing_rule;
 }
 
-scoped_ptr<BackgroundTracingRule> BackgroundTracingRule::ReactiveRuleFromDict(
+std::unique_ptr<BackgroundTracingRule>
+BackgroundTracingRule::ReactiveRuleFromDict(
     const base::DictionaryValue* dict,
     BackgroundTracingConfigImpl::CategoryPreset category_preset) {
   DCHECK(dict);
 
   std::string type;
   if (!dict->GetString(kConfigRuleKey, &type))
     return nullptr;
 
-  scoped_ptr<BackgroundTracingRule> tracing_rule;
+  std::unique_ptr<BackgroundTracingRule> tracing_rule;
 
   if (type == kReactiveConfigRuleTraceOnNavigationUntilTriggerOrFull) {
     tracing_rule =
         ReactiveTraceForNSOrTriggerOrFullRule::Create(dict, category_preset);
   } else if (type == kReactiveConfigRuleTraceAtRandomIntervals) {
     tracing_rule =
         ReactiveTraceAtRandomIntervalsRule::Create(dict, category_preset);
   }
 
   if (tracing_rule)
     tracing_rule->Setup(dict);
 
   return tracing_rule;
 }
 
 }  // namespace content