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 378 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 void EnableMatchingCategory(int category_index,
-                                   const std::vector<std::string>& patterns,
-                                   unsigned char matched_value,
-                                   unsigned char unmatched_value) {
-  std::vector<std::string>::const_iterator ci = patterns.begin();
-  bool is_match = false;
-  for (; ci != patterns.end(); ++ci) {
-    is_match = MatchPattern(g_categories[category_index], ci->c_str());
-    if (is_match)
-      break;
-  }
-  g_category_enabled[category_index] = is_match ?
-      matched_value : unmatched_value;
+void TraceLog::EnableIncludedCategoryGroup(int category_index,
+                              const CategoryFilter& category_filter) {
+  bool is_enabled =
+      category_filter.IsCategoryGroupEnabled(g_categories[category_index]);
+  g_category_enabled[category_index] = is_enabled ?
+      TraceLog::CATEGORY_ENABLED : 0;
 }
 
-// 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) {
+void TraceLog::EnableIncludedCategoryGroups(
+                                        const CategoryFilter& category_filter) {
   for (int i = 0; i < g_category_index; i++)
-    EnableMatchingCategory(i, patterns, matched_value, unmatched_value);
+    EnableIncludedCategoryGroup(i, category_filter);
 }
 
 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 = 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
-        // else clause below excludes nothing, thereby enabling this category.
-        if (!included_categories_.empty()) {
-          EnableMatchingCategory(new_index, included_categories_,
-                                 CATEGORY_ENABLED, 0);
-        } else {
-          EnableMatchingCategory(new_index, excluded_categories_,
-                                 0, CATEGORY_ENABLED);
-        }
+        // Note that if both included and excluded patterns in the
+        // CategoryFilter are empty, we exclude nothing,
+        // thereby enabling this category group.
+        EnableIncludedCategoryGroup(new_index, category_filter_);
       } 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) {
+static bool DoesCategoryGroupContainCategory(const char* category_group,
+                                             const char* category) {

[rterrazas, 2013/02/21 04:08:05]

So...I was thinking, I'd like to change this to something like
IsCategoryPatternContained(container, category_pattern) and then consume this
method from IsCategoryEnabled(...). 

wdyt?

[nduca, 2013/02/22 19:55:19]

This sounds like a metho don the CategoryFilter object, no?
DoesCategoryGroupContainCategory(const char* group) or something or other.

+  DCHECK(category);
+  CStringTokenizer category_group_tokens(category_group,
+                          category_group + strlen(category_group), ",");
+  while (category_group_tokens.GetNext()) {
+    std::string category_group_token = category_group_tokens.token();
+    // Don't allow empty tokens, nor tokens with leading or trailing space.
+    DCHECK(!category_group_token.empty() &&
+            category_group_token.at(0) != ' '&&
+            category_group_token.at(category_group_token.length() - 1) != ' ')
+            << "Disallowed category string";
+    if (MatchPattern(category_group_token.c_str(), category))
+      return true;
+  }
+  return false;
+}
+
+const char* CategoryFilter::kDefaultCategoryFilterString = "-*Debug,-*Test";
+
+CategoryFilter::CategoryFilter() {
+  Initialize(CategoryFilter::kDefaultCategoryFilterString);
+}
+
+CategoryFilter::CategoryFilter(const std::string& filter_string) {
+  Initialize(filter_string);
+}
+
+void CategoryFilter::Initialize(const std::string& filter_string) {
+  // Pass 1: Tokenize list of categories, delimited by ','.
+  StringTokenizer tokens(filter_string, ",");
+  while (tokens.GetNext()) {
+    bool is_included = true;
+    std::string category = tokens.token();
+    // Ignore empty categories.
+    if(category.empty())
+      continue;
+    // Excluded categories start with '-'.
+    if (category.at(0) == '-') {
+      // Remove '-' from category string.
+      category = category.substr(1);
+      is_included = false;
+    }
+    if (is_included)
+      included_.push_back(category);
+    else
+      excluded_.push_back(category);
+  }
+}
+
+void CategoryFilter::WriteString(std::string* out,
+                                 bool included) const {
+  std::vector<std::string>::const_iterator ci;
+  std::vector<std::string>::const_iterator end;
+  if (included) {
+    ci = included_.begin();
+    end = included_.end();
+  } else {
+    ci = excluded_.begin();
+    end = excluded_.end();
+  }
+
+  for (; ci != end; ++ci) {
+    if (included)
+      StringAppendF(out, "%s,", ci->c_str());
+    else
+      StringAppendF(out, "-%s,", ci->c_str());
+  }
+}
+
+void CategoryFilter::ToString(std::string* filter_string) const {
+  WriteString(filter_string, true);
+  WriteString(filter_string, false);
+}
+
+bool CategoryFilter::IsCategoryGroupEnabled(const char* category_group_name)

[rterrazas, 2013/02/20 02:40:06]

This does a lot of the work that was done through
EnableMatching...(..,CATEGORY_ENABLED, 0)/EnableMatching...(..,0,
CATEGORY_ENABLED).

I almost did things that way, but we gained no more readability IMHO, but this
is simpler to read IMHO, anyhow...Lmkwyt.

+                                                                         const {
+  // TraceLog should call this method only as  part of enabling/disabling
+  // categories.
+  std::vector<std::string>::const_iterator ci = included_.begin();
+  for (; ci != included_.end(); ++ci) {
+    if (DoesCategoryGroupContainCategory(category_group_name, ci->c_str()))
+      return true;
+  }
+  ci = excluded_.begin();
+  for (; ci != excluded_.end(); ++ci) {
+    if (DoesCategoryGroupContainCategory(category_group_name, ci->c_str()))
+      return false;
+  }
+  // If the category group is not excluded, and there are no included patterns
+  // we consider this pattern enabled.
+  return included_.empty();
+}
+
+void CategoryFilter::Merge(const CategoryFilter& nested_filter) {
+ included_.insert(included_.end(),
+                  nested_filter.included_.begin(),
+                  nested_filter.included_.end());
+  excluded_.insert(excluded_.end(),
+                   nested_filter.excluded_.begin(),
+                   nested_filter.excluded_.end());
+}
+
+bool CategoryFilter::HasIncludedCategories() const {
+  return !included_.empty();
+}
+
+void CategoryFilter::Clear() {
+  included_.clear();
+  excluded_.clear();
+}
+
+void TraceLog::SetEnabled(const CategoryFilter& category_filter) {
+
+  // Actually enable/disable the categories.
   AutoLock lock(lock_);
 
   if (enable_count_++ > 0) {
     // 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 (category_filter_.HasIncludedCategories() &&
+        category_filter.HasIncludedCategories()) {
+      category_filter_.Merge(category_filter);
     } 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);
+      // If either old or new included categories are empty, allow all not
+      // excluded events.
+      category_filter_.Clear();
     }
