[Startup Tracing] Hook up TraceConfig and remove CategoryFilter & TraceOptions

base/trace_event/trace_config.cc

 // Copyright (c) 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/trace_event/trace_config.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 26 matching lines @@
 const char kSyntheticDelayCategoryFilterPrefix[] = "DELAY(";
 
 }  // namespace
 
 TraceConfig::TraceConfig() {
   InitializeDefault();
 }
 
 TraceConfig::TraceConfig(const std::string& category_filter_string,
                          const std::string& trace_options_string) {
-  if (!category_filter_string.empty()) {
-    std::vector<std::string> split;
-    std::vector<std::string>::iterator iter;
-    base::SplitString(category_filter_string, ',', &split);
-    for (iter = split.begin(); iter != split.end(); ++iter) {
-      std::string category = *iter;
-      // Ignore empty categories.
-      if (category.empty())
-        continue;
-      // Synthetic delays are of the form 'DELAY(delay;option;option;...)'.
-      if (category.find(kSyntheticDelayCategoryFilterPrefix) == 0 &&
-          category.at(category.size() - 1) == ')') {
-        category = category.substr(
-            strlen(kSyntheticDelayCategoryFilterPrefix),
-            category.size() - strlen(kSyntheticDelayCategoryFilterPrefix) - 1);
-        size_t name_length = category.find(';');
-        if (name_length != std::string::npos && name_length > 0 &&
-            name_length != category.size() - 1) {
-          synthetic_delays_.push_back(category);
-        }
-      } else if (category.at(0) == '-') {
-        // Excluded categories start with '-'.
-        // Remove '-' from category string.
-        category = category.substr(1);
-        excluded_categories_.push_back(category);
-      } else if (category.compare(0, strlen(TRACE_DISABLED_BY_DEFAULT("")),
-                                  TRACE_DISABLED_BY_DEFAULT("")) == 0) {
-        disabled_categories_.push_back(category);
-      } else {
-        included_categories_.push_back(category);
-      }
-    }
+  InitializeFromStrings(category_filter_string, trace_options_string);
+}
+
+TraceConfig::TraceConfig(const std::string& category_filter_string,
+                         TraceRecordMode record_mode) {
+  std::string trace_options_string;
+  switch (record_mode) {
+    case RECORD_UNTIL_FULL:
+      trace_options_string = kRecordUntilFull;
+      break;
+    case RECORD_CONTINUOUSLY:
+      trace_options_string = kRecordContinuously;
+      break;
+    case RECORD_AS_MUCH_AS_POSSIBLE:
+      trace_options_string = kRecordAsMuchAsPossible;
+      break;
+    case ECHO_TO_CONSOLE:
+      trace_options_string = kTraceToConsole;
+      break;
+    default:
+      NOTREACHED();
   }
-
-  record_mode_ = RECORD_UNTIL_FULL;
-  enable_sampling_ = false;
-  enable_systrace_ = false;
-  enable_argument_filter_ = false;
-  if(!trace_options_string.empty()) {
-    std::vector<std::string> split;
-    std::vector<std::string>::iterator iter;
-    base::SplitString(trace_options_string, ',', &split);
-    for (iter = split.begin(); iter != split.end(); ++iter) {
-      if (*iter == kRecordUntilFull) {
-        record_mode_ = RECORD_UNTIL_FULL;
-      } else if (*iter == kRecordContinuously) {
-        record_mode_ = RECORD_CONTINUOUSLY;
-      } else if (*iter == kTraceToConsole) {
-        record_mode_ = ECHO_TO_CONSOLE;
-      } else if (*iter == kRecordAsMuchAsPossible) {
-        record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
-      } else if (*iter == kEnableSampling) {
-        enable_sampling_ = true;
-      } else if (*iter == kEnableSystrace) {
-        enable_systrace_ = true;
-      } else if (*iter == kEnableArgumentFilter) {
-        enable_argument_filter_ = true;
-      }
-    }
-  }
+  InitializeFromStrings(category_filter_string, trace_options_string);
 }
 
 TraceConfig::TraceConfig(const std::string& config_string) {
   if (!config_string.empty())
-    Initialize(config_string);
+    InitializeFromConfigString(config_string);
   else
     InitializeDefault();
 }
 
 TraceConfig::TraceConfig(const TraceConfig& tc)
     : record_mode_(tc.record_mode_),
       enable_sampling_(tc.enable_sampling_),
       enable_systrace_(tc.enable_systrace_),
       enable_argument_filter_(tc.enable_argument_filter_),
       included_categories_(tc.included_categories_),
@@ skipping 145 matching lines @@
 
 void TraceConfig::InitializeDefault() {
   record_mode_ = RECORD_UNTIL_FULL;
   enable_sampling_ = false;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
   excluded_categories_.push_back("*Debug");
   excluded_categories_.push_back("*Test");
 }
 
-void TraceConfig::Initialize(const std::string& config_string) {
+void TraceConfig::InitializeFromConfigString(const std::string& config_string) {
   scoped_ptr<base::Value> value(base::JSONReader::Read(config_string));
   if (!value || !value->IsType(base::Value::TYPE_DICTIONARY)) {
     InitializeDefault();
     return;
   }
   scoped_ptr<base::DictionaryValue> dict(
         static_cast<base::DictionaryValue*>(value.release()));
 
   record_mode_ = RECORD_UNTIL_FULL;
   std::string record_mode;
@@ skipping 30 matching lines @@
 
   base::ListValue* category_list = NULL;
   if (dict->GetList(kIncludedCategoriesParam, &category_list))
     SetCategoriesFromIncludedList(*category_list);
   if (dict->GetList(kExcludedCategoriesParam, &category_list))
     SetCategoriesFromExcludedList(*category_list);
   if (dict->GetList(kSyntheticDelaysParam, &category_list))
     SetSyntheticDelaysFromList(*category_list);
 }
 
+void TraceConfig::InitializeFromStrings(
+    const std::string& category_filter_string,
+    const std::string& trace_options_string) {
+  if (!category_filter_string.empty()) {
+    std::vector<std::string> split;
+    std::vector<std::string>::iterator iter;
+    base::SplitString(category_filter_string, ',', &split);
+    for (iter = split.begin(); iter != split.end(); ++iter) {
+      std::string category = *iter;
+      // Ignore empty categories.
+      if (category.empty())
+        continue;
+      // Synthetic delays are of the form 'DELAY(delay;option;option;...)'.
+      if (category.find(kSyntheticDelayCategoryFilterPrefix) == 0 &&
+          category.at(category.size() - 1) == ')') {
+        category = category.substr(
+            strlen(kSyntheticDelayCategoryFilterPrefix),
+            category.size() - strlen(kSyntheticDelayCategoryFilterPrefix) - 1);
+        size_t name_length = category.find(';');
+        if (name_length != std::string::npos && name_length > 0 &&
+            name_length != category.size() - 1) {
+          synthetic_delays_.push_back(category);
+        }
+      } else if (category.at(0) == '-') {
+        // Excluded categories start with '-'.
+        // Remove '-' from category string.
+        category = category.substr(1);
+        excluded_categories_.push_back(category);
+      } else if (category.compare(0, strlen(TRACE_DISABLED_BY_DEFAULT("")),
+                                  TRACE_DISABLED_BY_DEFAULT("")) == 0) {
+        disabled_categories_.push_back(category);
+      } else {
+        included_categories_.push_back(category);
+      }
+    }
+  }
+
+  record_mode_ = RECORD_UNTIL_FULL;
+  enable_sampling_ = false;
+  enable_systrace_ = false;
+  enable_argument_filter_ = false;
+  if(!trace_options_string.empty()) {
+    std::vector<std::string> split;
+    std::vector<std::string>::iterator iter;
+    base::SplitString(trace_options_string, ',', &split);
+    for (iter = split.begin(); iter != split.end(); ++iter) {
+      if (*iter == kRecordUntilFull) {
+        record_mode_ = RECORD_UNTIL_FULL;
+      } else if (*iter == kRecordContinuously) {
+        record_mode_ = RECORD_CONTINUOUSLY;
+      } else if (*iter == kTraceToConsole) {
+        record_mode_ = ECHO_TO_CONSOLE;
+      } else if (*iter == kRecordAsMuchAsPossible) {
+        record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
+      } else if (*iter == kEnableSampling) {
+        enable_sampling_ = true;
+      } else if (*iter == kEnableSystrace) {
+        enable_systrace_ = true;
+      } else if (*iter == kEnableArgumentFilter) {
+        enable_argument_filter_ = true;
+      }
+    }
+  }
+}
+
 void TraceConfig::SetCategoriesFromIncludedList(
     const base::ListValue& included_list) {
   included_categories_.clear();
   for (size_t i = 0; i < included_list.GetSize(); ++i) {
     std::string category;
     if (!included_list.GetString(i, &category))
       continue;
     if (category.compare(0, strlen(TRACE_DISABLED_BY_DEFAULT("")),
                          TRACE_DISABLED_BY_DEFAULT("")) == 0) {
       disabled_categories_.push_back(category);
@@ skipping 45 matching lines @@
 }
 
 void TraceConfig::ToDict(base::DictionaryValue& dict) const {
   switch (record_mode_) {
     case RECORD_UNTIL_FULL:
       dict.SetString(kRecordModeParam, kRecordUntilFull);
       break;
     case RECORD_CONTINUOUSLY:
       dict.SetString(kRecordModeParam, kRecordContinuously);
       break;
+    case RECORD_AS_MUCH_AS_POSSIBLE:
+      dict.SetString(kRecordModeParam, kRecordAsMuchAsPossible);
+      break;
     case ECHO_TO_CONSOLE:
       dict.SetString(kRecordModeParam, kTraceToConsole);
       break;
-    case RECORD_AS_MUCH_AS_POSSIBLE:
-      dict.SetString(kRecordModeParam, kRecordAsMuchAsPossible);
-      break;
     default:
       NOTREACHED();
   }
 
   if (enable_sampling_)
     dict.SetBoolean(kEnableSamplingParam, true);
   else
     dict.SetBoolean(kEnableSamplingParam, false);
 
   if (enable_systrace_)
     dict.SetBoolean(kEnableSystraceParam, true);
   else
     dict.SetBoolean(kEnableSystraceParam, false);
 
   if (enable_argument_filter_)
     dict.SetBoolean(kEnableArgumentFilterParam, true);
   else
     dict.SetBoolean(kEnableArgumentFilterParam, false);
 
   StringList categories(included_categories_);
   categories.insert(categories.end(),
                     disabled_categories_.begin(),
                     disabled_categories_.end());
   AddCategoryToDict(dict, kIncludedCategoriesParam, categories);
   AddCategoryToDict(dict, kExcludedCategoriesParam, excluded_categories_);
   AddCategoryToDict(dict, kSyntheticDelaysParam, synthetic_delays_);
 }
 
 std::string TraceConfig::ToTraceOptionsString() const {
-  TraceOptions to;
-  to.record_mode = record_mode_;
-  to.enable_sampling = enable_sampling_;
-  to.enable_systrace = enable_systrace_;
-  to.enable_argument_filter = enable_argument_filter_;
-  return to.ToString();
+  std::string ret;
+  switch (record_mode_) {
+    case RECORD_UNTIL_FULL:
+      ret = kRecordUntilFull;
+      break;
+    case RECORD_CONTINUOUSLY:
+      ret = kRecordContinuously;
+      break;
+    case RECORD_AS_MUCH_AS_POSSIBLE:
+      ret = kRecordAsMuchAsPossible;
+      break;
+    case ECHO_TO_CONSOLE:
+      ret = kTraceToConsole;
+      break;
+    default:
+      NOTREACHED();
+  }
+  if (enable_sampling_)
+    ret = ret + "," + kEnableSampling;
+  if (enable_systrace_)
+    ret = ret + "," + kEnableSystrace;
+  if (enable_argument_filter_)
+    ret = ret + "," + kEnableArgumentFilter;
+  return ret;
 }
 
 void TraceConfig::WriteCategoryFilterString(const StringList& values,
                                             std::string* out,
                                             bool included) const {
   bool prepend_comma = !out->empty();
   int token_cnt = 0;
   for (StringList::const_iterator ci = values.begin();
        ci != values.end(); ++ci) {
     if (token_cnt > 0 || prepend_comma)
@@ skipping 48 matching lines @@
           str.at(0) == ' ' ||
           str.at(str.length() - 1) == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base