Implement Reactive Configuration in Background Tracing

content/browser/tracing/background_tracing_config_dict.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/public/browser/background_tracing_preemptive_config.h"
 #include "content/public/browser/background_tracing_reactive_config.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 kConfigCategoryKey[] = "category";
 const char kConfigCategoryBenchmark[] = "BENCHMARK";
 const char kConfigCategoryBenchmarkDeep[] = "BENCHMARK_DEEP";
 
 const char kConfigRuleKey[] = "rule";
 const char kConfigRuleTriggerNameKey[] = "trigger_name";
 
 const char kPreemptiveConfigRuleMonitorNamed[] =
     "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED";
 
-const char kReactiveConfigRuleTraceOnTriggerOr10sOrTriggerOrFull[] =
-    "TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL";
+const char kReactiveConfigRuleTraceFor10sOrTriggerOrFull[] =
+    "TRACE_FOR_10S_OR_TRIGGER_OR_FULL";
 
 std::string CategoryPresetToString(
     BackgroundTracingConfig::CategoryPreset category_preset) {
   switch (category_preset) {
     case BackgroundTracingConfig::BENCHMARK:
       return kConfigCategoryBenchmark;
     case BackgroundTracingConfig::BENCHMARK_DEEP:
       return kConfigCategoryBenchmarkDeep;
       break;
   }
@@ skipping 84 matching lines @@
     if (!config_dict->GetString(kConfigCategoryKey, &category_preset_string))
       return nullptr;
 
     if (!StringToCategoryPreset(category_preset_string, &rule.category_preset))
       return nullptr;
 
     std::string type;
     if (!config_dict->GetString(kConfigRuleKey, &type))
       return nullptr;
 
-    if (type != kReactiveConfigRuleTraceOnTriggerOr10sOrTriggerOrFull)
+    if (type != kReactiveConfigRuleTraceFor10sOrTriggerOrFull)
       return nullptr;
 
     rule.type = BackgroundTracingReactiveConfig::
-        TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL;
+        TRACE_FOR_10S_OR_TRIGGER_OR_FULL;
 
     std::string trigger_name;
     if (!config_dict->GetString(kConfigRuleTriggerNameKey, &trigger_name))
       return nullptr;
 
     rule.trigger_name = trigger_name;
 
     config->configs.push_back(rule);
   }
 
@@ skipping 36 matching lines @@
   scoped_ptr<base::ListValue> configs_list(new base::ListValue());
 
   for (size_t i = 0; i < config->configs.size(); ++i) {
     scoped_ptr<base::DictionaryValue> config_dict(new base::DictionaryValue());
 
     config_dict->SetString(
         kConfigCategoryKey,
         CategoryPresetToString(config->configs[i].category_preset));
 
     switch (config->configs[i].type) {
-      case BackgroundTracingReactiveConfig::
-          TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL:
+      case BackgroundTracingReactiveConfig::TRACE_FOR_10S_OR_TRIGGER_OR_FULL:
         config_dict->SetString(
             kConfigRuleKey,
-            kReactiveConfigRuleTraceOnTriggerOr10sOrTriggerOrFull);
+            kReactiveConfigRuleTraceFor10sOrTriggerOrFull);
         break;
       default:
         NOTREACHED();
         continue;
     }
 
     config_dict->SetString(kConfigRuleTriggerNameKey,
                            config->configs[i].trigger_name.c_str());
 
     configs_list->Append(config_dict.Pass());
@@ skipping 41 matching lines @@
       dict->SetString(kConfigModeKey, kConfigModeReactive);
       if (!BackgroundTracingReactiveConfig_IntoDict(
               static_cast<const BackgroundTracingReactiveConfig*>(config),
               dict))
         dict->Clear();
       break;
   }
 }
 
 }  // namspace content