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 IsTagInCategory(const char* tag_expr, const char* category) {
+  CStringTokenizer tokens(category, category + strlen(category), ",");
+  while (tokens.GetNext()) {
+    if (MatchPattern(tokens.token().c_str(), tag_expr))
+      return true;
+  }
+  return false;
+}
+
+// A tag composite category name would be something like: "webkit,input"
+static bool IsTagCompositeCategory(const char* category) {
+  return strchr(category, ',');
+}
+
 static void EnableMatchingCategory(int category_index,

[nduca, 2013/01/09 09:43:33]

I'd like to update the naming convention throughout this file to be more obvious
what a given std::string is. FOr exmaple you have patterns passed in here --- is
that patterns on tags, or patterns on categories?

                                    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;
+  bool has_matching_tag = false;
+  bool is_tag_composite_category =
+                          IsTagCompositeCategory(g_categories[category_index]);
   for (; ci != patterns.end(); ++ci) {
     is_match = MatchPattern(g_categories[category_index], ci->c_str());
-    if (is_match)

[nduca, 2013/01/09 09:43:33]

cant you make this just a change to MatchPattern? This code is insanely hard to
read. Figure out some way to make this read cleanly!

Maybe MatchPattern should be more like IsTagPatternAMatchForCategoryString()?

+    has_matching_tag = is_tag_composite_category &&
+                       IsTagInCategory(ci->c_str(),
+                                       g_categories[category_index]);
+
+    if (is_match || has_matching_tag)
       break;
   }
-  g_category_enabled[category_index] = is_match ?
+  g_category_enabled[category_index] = is_match || has_matching_tag ?
       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) {
   for (int i = 0; i < g_category_index; i++)
@@ skipping 362 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