Background tracing: Tracing scenarios can now enable/disable Blink features, for A/B testing purpos…

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 "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";
 const char kConfigModeReactive[] = "REACTIVE_TRACING_MODE";
 
+const char kConfigScenarioName[] = "scenario_name";
+const char kConfigEnableBlinkFeatures[] = "enable_blink_features";
+const char kConfigDisableBlinkFeatures[] = "disable_blink_features";
+
 const char kConfigCategoryKey[] = "category";
 const char kConfigCategoryBenchmark[] = "BENCHMARK";
 const char kConfigCategoryBenchmarkDeep[] = "BENCHMARK_DEEP";
 const char kConfigCategoryBenchmarkGPU[] = "BENCHMARK_GPU";
 const char kConfigCategoryBenchmarkIPC[] = "BENCHMARK_IPC";
 const char kConfigCategoryBenchmarkStartup[] = "BENCHMARK_STARTUP";
 
 }  // namespace
 
 BackgroundTracingConfigImpl::BackgroundTracingConfigImpl(
@@ skipping 66 matching lines @@
 
   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());
   }
 
   dict->Set(kConfigsKey, configs_list.Pass());
+
+  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());
 }
 
@@ skipping 17 matching lines @@
   scoped_ptr<BackgroundTracingConfigImpl> config;
 
   if (mode == kConfigModePreemptive) {
     config = PreemptiveFromDict(dict);
   } else if (mode == kConfigModeReactive) {
     config = ReactiveFromDict(dict);
   } else {
     return nullptr;
   }
 
+  dict->GetString(kConfigScenarioName, &config->scenario_name_);
+  dict->GetString(kConfigEnableBlinkFeatures, &config->enable_blink_features_);
+  dict->GetString(kConfigDisableBlinkFeatures,
+                  &config->disable_blink_features_);
+
   return config.Pass();
 }
 
 scoped_ptr<BackgroundTracingConfigImpl>
 BackgroundTracingConfigImpl::PreemptiveFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
   scoped_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfigImpl::PREEMPTIVE));
@@ skipping 52 matching lines @@
     config->AddReactiveRule(config_dict, new_category_preset);
   }
 
   if (config->rules().empty())
     return nullptr;
 
   return config.Pass();
 }
 
 }  // namspace content