[Startup Tracing] The TraceConfig class [STALE]

base/trace_event/trace_event_impl.h

 // Copyright (c) 2012 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_EVENT_IMPL_H_
 #define BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
 
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
+#include "base/values.h"
 
 // Older style trace macros with explicit id and extra data
 // Only these macros result in publishing data to ETW as currently implemented.
 // TODO(georgesak): Update/replace these with new ETW macros.
 #define TRACE_EVENT_BEGIN_ETW(name, id, extra) \
     base::trace_event::TraceLog::AddTraceEventEtw( \
         TRACE_EVENT_PHASE_BEGIN, \
         name, reinterpret_cast<const void*>(id), extra)
 
 #define TRACE_EVENT_END_ETW(name, id, extra) \
     base::trace_event::TraceLog::AddTraceEventEtw( \
         TRACE_EVENT_PHASE_END, \
         name, reinterpret_cast<const void*>(id), extra)
 
 #define TRACE_EVENT_INSTANT_ETW(name, id, extra) \
     base::trace_event::TraceLog::AddTraceEventEtw( \
         TRACE_EVENT_PHASE_INSTANT, \
         name, reinterpret_cast<const void*>(id), extra)
 
 template <typename Type>
 struct DefaultSingletonTraits;
 
 namespace base {
 
 class WaitableEvent;
 class MessageLoop;
 
 namespace trace_event {
 
+class CategoryFilter;
+
 // For any argument of type TRACE_VALUE_TYPE_CONVERTABLE the provided
 // class must implement this interface.
 class BASE_EXPORT ConvertableToTraceFormat
     : public RefCounted<ConvertableToTraceFormat> {
  public:
   // Append the class info to the provided |out| string. The appended
   // data must be a valid JSON object. Strings must be properly quoted, and
   // escaped. There is no processing applied to the content after it is
   // appended.
   virtual void AppendAsTraceFormat(std::string* out) const = 0;
@@ skipping 202 matching lines @@
 
   // When all fragments have been added, call Finish to complete the JSON
   // formatted output.
   void Finish();
 
  private:
   OutputCallback output_callback_;
   bool append_comma_;
 };
 
+// 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,
+
+  // Echo to console. Events are discarded.
+  ECHO_TO_CONSOLE,
+
+  // Record until the trace buffer is full, but with a huge buffer size.
+  RECORD_AS_MUCH_AS_POSSIBLE
+};
+
+struct BASE_EXPORT TraceOptions {
+  TraceOptions()
+      : record_mode(RECORD_UNTIL_FULL),
+        enable_sampling(false),
+        enable_systrace(false) {}
+
+  explicit TraceOptions(TraceRecordMode record_mode)
+      : record_mode(record_mode),
+        enable_sampling(false),
+        enable_systrace(false) {}
+
+  // |options_string| is a comma-delimited list of trace options.
+  // Possible options are: "record-until-full", "record-continuously",
+  // "trace-to-console", "enable-sampling" and "enable-systrace".
+  // The first 3 options are trace recoding modes and hence
+  // mutually exclusive. If more than one trace recording modes appear in the
+  // options_string, the last one takes precedence. If none of the trace
+  // recording mode is specified, recording mode is RECORD_UNTIL_FULL.
+  //
+  // The trace option will first be reset to the default option
+  // (record_mode set to RECORD_UNTIL_FULL, enable_sampling and enable_systrace
+  // set to false) before options parsed from |options_string| are applied on
+  // it.
+  // If |options_string| is invalid, the final state of trace_options is
+  // undefined.
+  //
+  // Example: trace_options.SetFromString("record-until-full")
+  // Example: trace_options.SetFromString(
+  //              "record-continuously, enable-sampling")
+  // Example: trace_options.SetFromString("record-until-full, trace-to-console")
+  // will set ECHO_TO_CONSOLE as the recording mode.
+  //
+  // Returns true on success.
+  bool SetFromString(const std::string& options_string);
+
+  std::string ToString() const;
+
+  TraceRecordMode record_mode;
+  bool enable_sampling;
+  bool enable_systrace;
+};
+
+class BASE_EXPORT TraceConfig {

[dsinclair, 2015/05/21 13:42:08]

This file is getting pretty big, lets split these classes out to their own
files.

[Zhen Wang, 2015/05/22 23:38:04]

I move TraceConfig, CategoryFilter and TraceOptions to trace_config.h now. In
the next CL, the implementation of CategoryFilter and TraceOptions will be
removed. All the references to them will be updated to TraceConfig.

+ public:
+  typedef std::vector<std::string> StringList;
+
+  TraceConfig();
+
+  // Create TraceConfig object from CategoryFilter and TraceOptions.
+  TraceConfig(const CategoryFilter& cf, const TraceOptions& options);
+
+  // Create TraceConfig object from category filter and trace options strings.
+  TraceConfig(const std::string& category_filter_string,
+              const std::string& trace_options_string);
+
+  // |config_string| is a dictionary formatted as a JSON string, containing both
+  // category filters and trace options.
+  explicit TraceConfig(const std::string& config_string);
+
+  explicit 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;
+
+  // Convert TraceConfig to the dict representation of the TraceConfig.
+  void ToDict(base::DictionaryValue& dict) const;
+
+  // Writes the string representation of the TraceConfig. The string is JSON
+  // formatted.
+  std::string ToString() const;
+
+  // Write the string representation of the CategoryFilter part.
+  std::string ToCategoryFilterString() const;
+
+  // Write the string representation of the TraceOptions part.
+  std::string ToTraceOptionsString() const;
+
+  // 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();
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(TraceConfigTest, TraceConfigFromValidLegacyStrings);
+  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 class CategoryFilter;
+
+  void Initialize(const std::string& config_string);
+
+  // The default trace config, used when none is provided.
+  // Allows all categories through, except if they end in the suffix 'Debug' or
+  // 'Test'.

[dsinclair, 2015/05/21 13:42:08]

I still think this comment is wrong. It doesn't allow all categories through, it
allows all non-disabled-by-default categories through, right?

[Zhen Wang, 2015/05/22 23:38:04]

I think the comment is correct. See TraceConfigTest.ConstructDefaultTraceConfig
in trace_config_unittest.cc

[dsinclair, 2015/05/25 13:36:02]

If the comment is correct, then the code is wrong and has to be fixed. We should
not be enabling disabled-by-default- categories by default.

+  void InitializeDefault();
+
+  void SetCategoriesFromList(StringList& categories,
+                             const base::ListValue& list);
+  void SetSyntheticDelaysFromList(StringList& delays,
+                                  const base::ListValue& list);
+  void AddCategoryToDict(base::DictionaryValue& dict,
+                         const char* param,
+                         const StringList& categories) 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_;
+  bool enable_systrace_;
+
+  StringList included_categories_;
+  StringList disabled_categories_;
+  StringList excluded_categories_;
+  StringList synthetic_delays_;
+};
+
 class BASE_EXPORT CategoryFilter {
  public:
   typedef std::vector<std::string> StringList;
 
   // The default category filter, used when none is provided.
   // Allows all categories through, except if they end in the suffix 'Debug' or
   // 'Test'.
   static const char kDefaultCategoryFilterString[];
 
   // |filter_string| is a comma-delimited list of category wildcards.
@@ skipping 47 matching lines @@
   // Clears both included/excluded pattern lists. This would be equivalent to
   // creating a CategoryFilter with an empty string, through the constructor.
   // i.e: CategoryFilter().
   //
   // When using an empty filter, all categories are considered included as we
   // are not excluding anything.
   void Clear();
 
  private:
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture, CategoryFilter);
+  friend class TraceConfig;
 
   // Returns true if category is enable according to this filter.
   bool IsCategoryEnabled(const char* category_name) const;
 
   static bool IsEmptyOrContainsLeadingOrTrailingWhitespace(
       const std::string& str);
 
   void Initialize(const std::string& filter_string);
   void WriteString(const StringList& values,
                    std::string* out,
                    bool included) const;
   void WriteString(const StringList& delays, std::string* out) const;
   bool HasIncludedPatterns() const;
 
-  StringList included_;
-  StringList disabled_;
-  StringList excluded_;
-  StringList delays_;
+  TraceConfig config_;
 };
 
 class TraceSamplingThread;
 
