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,

[nduca, 2013/01/28 08:15:28]

So this would be DoesCategoryGroupContainCategory

+                              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 spacing:
+    // i.e: "webkit, input" or "webkit , input".
+    TrimWhitespaceASCII(tag_tokens.token(), TRIM_ALL, &trimmed_tag);

[rterrazas, 2013/01/18 17:44:18]

I'm thinking that maybe checking if we have leading or trailing whitespace
before trimming the string, just to save us a bit of time if not.

+    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 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 (enable_count_) {
-        // 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) {
   AutoLock lock(lock_);
-
   if (enable_count_++ > 0) {
-    // Tracing is already enabled, so just merge in enabled categories.
+    // Tracing is already enabled, so just merge in enabled categories
     // We only expand the set of enabled categories upon nested SetEnable().
-    if (!included_categories_.empty() && !included_categories.empty()) {
-      included_categories_.insert(included_categories_.end(),
-                                  included_categories.begin(),
-                                  included_categories.end());
-      EnableMatchingCategories(included_categories_, CATEGORY_ENABLED, 0);
+    if (!included_tag_patterns_.empty() && !included_tag_patterns.empty()) {
+      included_tag_patterns_.insert(included_tag_patterns_.end(),
+                                  included_tag_patterns.begin(),
+                                  included_tag_patterns.end());
+      EnableMatchingCategories(included_tag_patterns_, CATEGORY_ENABLED, 0);
     } else {
       // If either old or new included categories are empty, allow all events.
-      included_categories_.clear();
-      excluded_categories_.clear();
-      EnableMatchingCategories(excluded_categories_, 0, CATEGORY_ENABLED);
+      included_tag_patterns_.clear();
+      excluded_tag_patterns_.clear();
+      EnableMatchingCategories(excluded_tag_patterns_, 0, CATEGORY_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);
-  included_categories_ = included_categories;
-  excluded_categories_ = excluded_categories;
-  // Note that if both included and excluded_categories are empty, the else
+  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_categories_.empty())
-    EnableMatchingCategories(included_categories_, CATEGORY_ENABLED, 0);
+  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 tag patterns 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 (enable_count_) {
-    *included_out = included_categories_;
-    *excluded_out = excluded_categories_;
+    *included_out = included_tag_patterns_;
+    *excluded_out = excluded_tag_patterns_;
   }
 }
 
 void TraceLog::SetDisabled() {
   AutoLock lock(lock_);
   DCHECK(enable_count_ > 0);
   if (--enable_count_ != 0)
     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;
 
-  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