[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"],

[Primiano Tucci (use gerrit), 2015/08/25 18:27:37]

remove this line

[ssid, 2015/08/26 10:19:51]

Done.

   //     "excluded_categories": ["excluded", "exc_pattern*"],
   //     "synthetic_delays": ["test.Delay1;16", "test.Delay2;32"]
+  //     "memory_dump_config": {
+  //       "triggers": [
+  //         {
+  //           "level_of_detail": "high",

[Primiano Tucci (use gerrit), 2015/08/25 18:27:37]

s/level_of_detail/mode/
high -> detailed
low -> light

I'll rename the rest of the codebase to match.

[ssid, 2015/08/26 10:19:51]

Done.

+  //           "periodic_interval_ms": 2000
+  //         }
+  //       ]
+  //     }
   //   }
+  //
+  // Note: memory_dump_config can be specified only if

[Primiano Tucci (use gerrit), 2015/08/24 21:26:47]

ssid: according to our last chat offline this comment is not true anymore,
right?
Ditto for the if check below

[ssid, 2015/08/24 22:46:26]

For this CL this is true. This will be removed once I change the function of the
category. This means telemetry has to be updated to not include memory-infra,
which i am not changing in this CL. So, will prepare new CL for that.

[ssid, 2015/08/24 22:53:22]

Hm, this is true even after the change, right? The change is going to be:
if memory-infra is enabled, if dump config is specified, use that, if not
specified, do not disable periodic dumps and use default config. This still
means if config is specified then category should be enabled.

+  // disabled-by-default-memory-infra category is enabled.

[Primiano Tucci (use gerrit), 2015/08/25 18:27:37]

Had offline chat, remove this comment

[ssid, 2015/08/26 10:19:51]

Done.

   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.
   const StringList& GetSyntheticDelayValues() const;
@@ skipping 17 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_