-// 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,
-
-  // Echo to console. Events are discarded.
-  ECHO_TO_CONSOLE,
-
-  // Record until the trace buffer is full, but with a huge buffer size.
-  RECORD_AS_MUCH_AS_POSSIBLE
-};
-
-struct BASE_EXPORT TraceOptions {
-  TraceOptions()
-      : record_mode(RECORD_UNTIL_FULL),
-        enable_sampling(false),
-        enable_systrace(false) {}
-
-  explicit TraceOptions(TraceRecordMode record_mode)
-      : record_mode(record_mode),
-        enable_sampling(false),
-        enable_systrace(false) {}
-
-  // |options_string| is a comma-delimited list of trace options.
-  // Possible options are: "record-until-full", "record-continuously",
-  // "trace-to-console", "enable-sampling" and "enable-systrace".
-  // The first 3 options are trace recoding modes and hence
-  // mutually exclusive. If more than one trace recording modes appear in the
-  // options_string, the last one takes precedence. If none of the trace
-  // recording mode is specified, recording mode is RECORD_UNTIL_FULL.
-  //
-  // The trace option will first be reset to the default option
-  // (record_mode set to RECORD_UNTIL_FULL, enable_sampling and enable_systrace
-  // set to false) before options parsed from |options_string| are applied on
-  // it.
-  // If |options_string| is invalid, the final state of trace_options is
-  // undefined.
-  //
-  // Example: trace_options.SetFromString("record-until-full")
-  // Example: trace_options.SetFromString(
-  //              "record-continuously, enable-sampling")
-  // Example: trace_options.SetFromString("record-until-full, trace-to-console")
-  // will set ECHO_TO_CONSOLE as the recording mode.
-  //
-  // Returns true on success.
-  bool SetFromString(const std::string& options_string);
-
-  std::string ToString() const;
-
-  TraceRecordMode record_mode;
-  bool enable_sampling;
-  bool enable_systrace;
-};
-
 struct BASE_EXPORT TraceLogStatus {
   TraceLogStatus();
   ~TraceLogStatus();
   size_t event_capacity;
   size_t event_count;
 };
 
 class BASE_EXPORT TraceLog {
  public:
   enum Mode {
@@ skipping 379 matching lines @@
   subtle::AtomicWord generation_;
   bool use_worker_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_