content/browser/tracing/background_tracing_config_dict.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/macros.h"
   6 #include "base/values.h"
   7 #include "content/public/browser/background_tracing_preemptive_config.h"
   8 #include "content/public/browser/background_tracing_reactive_config.h"
   9
  10 namespace content {
  11
  12 namespace {
  13
  14 const char kConfigsKey[] = "configs";
  15
  16 const char kConfigModeKey[] = "mode";
  17 const char kConfigModePreemptive[] = "PREEMPTIVE_TRACING_MODE";
  18 const char kConfigModeReactive[] = "REACTIVE_TRACING_MODE";
  19
  20 const char kConfigCategoryKey[] = "category";
  21 const char kConfigCategoryBenchmark[] = "BENCHMARK";
  22 const char kConfigCategoryBenchmarkDeep[] = "BENCHMARK_DEEP";
  23
  24 const char kConfigRuleKey[] = "rule";
  25 const char kConfigRuleTriggerNameKey[] = "trigger_name";
  26 const char kConfigRuleHistogramNameKey[] = "histogram_name";
  27 const char kConfigRuleHistogramValueKey[] = "histogram_value";
  28
  29 const char kPreemptiveConfigRuleMonitorNamed[] =
  30     "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED";
  31
  32 const char kPreemptiveConfigRuleMonitorHistogram[] =
  33     "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE";
  34
  35 const char kReactiveConfigRuleTraceFor10sOrTriggerOrFull[] =
  36     "TRACE_FOR_10S_OR_TRIGGER_OR_FULL";
  37
  38 std::string CategoryPresetToString(
  39     BackgroundTracingConfig::CategoryPreset category_preset) {
  40   switch (category_preset) {
  41     case BackgroundTracingConfig::BENCHMARK:
  42       return kConfigCategoryBenchmark;
  43     case BackgroundTracingConfig::BENCHMARK_DEEP:
  44       return kConfigCategoryBenchmarkDeep;
  45       break;
  46   }
  47   NOTREACHED();
  48   return "";
  49 }
  50
  51 bool StringToCategoryPreset(
  52     const std::string& category_preset_string,
  53     BackgroundTracingConfig::CategoryPreset* category_preset) {
  54   if (category_preset_string == kConfigCategoryBenchmark) {
  55     *category_preset = BackgroundTracingConfig::BENCHMARK;
  56     return true;
  57   } else if (category_preset_string == kConfigCategoryBenchmarkDeep) {
  58     *category_preset = BackgroundTracingConfig::BENCHMARK_DEEP;
  59     return true;
  60   }
  61
  62   return false;
  63 }
  64
  65 scoped_ptr<BackgroundTracingPreemptiveConfig>
  66 BackgroundTracingPreemptiveConfig_FromDict(const base::DictionaryValue* dict) {
  67   DCHECK(dict);
  68
  69   scoped_ptr<BackgroundTracingPreemptiveConfig> config(
  70       new BackgroundTracingPreemptiveConfig());
  71
  72   std::string category_preset_string;
  73   if (!dict->GetString(kConfigCategoryKey, &category_preset_string))
  74     return nullptr;
  75
  76   if (!StringToCategoryPreset(category_preset_string, &config->category_preset))
  77     return nullptr;
  78
  79   const base::ListValue* configs_list = nullptr;
  80   if (!dict->GetList(kConfigsKey, &configs_list))
  81     return nullptr;
  82
  83   for (const auto& it : *configs_list) {
  84     const base::DictionaryValue* config_dict = nullptr;
  85     if (!it->GetAsDictionary(&config_dict))
  86       return nullptr;
  87
  88     std::string type;
  89     if (!config_dict->GetString(kConfigRuleKey, &type))
  90       return nullptr;
  91
  92     if (type == kPreemptiveConfigRuleMonitorNamed) {
  93       std::string trigger_name;
  94       if (!config_dict->GetString(kConfigRuleTriggerNameKey, &trigger_name))
  95         return nullptr;
  96
  97       BackgroundTracingPreemptiveConfig::MonitoringRule rule;
  98       rule.type = BackgroundTracingPreemptiveConfig::
  99           MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
 100       rule.named_trigger_info.trigger_name = trigger_name;
 101
 102       config->configs.push_back(rule);
 103     } else if (type == kPreemptiveConfigRuleMonitorHistogram) {
 104       std::string histogram_name;
 105       if (!config_dict->GetString(kConfigRuleHistogramNameKey, &histogram_name))
 106         return nullptr;
 107
 108       int histogram_value;
 109       if (!config_dict->GetInteger(kConfigRuleHistogramValueKey,
 110                                    &histogram_value))
 111         return nullptr;
 112
 113       BackgroundTracingPreemptiveConfig::MonitoringRule rule;
 114       rule.type = BackgroundTracingPreemptiveConfig::
 115           MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
 116       rule.histogram_trigger_info.histogram_name = histogram_name;
 117       rule.histogram_trigger_info.histogram_value = histogram_value;
 118
 119       config->configs.push_back(rule);
 120     } else {
 121       continue;
 122     }
 123   }
 124
 125   return config.Pass();
 126 }
 127
 128 scoped_ptr<BackgroundTracingReactiveConfig>
 129 BackgroundTracingReactiveConfig_FromDict(const base::DictionaryValue* dict) {
 130   DCHECK(dict);
 131
 132   scoped_ptr<BackgroundTracingReactiveConfig> config(
 133       new BackgroundTracingReactiveConfig());
 134
 135   const base::ListValue* configs_list = nullptr;
 136   if (!dict->GetList(kConfigsKey, &configs_list))
 137     return nullptr;
 138
 139   for (const auto& it : *configs_list) {
 140     const base::DictionaryValue* config_dict = nullptr;
 141     if (!it->GetAsDictionary(&config_dict))
 142       return nullptr;
 143
 144     BackgroundTracingReactiveConfig::TracingRule rule;
 145
 146     std::string category_preset_string;
 147     if (!config_dict->GetString(kConfigCategoryKey, &category_preset_string))
 148       return nullptr;
 149
 150     if (!StringToCategoryPreset(category_preset_string, &rule.category_preset))
 151       return nullptr;
 152
 153     std::string type;
 154     if (!config_dict->GetString(kConfigRuleKey, &type))
 155       return nullptr;
 156
 157     if (type != kReactiveConfigRuleTraceFor10sOrTriggerOrFull)
 158       return nullptr;
 159
 160     rule.type = BackgroundTracingReactiveConfig::
 161         TRACE_FOR_10S_OR_TRIGGER_OR_FULL;
 162
 163     std::string trigger_name;
 164     if (!config_dict->GetString(kConfigRuleTriggerNameKey, &trigger_name))
 165       return nullptr;
 166
 167     rule.trigger_name = trigger_name;
 168
 169     config->configs.push_back(rule);
 170   }
 171
 172   return config.Pass();
 173 }
 174
 175 bool BackgroundTracingPreemptiveConfig_IntoDict(
 176     const BackgroundTracingPreemptiveConfig* config,
 177     base::DictionaryValue* dict) {
 178   dict->SetString(kConfigCategoryKey,
 179                   CategoryPresetToString(config->category_preset));
 180
 181   scoped_ptr<base::ListValue> configs_list(new base::ListValue());
 182
 183   for (const auto& it : config->configs) {
 184     scoped_ptr<base::DictionaryValue> config_dict(new base::DictionaryValue());
 185
 186     if (it.type == BackgroundTracingPreemptiveConfig::
 187                        MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED) {
 188       config_dict->SetString(kConfigRuleKey, kPreemptiveConfigRuleMonitorNamed);
 189       config_dict->SetString(kConfigRuleTriggerNameKey,
 190                              it.named_trigger_info.trigger_name.c_str());
 191     } else if (it.type ==
 192                BackgroundTracingPreemptiveConfig::
 193                    MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE) {
 194       config_dict->SetString(kConfigRuleKey,
 195                              kPreemptiveConfigRuleMonitorHistogram);
 196       config_dict->SetString(kConfigRuleHistogramNameKey,
 197                              it.histogram_trigger_info.histogram_name.c_str());
 198       config_dict->SetInteger(kConfigRuleHistogramValueKey,
 199                               it.histogram_trigger_info.histogram_value);
 200     } else {
 201       continue;
 202     }
 203
 204     configs_list->Append(config_dict.Pass());
 205   }
 206
 207   dict->Set(kConfigsKey, configs_list.Pass());
 208
 209   return true;
 210 }
 211
 212 bool BackgroundTracingReactiveConfig_IntoDict(
 213     const BackgroundTracingReactiveConfig* config,
 214     base::DictionaryValue* dict) {
 215   scoped_ptr<base::ListValue> configs_list(new base::ListValue());
 216
 217   for (const auto& it : config->configs) {
 218     scoped_ptr<base::DictionaryValue> config_dict(new base::DictionaryValue());
 219
 220     config_dict->SetString(kConfigCategoryKey,
 221                            CategoryPresetToString(it.category_preset));
 222
 223     switch (it.type) {
 224       case BackgroundTracingReactiveConfig::TRACE_FOR_10S_OR_TRIGGER_OR_FULL:
 225         config_dict->SetString(
 226             kConfigRuleKey,
 227             kReactiveConfigRuleTraceFor10sOrTriggerOrFull);
 228         break;
 229       default:
 230         NOTREACHED();
 231         continue;
 232     }
 233
 234     config_dict->SetString(kConfigRuleTriggerNameKey, it.trigger_name.c_str());
 235     configs_list->Append(config_dict.Pass());
 236   }
 237
 238   dict->Set(kConfigsKey, configs_list.Pass());
 239
 240   return true;
 241 }
 242
 243 }  // namespace
 244
 245 scoped_ptr<BackgroundTracingConfig> BackgroundTracingConfig::FromDict(
 246     const base::DictionaryValue* dict) {
 247   DCHECK(dict);
 248
 249   std::string mode;
 250   if (!dict->GetString(kConfigModeKey, &mode))
 251     return nullptr;
 252
 253   scoped_ptr<BackgroundTracingConfig> config;
 254
 255   if (mode == kConfigModePreemptive) {
 256     config = BackgroundTracingPreemptiveConfig_FromDict(dict);
 257   } else if (mode == kConfigModeReactive) {
 258     config = BackgroundTracingReactiveConfig_FromDict(dict);
 259   } else {
 260     return nullptr;
 261   }
 262
 263   return config.Pass();
 264 }
 265
 266 void BackgroundTracingConfig::IntoDict(const BackgroundTracingConfig* config,
 267                                        base::DictionaryValue* dict) {
 268   switch (config->mode) {
 269     case PREEMPTIVE_TRACING_MODE:
 270       dict->SetString(kConfigModeKey, kConfigModePreemptive);
 271       if (!BackgroundTracingPreemptiveConfig_IntoDict(
 272               static_cast<const BackgroundTracingPreemptiveConfig*>(config),
 273               dict))
 274         dict->Clear();
 275       break;
 276     case REACTIVE_TRACING_MODE:
 277       dict->SetString(kConfigModeKey, kConfigModeReactive);
 278       if (!BackgroundTracingReactiveConfig_IntoDict(
 279               static_cast<const BackgroundTracingReactiveConfig*>(config),
 280               dict))
 281         dict->Clear();
 282       break;
 283   }
 284 }
 285
 286 }  // namspace content