Refactor trace_event_impl's SetEnabled to use TraceOptions. Propagate this through the whole stack.

base/debug/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_DEBUG_TRACE_EVENT_IMPL_H_
 #define BASE_DEBUG_TRACE_EVENT_IMPL_H_
 
 #include <stack>
 #include <string>
@@ skipping 346 matching lines @@
                                         const char* category) const;
 
   StringList included_;
   StringList disabled_;
   StringList excluded_;
   StringList delays_;
 };
 
 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,
+};
+
+struct BASE_EXPORT TraceOptions {
+
+  TraceOptions()
+      : record_mode(RECORD_UNTIL_FULL),
+        enable_sampling(false),
+        enable_systrace(false) {}
+
+  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.
+  //
+  // Example: TraceOptions("record-until-full")
+  // Example: TraceOptions("record-continuously, enable-sampling")
+  // Example: TraceOptions("record-until-full, trace-to-console") would have
+  //          ECHO_TO_CONSOLE as the recording mode.
+  explicit TraceOptions(const std::string& options_string);
+
+  std::string ToString() const;
+
+  TraceRecordMode record_mode;
+  bool enable_sampling;
+  bool enable_systrace;
+};
+
 class BASE_EXPORT TraceLog {
  public:
   enum Mode {
     DISABLED = 0,
     RECORDING_MODE,
     MONITORING_MODE,
   };
 
-  // Options determines how the trace buffer stores data.
-  enum Options {
-    // Record until the trace buffer is full.
-    RECORD_UNTIL_FULL = 1 << 0,
-
-    // 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 = 1 << 1,
-
-    // Enable the sampling profiler in the recording mode.
-    ENABLE_SAMPLING = 1 << 2,
-
-    // Echo to console. Events are discarded.
-    ECHO_TO_CONSOLE = 1 << 3,
-  };
-
   // The pointer returned from GetCategoryGroupEnabledInternal() points to a
   // value with zero or more of the following bits. Used in this class only.
   // The TRACE_EVENT macros should only use the value as a bool.
   // These values must be in sync with macro values in TraceEvent.h in Blink.
   enum CategoryGroupEnabledFlags {
     // Category group enabled for the recording mode.
     ENABLED_FOR_RECORDING = 1 << 0,
     // Category group enabled for the monitoring mode.
     ENABLED_FOR_MONITORING = 1 << 1,
     // Category group enabled by SetEventCallbackEnabled().
     ENABLED_FOR_EVENT_CALLBACK = 1 << 2,
   };
 
   static TraceLog* GetInstance();
 
   // Get set of known category groups. This can change as new code paths are
   // reached. The known category groups are inserted into |category_groups|.
   void GetKnownCategoryGroups(std::vector<std::string>* category_groups);
 
   // Retrieves a copy (for thread-safety) of the current CategoryFilter.
   CategoryFilter GetCurrentCategoryFilter();
 
-  Options trace_options() const {
-    return static_cast<Options>(subtle::NoBarrier_Load(&trace_options_));
-  }
+  // Retrieves a copy (for thread-safety) of the current TraceOptions.
+  TraceOptions GetCurrentTraceOptions() const;
 
   // Enables normal tracing (recording trace events in the trace buffer).
   // See CategoryFilter comments for details on how to control what categories
   // will be traced. If tracing has already been enabled, |category_filter| will
   // be merged into the current category filter.
   void SetEnabled(const CategoryFilter& category_filter,
-                  Mode mode, Options options);
+                  Mode mode, const TraceOptions& options);
 
   // Disables normal tracing for all categories.
   void SetDisabled();
 
   bool IsEnabled() { return mode_ != DISABLED; }
 
   // The number of times we have begun recording traces. If tracing is off,
   // returns -1. If tracing is on, then it returns the number of times we have
   // recorded a trace. By watching for this number to increment, you can
   // passively discover when a new trace has begun. This is then used to
@@ skipping 159 matching lines @@
   void SetTimeOffset(TimeDelta offset);
 
   size_t GetObserverCountForTest() const;
 
   // Call this method if the current thread may block the message loop to
   // prevent the thread from using the thread-local buffer because the thread
   // may not handle the flush request in time causing lost of unflushed events.
   void SetCurrentThreadBlocksMessageLoop();
 
  private:
+  typedef unsigned int InternalTraceOptions;
+
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferGetReturnChunk);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferHalfIteration);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferFullIteration);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferVectorReportFull);
+  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
+                           ConvertTraceOptionsToInternalOptions);
+
 
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
   friend struct DefaultSingletonTraits<TraceLog>;
 
   // Enable/disable each category group based on the current mode_,
   // category_filter_, event_callback_ and event_callback_category_filter_.
   // Enable the category group in the enabled mode if category_filter_ matches
   // the category group, or event_callback_ is not null and
   // event_callback_category_filter_ matches the category group.
   void UpdateCategoryGroupEnabledFlags();
   void UpdateCategoryGroupEnabledFlag(size_t category_index);
 
   // Configure synthetic delays based on the values set in the current
   // category filter.
   void UpdateSyntheticDelaysFromCategoryFilter();
 
+  InternalTraceOptions GetInternalOptionsFromTraceOptions(
+      const TraceOptions& options);
+
   class ThreadLocalEventBuffer;
   class OptionalAutoLock;
 
   TraceLog();
   ~TraceLog();
   const unsigned char* GetCategoryGroupEnabledInternal(const char* name);
   void AddMetadataEventsWhileLocked();
 
+  InternalTraceOptions trace_options() const {
+    return static_cast<InternalTraceOptions>(
+        subtle::NoBarrier_Load(&trace_options_));
+  }
+
   TraceBuffer* trace_buffer() const { return logged_events_.get(); }
   TraceBuffer* CreateTraceBuffer();
   TraceBuffer* CreateTraceBufferVectorOfSize(size_t max_chunks);
 
   std::string EventToConsoleMessage(unsigned char phase,
                                     const TimeTicks& timestamp,
                                     TraceEvent* trace_event);
 
   TraceEvent* AddEventToThreadSharedChunkWhileLocked(TraceEventHandle* handle,
                                                      bool check_buffer_is_full);
@@ skipping 19 matching lines @@
   }
   void UseNextTraceBuffer();
 
   TimeTicks OffsetNow() const {
     return OffsetTimestamp(TimeTicks::NowFromSystemTraceTime());
   }
   TimeTicks OffsetTimestamp(const TimeTicks& timestamp) const {
     return timestamp - time_offset_;
   }
 
+  // Internal representation of trace options since we store the currently used
+  // trace option as an AtomicWord.
+  static const InternalTraceOptions kInternalNone;
+  static const InternalTraceOptions kInternalRecordUntilFull;
+  static const InternalTraceOptions kInternalRecordContinuously;
+  static const InternalTraceOptions kInternalEchoToConsole;
+  static const InternalTraceOptions kInternalEnableSampling;
+
   // This lock protects TraceLog member accesses (except for members protected
   // by thread_info_lock_) from arbitrary threads.
   mutable Lock lock_;
   // This lock protects accesses to thread_names_, thread_event_start_times_
   // and thread_colors_.
   Lock thread_info_lock_;
   int locked_line_;
   Mode mode_;
   int num_traces_recorded_;
   scoped_ptr<TraceBuffer> logged_events_;
@@ skipping 53 matching lines @@
   scoped_refptr<MessageLoopProxy> flush_message_loop_proxy_;
   subtle::AtomicWord generation_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_