[tracing] Add memory dump config to TraceConfig

base/trace_event/trace_config.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_TRACE_CONFIG_H_
 #define BASE_TRACE_EVENT_TRACE_CONFIG_H_
 
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/gtest_prod_util.h"
+#include "base/trace_event/memory_dump_provider.h"
 #include "base/values.h"
 
 namespace base {
 namespace trace_event {
 
 // Options determines how the trace buffer stores data.
 enum TraceRecordMode {
   // Record until the trace buffer is full.
   RECORD_UNTIL_FULL,
 
   // Record until the user ends the trace. The trace buffer is a fixed size
   // and we use it as a ring buffer during recording.
   RECORD_CONTINUOUSLY,
 
   // Record until the trace buffer is full, but with a huge buffer size.
   RECORD_AS_MUCH_AS_POSSIBLE,
 
   // Echo to console. Events are discarded.
   ECHO_TO_CONSOLE,
 };
 
 class BASE_EXPORT TraceConfig {
  public:
   typedef std::vector<std::string> StringList;
 
+  // Specifies the memory dump config for tracing. Used only when
+  // "memory-infra" category is enabled.
+  struct MemoryDumpTriggerConfig {
+    uint32 periodic_interval_ms;
+    MemoryDumpArgs::LevelOfDetail level_of_detail;
+  };
+
+  typedef std::vector<MemoryDumpTriggerConfig> MemoryDumpConfig;
+
   TraceConfig();
 
   // Create TraceConfig object from category filter and trace options strings.
   //
   // |category_filter_string| is a comma-delimited list of category wildcards.
   // A category can have an optional '-' prefix to make it an excluded category.
   // All the same rules apply above, so for example, having both included and
   // excluded categories in the same list would not be supported.
   //
   // Category filters can also be used to configure synthetic delays.
@@ skipping 44 matching lines @@
   // category filters and trace options.
   //
   // Example:
   //   {
   //     "record_mode": "record-continuously",
   //     "enable_sampling": true,
   //     "enable_systrace": true,
   //     "enable_argument_filter": true,
   //     "included_categories": ["included",
   //                             "inc_pattern*",
-  //                             "disabled-by-default-category1"],
+  //                             "disabled-by-default-memory-infra"],

[Zhen Wang, 2015/08/24 18:38:24]

disabled-by-default-memory-infra must be specified if one wants to use
memory_dump_config, right? It is not clear in the example if those two are
tightly related. Can you add a note after the example?

[ssid, 2015/08/24 19:48:10]

Done.

   //     "excluded_categories": ["excluded", "exc_pattern*"],
   //     "synthetic_delays": ["test.Delay1;16", "test.Delay2;32"]
+  //     "memory_dump_config": {
+  //       "triggers": [
+  //         {
+  //           "level_of_detail": "high",
+  //           "periodic_interval_ms": 2000
+  //         }
+  //       ]
+  //     }
   //   }
   explicit TraceConfig(const std::string& config_string);
 
   TraceConfig(const TraceConfig& tc);
 
   ~TraceConfig();
 
   TraceConfig& operator=(const TraceConfig& rhs);
 
   // Return a list of the synthetic delays specified in this category filter.
@@ skipping 18 matching lines @@
 
   // Returns true if at least one category in the list is enabled by this
   // trace config.
   bool IsCategoryGroupEnabled(const char* category_group) const;
 
   // Merges config with the current TraceConfig
   void Merge(const TraceConfig& config);
 
   void Clear();
 
+  const MemoryDumpConfig& memory_dump_config() const {
+    return memory_dump_config_;
+  }
+
  private:
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromValidLegacyFormat);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest,
                            TraceConfigFromInvalidLegacyStrings);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, ConstructDefaultTraceConfig);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromValidString);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromInvalidString);
   FRIEND_TEST_ALL_PREFIXES(TraceConfigTest,
                            IsEmptyOrContainsLeadingOrTrailingWhitespace);
+  FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromMemoryConfigString);
+  FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, InvalidMemoryConfigString);
 
   // The default trace config, used when none is provided.
   // Allows all non-disabled-by-default categories through, except if they end
   // in the suffix 'Debug' or 'Test'.
   void InitializeDefault();
 
   // Initialize from the config string
   void InitializeFromConfigString(const std::string& config_string);
 
   // Initialize from category filter and trace options strings
   void InitializeFromStrings(const std::string& category_filter_string,
                              const std::string& trace_options_string);
 
   void SetCategoriesFromIncludedList(const base::ListValue& included_list);
   void SetCategoriesFromExcludedList(const base::ListValue& excluded_list);
   void SetSyntheticDelaysFromList(const base::ListValue& list);
   void AddCategoryToDict(base::DictionaryValue& dict,
                          const char* param,
                          const StringList& categories) const;
 
+  void SetMemoryDumpConfig(const base::DictionaryValue& memory_dump_config);
+
   // Convert TraceConfig to the dict representation of the TraceConfig.
   void ToDict(base::DictionaryValue& dict) const;
 
   std::string ToTraceOptionsString() const;
 
   void WriteCategoryFilterString(const StringList& values,
                                  std::string* out,
                                  bool included) const;
   void WriteCategoryFilterString(const StringList& delays,
                                  std::string* out) const;
 
   // Returns true if category is enable according to this trace config.
   bool IsCategoryEnabled(const char* category_name) const;
 
   static bool IsEmptyOrContainsLeadingOrTrailingWhitespace(
       const std::string& str);
 
   bool HasIncludedPatterns() const;
 
   TraceRecordMode record_mode_;
   bool enable_sampling_ : 1;
   bool enable_systrace_ : 1;
   bool enable_argument_filter_ : 1;
 
+  MemoryDumpConfig memory_dump_config_;
+
   StringList included_categories_;
   StringList disabled_categories_;
   StringList excluded_categories_;
   StringList synthetic_delays_;
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_CONFIG_H_