[tracing] Non-functional refactor of memory dump arg names

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/pattern.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/memory_dump_request_args.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 // String options that can be used to initialize TraceOptions.
 const char kRecordUntilFull[] = "record-until-full";
 const char kRecordContinuously[] = "record-continuously";
@@ skipping 13 matching lines @@
 const char kSyntheticDelaysParam[] = "synthetic_delays";
 
 const char kSyntheticDelayCategoryFilterPrefix[] = "DELAY(";
 
 // String parameters that is used to parse memory dump config in trace config
 // string.
 const char kMemoryDumpConfigParam[] = "memory_dump_config";
 const char kTriggersParam[] = "triggers";
 const char kPeriodicIntervalParam[] = "periodic_interval_ms";
 const char kModeParam[] = "mode";
-const char kDetailedParam[] = "detailed";
-const char kLightParam[] = "light";
 
 // Default configuration of memory dumps.
 const TraceConfig::MemoryDumpTriggerConfig kDefaultHeavyMemoryDumpTrigger = {
     2000,  // periodic_interval_ms
-    MemoryDumpArgs::LevelOfDetail::HIGH};
+    MemoryDumpLevelOfDetail::DETAILED};
 const TraceConfig::MemoryDumpTriggerConfig kDefaultLightMemoryDumpTrigger = {
     250,  // periodic_interval_ms
-    MemoryDumpArgs::LevelOfDetail::LOW};
+    MemoryDumpLevelOfDetail::LIGHT};
 
 }  // namespace
 
 TraceConfig::TraceConfig() {
   InitializeDefault();
 }
 
 TraceConfig::TraceConfig(const std::string& category_filter_string,
                          const std::string& trace_options_string) {
   InitializeFromStrings(category_filter_string, trace_options_string);
@@ skipping 391 matching lines @@
       trigger_list->GetSize() == 0) {
     return;
   }
 
   for (size_t i = 0; i < trigger_list->GetSize(); ++i) {
     const base::DictionaryValue* trigger = nullptr;
     if (!trigger_list->GetDictionary(i, &trigger))
       continue;
 
     MemoryDumpTriggerConfig dump_config;
-    std::string dump_type;
     int interval = 0;
 
     if (!trigger->GetInteger(kPeriodicIntervalParam, &interval)) {
       continue;
     }
     DCHECK_GT(interval, 0);
     dump_config.periodic_interval_ms = static_cast<uint32>(interval);
-    dump_config.level_of_detail = MemoryDumpArgs::LevelOfDetail::LOW;
-
-    if (trigger->GetString(kModeParam, &dump_type)) {
-      if (dump_type == kDetailedParam) {
-        dump_config.level_of_detail = MemoryDumpArgs::LevelOfDetail::HIGH;
-      }
-    }
-
+    std::string level_of_detail_str;
+    trigger->GetString(kModeParam, &level_of_detail_str);
+    dump_config.level_of_detail =
+        StringToMemoryDumpLevelOfDetail(level_of_detail_str);
     memory_dump_config_.push_back(dump_config);
   }
 }
 
 void TraceConfig::SetDefaultMemoryDumpConfig() {
   memory_dump_config_.clear();
   memory_dump_config_.push_back(kDefaultHeavyMemoryDumpTrigger);
   memory_dump_config_.push_back(kDefaultLightMemoryDumpTrigger);
 }
 
@@ skipping 40 matching lines @@
 
   if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
     scoped_ptr<base::DictionaryValue> memory_dump_config(
         new base::DictionaryValue());
     scoped_ptr<base::ListValue> triggers_list(new base::ListValue());
     for (const MemoryDumpTriggerConfig& config : memory_dump_config_) {
       scoped_ptr<base::DictionaryValue> trigger_dict(
           new base::DictionaryValue());
       trigger_dict->SetInteger(kPeriodicIntervalParam,
                                static_cast<int>(config.periodic_interval_ms));
-
-      switch (config.level_of_detail) {
-        case MemoryDumpArgs::LevelOfDetail::LOW:
-          trigger_dict->SetString(kModeParam, kLightParam);
-          break;
-        case MemoryDumpArgs::LevelOfDetail::HIGH:
-          trigger_dict->SetString(kModeParam, kDetailedParam);
-          break;
-        default:
-          NOTREACHED();
-      }
+      trigger_dict->SetString(
+          kModeParam, MemoryDumpLevelOfDetailToString(config.level_of_detail));
       triggers_list->Append(trigger_dict.Pass());
     }
 
     // Empty triggers will still be specified explicitly since it means that
     // the periodic dumps are not enabled.
     memory_dump_config->Set(kTriggersParam, triggers_list.Pass());
     dict.Set(kMemoryDumpConfigParam, memory_dump_config.Pass());
   }
 }
 
@@ skipping 83 matching lines @@
           str.at(0) == ' ' ||
           str.at(str.length() - 1) == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base