+    EnableIncludedCategoryGroups(category_filter_);
     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
-  // clause below excludes nothing, thereby enabling all categories.
-  if (!included_categories_.empty())
-    EnableMatchingCategories(included_categories_, CATEGORY_ENABLED, 0);
-  else
-    EnableMatchingCategories(excluded_categories_, 0, CATEGORY_ENABLED);
+  category_filter_ = CategoryFilter(category_filter);
+  EnableIncludedCategoryGroups(category_filter_);
 }
 
-void TraceLog::SetEnabled(const std::string& categories) {
-  std::vector<std::string> included, excluded;
-  // Tokenize list of categories, delimited by ','.
-  StringTokenizer tokens(categories, ",");
-  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);
-      is_included = false;
-    }
-    if (is_included)
-      included.push_back(category);
-    else
-      excluded.push_back(category);
-  }
-  SetEnabled(included, excluded);
-}
-
-void TraceLog::GetEnabledTraceCategories(
-    std::vector<std::string>* included_out,
-    std::vector<std::string>* excluded_out) {
+CategoryFilter& TraceLog::GetCurrentCategoryFilter() {
   AutoLock lock(lock_);
-  if (enable_count_) {
-    *included_out = included_categories_;
-    *excluded_out = excluded_categories_;
-  }
+  DCHECK(enable_count_ > 0);
+  return category_filter_;
 }
 
 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();
+  category_filter_.Clear();
   watch_category_ = NULL;
   watch_event_name_ = "";
   for (int i = 0; i < g_category_index; i++)
     g_category_enabled[i] = 0;
   AddThreadNameMetadataEvents();
 }
 
-void TraceLog::SetEnabled(bool enabled) {
-  if (enabled)
-    SetEnabled(std::vector<std::string>(), std::vector<std::string>());
-  else
-    SetDisabled();
-}
-
 void TraceLog::AddEnabledStateObserver(EnabledStateChangedObserver* listener) {
   enabled_state_observer_list_.AddObserver(listener);
 }
 
 void TraceLog::RemoveEnabledStateObserver(
     EnabledStateChangedObserver* listener) {
   enabled_state_observer_list_.RemoveObserver(listener);
 }
 
 float TraceLog::GetBufferPercentFull() const {
@@ skipping 265 matching lines @@
         0,                       // num_args
         NULL,                    // arg_names
         NULL,                    // arg_types
         NULL,                    // arg_values
         TRACE_EVENT_FLAG_NONE);  // flags
   }
 }
 
 }  // namespace trace_event_internal