Background tracing: Added preset category for blink_style

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 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";
+const char kConfigCategoryBlinkStyle[] = "BLINK_STYLE";
 
 }  // namespace
 
 BackgroundTracingConfigImpl::BackgroundTracingConfigImpl(
     TracingMode tracing_mode)
     : BackgroundTracingConfig(tracing_mode),
       category_preset_(BackgroundTracingConfigImpl::BENCHMARK) {}
 
 BackgroundTracingConfigImpl::~BackgroundTracingConfigImpl() {}
 
 std::string BackgroundTracingConfigImpl::CategoryPresetToString(
     BackgroundTracingConfigImpl::CategoryPreset category_preset) {
   switch (category_preset) {
     case BackgroundTracingConfigImpl::BENCHMARK:
       return kConfigCategoryBenchmark;
     case BackgroundTracingConfigImpl::BENCHMARK_DEEP:
       return kConfigCategoryBenchmarkDeep;
     case BackgroundTracingConfigImpl::BENCHMARK_GPU:
       return kConfigCategoryBenchmarkGPU;
     case BackgroundTracingConfigImpl::BENCHMARK_IPC:
       return kConfigCategoryBenchmarkIPC;
     case BackgroundTracingConfigImpl::BENCHMARK_STARTUP:
       return kConfigCategoryBenchmarkStartup;
+    case BackgroundTracingConfigImpl::BLINK_STYLE:
+      return kConfigCategoryBlinkStyle;
   }
   NOTREACHED();
   return "";
 }
 
 bool BackgroundTracingConfigImpl::StringToCategoryPreset(
     const std::string& category_preset_string,
     BackgroundTracingConfigImpl::CategoryPreset* category_preset) {
   if (category_preset_string == kConfigCategoryBenchmark) {
     *category_preset = BackgroundTracingConfigImpl::BENCHMARK;
@@ skipping 13 matching lines @@
   if (category_preset_string == kConfigCategoryBenchmarkIPC) {
     *category_preset = BackgroundTracingConfigImpl::BENCHMARK_IPC;
     return true;
   }
 
   if (category_preset_string == kConfigCategoryBenchmarkStartup) {
     *category_preset = BackgroundTracingConfigImpl::BENCHMARK_STARTUP;
     return true;
   }
 
+  if (category_preset_string == kConfigCategoryBlinkStyle) {
+    *category_preset = BackgroundTracingConfigImpl::BLINK_STYLE;
+    return true;
+  }
+
   return false;
 }
 
 void BackgroundTracingConfigImpl::IntoDict(base::DictionaryValue* dict) const {
   switch (tracing_mode()) {
     case BackgroundTracingConfigImpl::PREEMPTIVE:
       dict->SetString(kConfigModeKey, kConfigModePreemptive);
       dict->SetString(kConfigCategoryKey,
                       CategoryPresetToString(category_preset_));
       break;
@@ skipping 113 matching lines @@
     config->AddReactiveRule(config_dict, new_category_preset);
   }
 
   if (config->rules().empty())
     return nullptr;
 
   return config.Pass();
 }
 
 }  // namspace content