Configure synthetic delays through TraceLog

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 265 matching lines @@
   // formatted output.
   void Finish();
 
  private:
   OutputCallback output_callback_;
   bool append_comma_;
 };
 
 class BASE_EXPORT CategoryFilter {
  public:
+  typedef std::pair<std::string, std::string> DelayValue;
+  typedef std::vector<DelayValue> DelayValueList;
+
   // 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.
   // 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.
   //
   // Example: CategoryFilter"test_MyTest*");
   // Example: CategoryFilter("test_MyTest*,test_OtherStuff");
   // Example: CategoryFilter("-excluded_category1,-excluded_category2");
   // Example: CategoryFilter("-*,webkit"); would disable everything but webkit.
   // Example: CategoryFilter("-webkit"); would enable everything but webkit.
+  //
+  // Category filters can also be used to configure synthetic delays.
+  //
+  // Example: CategoryFilter("gpu.SwapBuffers=16"); would make swap buffers
+  //          always take at least 16 ms.
+  // Example: CategoryFilter("gpu.SwapBuffers=16;oneshot"); would make swap
+  //          buffers take at least 16 ms the first time it is called.
+  // Example: CategoryFilter("gpu.SwapBuffers=16;alternating"); would make swap
+  //          buffers take at least 16 ms every other time it is called.
   explicit CategoryFilter(const std::string& filter_string);
 
   CategoryFilter(const CategoryFilter& cf);
 
   ~CategoryFilter();
 
   CategoryFilter& operator=(const CategoryFilter& rhs);
 
   // Writes the string representation of the CategoryFilter. This is a comma
   // separated string, similar in nature to the one used to determine
   // enabled/disabled category patterns, except here there is an arbitrary
   // order, included categories go first, then excluded categories. Excluded
   // categories are distinguished from included categories by the prefix '-'.
   std::string ToString() const;
 
   // Determines whether category group would be enabled or
   // disabled by this category filter.
   bool IsCategoryGroupEnabled(const char* category_group) const;
 
+  // Return a list of the synthetic delays specified in this category filter.
+  const DelayValueList& GetSyntheticDelayValues() const;
+
   // Merges nested_filter with the current CategoryFilter
   void Merge(const CategoryFilter& nested_filter);
 
   // 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);
 
   static bool IsEmptyOrContainsLeadingOrTrailingWhitespace(
       const std::string& str);
 
   typedef std::vector<std::string> StringList;
 
   void Initialize(const std::string& filter_string);
   void WriteString(const StringList& values,
                    std::string* out,
                    bool included) const;
+  void WriteString(const DelayValueList& delays, std::string* out) const;
   bool HasIncludedPatterns() const;
 
   bool DoesCategoryGroupContainCategory(const char* category_group,
                                         const char* category) const;
 
   StringList included_;
   StringList disabled_;
   StringList excluded_;
+  DelayValueList delays_;
 };
 
 class TraceSamplingThread;
 
 class BASE_EXPORT TraceLog {
  public:
   // Options determines how the trace buffer stores data.
   enum Options {
     // Record until the trace buffer is full.
     RECORD_UNTIL_FULL = 1 << 0,
@@ skipping 231 matching lines @@
   friend struct DefaultSingletonTraits<TraceLog>;
 
   // Enable/disable each category group based on the current enabled_,
   // category_filter_, event_callback_ and event_callback_category_filter_.
   // Enable the category group if enabled_ is true and 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(int category_index);
 
+  // Configure synthetic delays based on the values set in the current
+  // category filter.
+  void UpdateSyntheticDelaysFromCategoryFilter();
+
   class ThreadLocalEventBuffer;
   class OptionalAutoLock;
 
   TraceLog();
   ~TraceLog();
   const unsigned char* GetCategoryGroupEnabledInternal(const char* name);
   void AddMetadataEventsWhileLocked();
 
   TraceBuffer* trace_buffer() const { return logged_events_.get(); }
   TraceBuffer* CreateTraceBuffer();
@@ skipping 99 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_