Enable overlapping, usage counted SetEnabled()/SetDisabled() for TraceLog

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 328 matching lines @@
   if (notification_)
     callback_copy_.Run(notification_);
 }
 
 // static
 TraceLog* TraceLog::GetInstance() {
   return Singleton<TraceLog, StaticMemorySingletonTraits<TraceLog> >::get();
 }
 
 TraceLog::TraceLog()
-    : enabled_(false),
+    : enable_count_(0),
       dispatching_to_observer_list_(false),
       watch_category_(NULL) {
   // Trace is enabled or disabled on one thread while other threads are
   // accessing the enabled flag. We don't care whether edge-case events are
   // traced or not, so we allow races on the enabled flag to keep the trace
   // macros fast.
   // TODO(jbates): ANNOTATE_BENIGN_RACE_SIZED crashes windows TSAN bots:
   // ANNOTATE_BENIGN_RACE_SIZED(g_category_enabled, sizeof(g_category_enabled),
   //                            "trace_event category enabled");
   for (int i = 0; i < TRACE_EVENT_MAX_CATEGORIES; ++i) {
@@ skipping 77 matching lines @@
         "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_) {
+      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);
         }
       } else {
@@ skipping 12 matching lines @@
 
 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) {
   AutoLock lock(lock_);
-  if (enabled_)
+
+  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);
+    } 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);
+    }
     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);
   else
     EnableMatchingCategories(excluded_categories_, 0, CATEGORY_ENABLED);
 }
 
@@ skipping 15 matching lines @@
     else
       excluded.push_back(category);
   }
   SetEnabled(included, excluded);
 }
 
 void TraceLog::GetEnabledTraceCategories(
     std::vector<std::string>* included_out,
     std::vector<std::string>* excluded_out) {
   AutoLock lock(lock_);
-  if (enabled_) {
+  if (enable_count_) {
     *included_out = included_categories_;
     *excluded_out = excluded_categories_;
   }
 }
 
 void TraceLog::SetDisabled() {
   AutoLock lock(lock_);
-  if (!enabled_)
+  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;
 
-  enabled_ = false;
   included_categories_.clear();
   excluded_categories_.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 216 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