Allow tracing categories to default to disabled.

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 885 matching lines @@
 void TraceLog::SetEnabled(const CategoryFilter& category_filter,
                           Options options) {
   AutoLock lock(lock_);
 
   if (enable_count_++ > 0) {
     if (options != trace_options_) {
       DLOG(ERROR) << "Attemting to re-enable tracing with a different "
                   << "set of options.";
     }
 
-    // Tracing is already enabled, so just merge in enabled categories.
-    // We only expand the set of enabled categories upon nested SetEnable().
-    if (category_filter_.HasIncludedPatterns() &&
-        category_filter.HasIncludedPatterns()) {
-      category_filter_.Merge(category_filter);
-    } else {
-      // If either old or new included categories are empty, allow all events.
-      category_filter_.Clear();
-    }
+    category_filter_.Merge(category_filter);
     EnableIncludedCategoryGroups();
     return;
   }
 
   if (options != trace_options_) {
     trace_options_ = options;
     logged_events_.reset(GetTraceBuffer());
   }
 
   if (dispatching_to_observer_list_) {
@@ skipping 375 matching lines @@
   time_offset_ = offset;
 }
 
 bool CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
     const std::string& str) {
   return  str.empty() ||
           str.at(0) == ' ' ||
           str.at(str.length() - 1) == ' ';
 }
 
-static bool DoesCategoryGroupContainCategory(const char* category_group,
-                                             const char* category) {
+bool CategoryFilter::DoesCategoryGroupContainCategory(
+    const char* category_group,
+    const char* category) const {
   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(!CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
         category_group_token))
         << "Disallowed category string";
     if (MatchPattern(category_group_token.c_str(), category))
       return true;
   }
   return false;
 }
 
 // Enable everything but debug and test categories by default.
 const char* CategoryFilter::kDefaultCategoryFilterString = "-*Debug,-*Test";
 
 CategoryFilter::CategoryFilter(const std::string& filter_string) {
   if (!filter_string.empty())
     Initialize(filter_string);
   else
     Initialize(CategoryFilter::kDefaultCategoryFilterString);
 }
 
 CategoryFilter::CategoryFilter(const CategoryFilter& cf)
     : included_(cf.included_),
+      disabled_(cf.disabled_),
       excluded_(cf.excluded_) {
 }
 
 CategoryFilter::~CategoryFilter() {
 }
 
 CategoryFilter& CategoryFilter::operator=(const CategoryFilter& rhs) {
   if (this == &rhs)
     return *this;
 
   included_ = rhs.included_;
+  disabled_ = rhs.disabled_;
   excluded_ = rhs.excluded_;
   return *this;
 }
 
 void CategoryFilter::Initialize(const std::string& filter_string) {
   // Tokenize list of categories, delimited by ','.
   StringTokenizer tokens(filter_string, ",");
   // Add each token to the appropriate list (included_,excluded_).
   while (tokens.GetNext()) {
     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);
       excluded_.push_back(category);
+    } else if (category.compare(0, strlen(TRACE_DISABLED_BY_DEFAULT("")),
+                                TRACE_DISABLED_BY_DEFAULT("")) == 0) {
+      disabled_.push_back(category);
     } else {
       included_.push_back(category);
     }
   }
 }
 
-void CategoryFilter::WriteString(std::string* out,
+void CategoryFilter::WriteString(const StringList& values,
+                                 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();
-  }
-
-  // Prepend commas for all excluded categories IF we have included categories.
-  bool prepend_comma_for_first_excluded = !included && !included_.empty();
+  bool prepend_comma = !out->empty();
   int token_cnt = 0;
-  for (; ci != end; ++ci) {
-    if (token_cnt > 0 || prepend_comma_for_first_excluded)
+  for (StringList::const_iterator ci = values.begin();
+       ci != values.end(); ++ci) {
+    if (token_cnt > 0 || prepend_comma)
       StringAppendF(out, ",");
     StringAppendF(out, "%s%s", (included ? "" : "-"), ci->c_str());
     ++token_cnt;
   }
 }
 
 std::string CategoryFilter::ToString() const {
   std::string filter_string;
-  WriteString(&filter_string, true);
-  WriteString(&filter_string, false);
-
+  WriteString(included_, &filter_string, true);
+  WriteString(disabled_, &filter_string, true);
+  WriteString(excluded_, &filter_string, false);
   return filter_string;
 }
 
 bool CategoryFilter::IsCategoryGroupEnabled(
     const char* category_group_name) 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) {
+  StringList::const_iterator ci;
+
+  // Check the disabled- filters and the disabled-* wildcard first so that a
+  // "*" filter does not include the disabled.
+  for (ci = disabled_.begin(); ci != disabled_.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,
+                                       TRACE_DISABLED_BY_DEFAULT("*")))
+    return false;
+
+  for (ci = included_.begin(); ci != included_.end(); ++ci) {
+    if (DoesCategoryGroupContainCategory(category_group_name, ci->c_str()))
+      return true;
+  }
+
+  for (ci = excluded_.begin(); 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::HasIncludedPatterns() const {
   return !included_.empty();
 }
 
+void CategoryFilter::Merge(const CategoryFilter& nested_filter) {
+  // Keep included patterns only if both filters have an included entry.
+  // Otherwise, one of the filter was specifying "*" and we want to honour the
+  // broadest filter.
+  if (HasIncludedPatterns() && nested_filter.HasIncludedPatterns()) {
+    included_.insert(included_.end(),
+                     nested_filter.included_.begin(),
+                     nested_filter.included_.end());
+  } else {
+    included_.clear();
+  }
+
+  disabled_.insert(disabled_.end(),
+                   nested_filter.disabled_.begin(),
+                   nested_filter.disabled_.end());
+  excluded_.insert(excluded_.end(),
+                   nested_filter.excluded_.begin(),
+                   nested_filter.excluded_.end());
+}
+
 void CategoryFilter::Clear() {
   included_.clear();
+  disabled_.clear();
   excluded_.clear();
 }
 
 }  // namespace debug
 }  // namespace base
 
 namespace trace_event_internal {
 
 ScopedTrace::ScopedTrace(
     TRACE_EVENT_API_ATOMIC_WORD* event_uid, const char* name) {
@@ skipping 35 matching lines @@
         NULL,                    // arg_names
         NULL,                    // arg_types
         NULL,                    // arg_values
         NULL,                    // convertable values
         TRACE_EVENT_FLAG_NONE);  // flags
   }
 }
 
 }  // namespace trace_event_internal