Trace category groups and category filter.

base/debug/trace_event_impl.cc

 // 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.
 
 #include "base/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 375 matching lines @@
   uintptr_t category_ptr = reinterpret_cast<uintptr_t>(category_enabled);
   DCHECK(category_ptr >= category_begin &&
          category_ptr < reinterpret_cast<uintptr_t>(g_category_enabled +
                                                TRACE_EVENT_MAX_CATEGORIES)) <<
       "out of bounds category pointer";
   uintptr_t category_index =
       (category_ptr - category_begin) / sizeof(g_category_enabled[0]);
   return g_categories[category_index];
 }
 
+static bool DoesCategoryContainMatchingTag(const char* tagged_category,

[rterrazas, 2013/01/15 08:08:31]

Implemented the support for multi tag and single tag categories, per your
suggestion, found this much cleaner.

Trimming tokens to allow whitespace between tags, seems better than having
people waste time by debugging errors caused by not supporting this.

+                              const char* tag_pattern) {
+  CStringTokenizer tag_tokens(tagged_category,
+                          tagged_category + strlen(tagged_category), ",");
+  while (tag_tokens.GetNext()) {
+    std::string trimmed_tag;
+    //Trimming tokens to allow categories with arbitrary spaces:
+    // i.e: "webkit, input" or "webkit , input".
+    TrimWhitespaceASCII(tag_tokens.token(), TRIM_ALL, &trimmed_tag);
+    if(trimmed_tag.length() == 0)
+      continue;
+    if (MatchPattern(trimmed_tag.c_str(), tag_pattern))
+      return true;
+  }
+  return false;
+}
+
 static void EnableMatchingCategory(int category_index,
-                                   const std::vector<std::string>& patterns,
+                                   const std::vector<std::string>& tag_patterns,
                                    unsigned char matched_value,
                                    unsigned char unmatched_value) {
-  std::vector<std::string>::const_iterator ci = patterns.begin();
+  std::vector<std::string>::const_iterator ci = tag_patterns.begin();
   bool is_match = false;
-  for (; ci != patterns.end(); ++ci) {
-    is_match = MatchPattern(g_categories[category_index], ci->c_str());
+  for (; ci != tag_patterns.end(); ++ci) {
+    is_match = DoesCategoryContainMatchingTag(g_categories[category_index],
+                                              ci->c_str());
+
     if (is_match)
       break;
   }
   g_category_enabled[category_index] = is_match ?
       matched_value : unmatched_value;
 }
 
-// Enable/disable each category based on the category filters in |patterns|.
-// If the category name matches one of the patterns, its enabled status is set
-// to |matched_value|. Otherwise its enabled status is set to |unmatched_value|.
-static void EnableMatchingCategories(const std::vector<std::string>& patterns,
-                                     unsigned char matched_value,
-                                     unsigned char unmatched_value) {
+// Enable/disable each category based on the category filters in |tag_patterns|.
+// If the category name contains a tag that matches one of the tag_patterns,
+// its enabled status is set to |matched_value|.
+// Otherwise its enabled status is set to |unmatched_value|.
+static void EnableMatchingCategories(
+                                  const std::vector<std::string>& tag_patterns,
+                                  unsigned char matched_value,
+                                  unsigned char unmatched_value) {
   for (int i = 0; i < g_category_index; i++)
-    EnableMatchingCategory(i, patterns, matched_value, unmatched_value);
+    EnableMatchingCategory(i, tag_patterns, matched_value, unmatched_value);
 }
 
 const unsigned char* TraceLog::GetCategoryEnabledInternal(const char* name) {
   AutoLock lock(lock_);
   DCHECK(!strchr(name, '"')) << "Category names may not contain double quote";
 
   unsigned char* category_enabled = NULL;
   // Search for pre-existing category matching this name
   for (int i = 0; i < g_category_index; i++) {
     if (strcmp(g_categories[i], name) == 0) {
       category_enabled = &g_category_enabled[i];
       break;
     }
   }
 
   if (!category_enabled) {
     // Create a new category
     DCHECK(g_category_index < TRACE_EVENT_MAX_CATEGORIES) <<
         "must increase TRACE_EVENT_MAX_CATEGORIES";
     if (g_category_index < TRACE_EVENT_MAX_CATEGORIES) {
       int new_index = g_category_index++;
       // Don't hold on to the name pointer, so that we can create categories
       // with strings not known at compile time (this is required by
       // SetWatchEvent).
       const char* new_name = base::strdup(name);
       ANNOTATE_LEAKING_OBJECT_PTR(new_name);
       g_categories[new_index] = new_name;
       DCHECK(!g_category_enabled[new_index]);
       if (enabled_) {
-        // Note that if both included and excluded_categories are empty, the
+        // Note that if both included and excluded_tag_patterns are empty, the
         // else clause below excludes nothing, thereby enabling this category.
-        if (!included_categories_.empty()) {
-          EnableMatchingCategory(new_index, included_categories_,
+        if (!included_tag_patterns_.empty()) {
+          EnableMatchingCategory(new_index, included_tag_patterns_,
                                  CATEGORY_ENABLED, 0);
         } else {
-          EnableMatchingCategory(new_index, excluded_categories_,
+          EnableMatchingCategory(new_index, excluded_tag_patterns_,
                                  0, CATEGORY_ENABLED);
         }
       } else {
         g_category_enabled[new_index] = 0;
       }
       category_enabled = &g_category_enabled[new_index];
     } else {
       category_enabled = &g_category_enabled[g_category_categories_exhausted];
     }
   }
 #if defined(OS_ANDROID)
   ApplyATraceEnabledFlag(category_enabled);
 #endif
   return category_enabled;
 }
 
 void TraceLog::GetKnownCategories(std::vector<std::string>* categories) {
   AutoLock lock(lock_);
   for (int i = 0; i < g_category_index; i++)
     categories->push_back(g_categories[i]);
 }
 
-void TraceLog::SetEnabled(const std::vector<std::string>& included_categories,
-                          const std::vector<std::string>& excluded_categories) {
+void TraceLog::SetEnabled(const std::vector<std::string>& included_tag_patterns,
+                          const std::vector<std::string>& excluded_tag_patterns) {

[rterrazas, 2013/01/15 08:08:31]

Crossed the 80 char barrier, seemed moving the parameters down seemed a bit too
ugly. 

What do you think?

[rterrazas, 2013/01/18 01:25:35]

Done.

   AutoLock lock(lock_);
   if (enabled_)
     return;
 
   if (dispatching_to_observer_list_) {
     DLOG(ERROR) <<
         "Cannot manipulate TraceLog::Enabled state from an observer.";
     return;
   }
 
   dispatching_to_observer_list_ = true;
   FOR_EACH_OBSERVER(EnabledStateChangedObserver, enabled_state_observer_list_,
                     OnTraceLogWillEnable());
   dispatching_to_observer_list_ = false;
 
   logged_events_.reserve(1024);
   enabled_ = true;
-  included_categories_ = included_categories;
-  excluded_categories_ = excluded_categories;
-  // Note that if both included and excluded_categories are empty, the else
-  // clause below excludes nothing, thereby enabling all categories.
-  if (!included_categories_.empty())
-    EnableMatchingCategories(included_categories_, CATEGORY_ENABLED, 0);
+  included_tag_patterns_ = included_tag_patterns;
+  excluded_tag_patterns_ = excluded_tag_patterns;
+  // Note that if both included and excluded_tag_patterns are empty, the
+  // else clause below excludes nothing, thereby enabling all categories.
+  if (!included_tag_patterns_.empty())
+    EnableMatchingCategories(included_tag_patterns_, CATEGORY_ENABLED, 0);
   else
-    EnableMatchingCategories(excluded_categories_, 0, CATEGORY_ENABLED);
+    EnableMatchingCategories(excluded_tag_patterns_, 0, CATEGORY_ENABLED);
 }
 
-void TraceLog::SetEnabled(const std::string& categories) {
+void TraceLog::SetEnabled(const std::string& tag_patterns) {
   std::vector<std::string> included, excluded;
-  // Tokenize list of categories, delimited by ','.
-  StringTokenizer tokens(categories, ",");
+  // Tokenize list of tag patterns, delimited by ','.
+  StringTokenizer tokens(tag_patterns, ",");
   while (tokens.GetNext()) {
     bool is_included = true;
-    std::string category = tokens.token();
-    // Excluded categories start with '-'.
-    if (category.at(0) == '-') {
-      // Remove '-' from category string.
-      category = category.substr(1);
+    std::string tag_pattern = tokens.token();
+    // Excluded tags start with '-'.
+    if (tag_pattern.at(0) == '-') {
+      // Remove '-' from tag pattern string.
+      tag_pattern = tag_pattern.substr(1);
       is_included = false;
     }
     if (is_included)
-      included.push_back(category);
+      included.push_back(tag_pattern);
     else
-      excluded.push_back(category);
+      excluded.push_back(tag_pattern);
   }
   SetEnabled(included, excluded);
 }
 
 void TraceLog::GetEnabledTraceCategories(
     std::vector<std::string>* included_out,
     std::vector<std::string>* excluded_out) {
   AutoLock lock(lock_);
   if (enabled_) {
-    *included_out = included_categories_;
-    *excluded_out = excluded_categories_;
+    *included_out = included_tag_patterns_;
+    *excluded_out = excluded_tag_patterns_;
   }
 }
 
 void TraceLog::SetDisabled() {
   AutoLock lock(lock_);
   if (!enabled_)
     return;
 
   if (dispatching_to_observer_list_) {
     DLOG(ERROR)
         << "Cannot manipulate TraceLog::Enabled state from an observer.";
     return;
   }
 
   dispatching_to_observer_list_ = true;
   FOR_EACH_OBSERVER(EnabledStateChangedObserver, enabled_state_observer_list_,
                     OnTraceLogWillDisable());
   dispatching_to_observer_list_ = false;
 
   enabled_ = false;
-  included_categories_.clear();
-  excluded_categories_.clear();
+  included_tag_patterns_.clear();
+  excluded_tag_patterns_.clear();
   watch_category_ = NULL;
   watch_event_name_ = "";
   for (int i = 0; i < g_category_index; i++)
     g_category_enabled[i] = 0;
   AddThreadNameMetadataEvents();
 #if defined(OS_ANDROID)
   AddClockSyncMetadataEvents();
 #endif
 }
 
@@ skipping 214 matching lines @@
   unsigned long long pid = static_cast<unsigned long long>(process_id_);
   process_id_hash_ = (offset_basis ^ pid) * fnv_prime;
 }
 
 void TraceLog::SetTimeOffset(TimeDelta offset) {
   time_offset_ = offset;
 }
 
 }  // namespace debug
 }  // namespace base