Convert Pass()→std::move() in //content/browser

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"
-#include "content/browser/tracing/background_tracing_config_impl.h"
 #include "content/browser/tracing/background_tracing_rule.h"
 
 namespace content {
 
 namespace {
 
 const char kConfigsKey[] = "configs";
 
 const char kConfigModeKey[] = "mode";
 const char kConfigModePreemptive[] = "PREEMPTIVE_TRACING_MODE";
@@ skipping 86 matching lines @@
     case BackgroundTracingConfigImpl::REACTIVE:
       dict->SetString(kConfigModeKey, kConfigModeReactive);
       break;
   }
 
   scoped_ptr<base::ListValue> configs_list(new base::ListValue());
   for (const auto& it : rules_) {
     scoped_ptr<base::DictionaryValue> config_dict(new base::DictionaryValue());
     DCHECK(it);
     it->IntoDict(config_dict.get());
-    configs_list->Append(config_dict.Pass());
+    configs_list->Append(std::move(config_dict));
   }
 
-  dict->Set(kConfigsKey, configs_list.Pass());
+  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 =
       BackgroundTracingRule::PreemptiveRuleFromDict(dict);
   if (rule)
-    rules_.push_back(rule.Pass());
+    rules_.push_back(std::move(rule));
 }
 
 void BackgroundTracingConfigImpl::AddReactiveRule(
     const base::DictionaryValue* dict,
     BackgroundTracingConfigImpl::CategoryPreset category_preset) {
   scoped_ptr<BackgroundTracingRule> rule =
       BackgroundTracingRule::ReactiveRuleFromDict(dict, category_preset);
   if (rule)
-    rules_.push_back(rule.Pass());
+    rules_.push_back(std::move(rule));
 }
 
 scoped_ptr<BackgroundTracingConfigImpl> BackgroundTracingConfigImpl::FromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
   std::string mode;
   if (!dict->GetString(kConfigModeKey, &mode))
     return nullptr;
 
   scoped_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.Pass();
+  return config;
 }
 
 scoped_ptr<BackgroundTracingConfigImpl>
 BackgroundTracingConfigImpl::PreemptiveFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
   scoped_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfigImpl::PREEMPTIVE));
 
@@ skipping 13 matching lines @@
     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.Pass();
+  return config;
 }
 
 scoped_ptr<BackgroundTracingConfigImpl>
 BackgroundTracingConfigImpl::ReactiveFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
   scoped_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfigImpl::REACTIVE));
 
@@ skipping 13 matching lines @@
     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.Pass();
+  return config;
 }
 
 }  // namspace content