[tracing] Add filtering mode in TraceLog

base/trace_event/trace_log.cc

 // Copyright 2015 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/trace_event/trace_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ skipping 444 matching lines @@
 TraceLogStatus::TraceLogStatus() : event_capacity(0), event_count(0) {}
 
 TraceLogStatus::~TraceLogStatus() {}
 
 // static
 TraceLog* TraceLog::GetInstance() {
   return Singleton<TraceLog, LeakySingletonTraits<TraceLog>>::get();
 }
 
 TraceLog::TraceLog()
-    : mode_(DISABLED),
+    : enabled_modes_(0),
       num_traces_recorded_(0),
       event_callback_(0),
       dispatching_to_observer_list_(false),
       process_sort_index_(0),
       process_id_hash_(0),
       process_id_(0),
       watch_category_(0),
       trace_options_(kInternalRecordUntilFull),
       trace_config_(TraceConfig()),
       event_callback_trace_config_(TraceConfig()),
@@ skipping 77 matching lines @@
 }
 
 const char* TraceLog::GetCategoryGroupName(
     const unsigned char* category_group_enabled) {
   return g_category_groups[GetCategoryIndex(category_group_enabled)];
 }
 
 void TraceLog::UpdateCategoryGroupEnabledFlag(size_t category_index) {
   unsigned char enabled_flag = 0;
   const char* category_group = g_category_groups[category_index];
-  if (mode_ == RECORDING_MODE &&
+  if (enabled_modes_ & RECORDING_MODE &&
       trace_config_.IsCategoryGroupEnabled(category_group)) {
     enabled_flag |= ENABLED_FOR_RECORDING;
   }
 
   if (event_callback_ &&
       event_callback_trace_config_.IsCategoryGroupEnabled(category_group)) {
     enabled_flag |= ENABLED_FOR_EVENT_CALLBACK;
   }
 
 #if defined(OS_WIN)
   if (base::trace_event::TraceEventETWExport::IsCategoryGroupEnabled(
           category_group)) {
     enabled_flag |= ENABLED_FOR_ETW_EXPORT;
   }
 #endif
 
   // TODO(primiano): this is a temporary workaround for catapult:#2341,
   // to guarantee that metadata events are always added even if the category
   // filter is "-*". See crbug.com/618054 for more details and long-term fix.
-  if (mode_ == RECORDING_MODE && !strcmp(category_group, "__metadata"))
+  if (enabled_modes_ & RECORDING_MODE && !strcmp(category_group, "__metadata"))
     enabled_flag |= ENABLED_FOR_RECORDING;
 
   uint32_t enabled_filters_bitmap = 0;
   int index = 0;
-  for (const auto& event_filter : trace_config_.event_filters()) {
+  for (const auto& event_filter : enabled_event_filters_) {
     if (event_filter.IsCategoryGroupEnabled(category_group)) {
       enabled_flag |= ENABLED_FOR_FILTERING;
       DCHECK(g_category_group_filters.Get()[index]);
       enabled_filters_bitmap |= 1 << index;
     }
     if (index++ >= MAX_TRACE_EVENT_FILTERS) {
       NOTREACHED();
       break;
     }
   }
   g_category_group_filters_enabled[category_index] = enabled_filters_bitmap;
 
   g_category_group_enabled[category_index] = enabled_flag;
 }
 
 void TraceLog::UpdateCategoryGroupEnabledFlags() {
   CreateFiltersForTraceConfig();
   size_t category_index = base::subtle::NoBarrier_Load(&g_category_index);
   for (size_t i = 0; i < category_index; i++)
     UpdateCategoryGroupEnabledFlag(i);
 }
 
 void TraceLog::CreateFiltersForTraceConfig() {
+  if (!(enabled_modes_ & FILTERING_MODE))
+    return;
+
   // Filters were already added and tracing could be enabled. Filters list
   // cannot be changed when trace events are using them.
   if (g_category_group_filters.Get().size())
     return;
 
-  for (auto& event_filter : trace_config_.event_filters()) {
+  for (auto& event_filter : enabled_event_filters_) {
     if (g_category_group_filters.Get().size() >= MAX_TRACE_EVENT_FILTERS) {
       NOTREACHED()
           << "Too many trace event filters installed in the current session";
       break;
     }
 
     std::unique_ptr<TraceEventFilter> new_filter;
     if (event_filter.predicate_name() ==
         TraceEventFilter::kEventWhitelistPredicate) {
       new_filter = MakeUnique<EventNameFilter>(event_filter.filter_args());
@@ skipping 92 matching lines @@
 }
 
 void TraceLog::GetKnownCategoryGroups(
     std::vector<std::string>* category_groups) {
   AutoLock lock(lock_);
   size_t category_index = base::subtle::NoBarrier_Load(&g_category_index);
   for (size_t i = kNumBuiltinCategories; i < category_index; i++)
     category_groups->push_back(g_category_groups[i]);
 }
 
-void TraceLog::SetEnabled(const TraceConfig& trace_config, Mode mode) {
+void TraceLog::SetEnabled(const TraceConfig& trace_config, uint8_t modes) {
   std::vector<EnabledStateObserver*> observer_list;
   std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver> observer_map;
   {
     AutoLock lock(lock_);
 
     // Can't enable tracing when Flush() is in progress.
     DCHECK(!flush_task_runner_);
 
     InternalTraceOptions new_options =
         GetInternalOptionsFromTraceConfig(trace_config);
 
     InternalTraceOptions old_options = trace_options();
 
-    if (IsEnabled()) {
-      if (new_options != old_options) {
-        DLOG(ERROR) << "Attempting to re-enable tracing with a different "
-                    << "set of options.";
-      }
-
-      if (mode != mode_) {
-        DLOG(ERROR) << "Attempting to re-enable tracing with a different mode.";
-      }
-
-      DCHECK(!trace_config.event_filters().size())
-          << "Adding new filters while tracing was already enabled is not "
-             "supported.";
-
-      trace_config_.Merge(trace_config);
-      UpdateCategoryGroupEnabledFlags();
-      return;
-    }
-
     if (dispatching_to_observer_list_) {
-      DLOG(ERROR)
+      NOTREACHED()
           << "Cannot manipulate TraceLog::Enabled state from an observer.";
       return;
     }
 
-    mode_ = mode;
+    // Clear all filters from previous tracing session. These filters are not
+    // cleared at the end of tracing because some threads which hit trace event
+    // when disabling, could try to use the filters.
+    if (!enabled_modes_)
+      g_category_group_filters.Get().clear();
+
+    // Update trace config for recording.
+    const bool already_recording = enabled_modes_ & RECORDING_MODE;
+    if (modes & RECORDING_MODE) {
+      if (already_recording) {
+        // TODO(ssid): Stop suporting enabling of RECODING_MODE when already
+        // enabled crbug.com/625170.
+        DCHECK_EQ(new_options, old_options) << "Attempting to re-enable "
+                                               "tracing with a different set "
+                                               "of options.";
+        trace_config_.Merge(trace_config);
+      } else {
+        trace_config_ = trace_config;
+      }
+    }
+
+    // Update event filters.
+    if (modes & FILTERING_MODE) {
+      DCHECK(!trace_config.event_filters().empty())
+          << "Attempting to enable filtering without any filters";
+      DCHECK(enabled_event_filters_.empty()) << "Attempting to re-enable "
+                                                "filtering when filters are "
+                                                "already enabled.";
+
+      // Use the given event filters only if filtering was not enabled.
+      if (enabled_event_filters_.empty())
+        enabled_event_filters_ = trace_config.event_filters();
+    }
+    // Keep the |trace_config_| updated with only enabled filters in case anyone
+    // tries to read it using |GetCurrentTraceConfig| (even if filters are
+    // empty).
+    trace_config_.SetEventFilters(enabled_event_filters_);
+
+    enabled_modes_ |= modes;
+    UpdateCategoryGroupEnabledFlags();
+
+    // Do not notify observers or create trace buffer if only enabled for
+    // filtering or if recording was already enabled.
+    if (!(modes & RECORDING_MODE) || already_recording)
+      return;
 
     if (new_options != old_options) {
       subtle::NoBarrier_Store(&trace_options_, new_options);
       UseNextTraceBuffer();
     }
 
     num_traces_recorded_++;
 
-    // Clear all filters from previous tracing session. These filters are not
-    // cleared at the end of tracing because some threads which hit trace event
-    // when disabling, could try to use the filters.
-    g_category_group_filters.Get().clear();
-
-    trace_config_ = TraceConfig(trace_config);
     UpdateCategoryGroupEnabledFlags();
     UpdateSyntheticDelaysFromTraceConfig();
 
     dispatching_to_observer_list_ = true;
     observer_list = enabled_state_observer_list_;
     observer_map = async_observers_;
   }
   // Notify observers outside the lock in case they trigger trace events.
   for (EnabledStateObserver* observer : observer_list)
     observer->OnTraceLogEnabled();
@@ skipping 36 matching lines @@
   return kInternalNone;
 }
 
 TraceConfig TraceLog::GetCurrentTraceConfig() const {
   AutoLock lock(lock_);
   return trace_config_;
 }
 
 void TraceLog::SetDisabled() {
   AutoLock lock(lock_);
-  SetDisabledWhileLocked();
+  SetDisabledWhileLocked(RECORDING_MODE);
 }
 
-void TraceLog::SetDisabledWhileLocked() {
+void TraceLog::SetDisabled(uint8_t modes) {
+  AutoLock lock(lock_);
+  SetDisabledWhileLocked(modes);
+}
+
+void TraceLog::SetDisabledWhileLocked(uint8_t modes) {

[Primiano Tucci (use gerrit), 2016/10/13 19:11:24]

nit: probably a bit easier to read if this var is called modes_to_disable
My brain tripped twice while reading this because I didn't realize that the bits
in modes and enabled_modes_ have the opposite meaning (modes == RECORDING -> I
want to disable recording)

[ssid, 2016/10/13 19:39:36]

Done.

   lock_.AssertAcquired();
 
-  if (!IsEnabled())
+  if (!(enabled_modes_ & modes))
     return;
 
   if (dispatching_to_observer_list_) {
-    DLOG(ERROR)
+    NOTREACHED()
         << "Cannot manipulate TraceLog::Enabled state from an observer.";
     return;
   }
 
-  mode_ = DISABLED;
+  bool is_recording_mode_disabled =
+      (enabled_modes_ & RECORDING_MODE) && (modes & RECORDING_MODE);
+  enabled_modes_ &= ~modes;
 
-  trace_config_.Clear();
-  subtle::NoBarrier_Store(&watch_category_, 0);
-  watch_event_name_.clear();
+  if (modes & FILTERING_MODE)
+    enabled_event_filters_.clear();
+
+  if (modes & RECORDING_MODE) {
+    trace_config_.Clear();
+
+    subtle::NoBarrier_Store(&watch_category_, 0);
+    watch_event_name_.clear();
+  }
+
   UpdateCategoryGroupEnabledFlags();
+
+  // Add metadata events and notify observers only if recording mode was
+  // disabled now.
+  if (!is_recording_mode_disabled)
+    return;
+
   AddMetadataEventsWhileLocked();
 
   // Remove metadata events so they will not get added to a subsequent trace.
   metadata_events_.clear();
 
   dispatching_to_observer_list_ = true;
   std::vector<EnabledStateObserver*> observer_list =
       enabled_state_observer_list_;
   std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver> observer_map =
       async_observers_;
@@ skipping 79 matching lines @@
   }
   return trace_event;
 }
 
 void TraceLog::CheckIfBufferIsFullWhileLocked() {
   lock_.AssertAcquired();
   if (logged_events_->IsFull()) {
     if (buffer_limit_reached_timestamp_.is_null()) {
       buffer_limit_reached_timestamp_ = OffsetNow();
     }
-    SetDisabledWhileLocked();
+    SetDisabledWhileLocked(RECORDING_MODE);
   }
 }
 
 void TraceLog::SetEventCallbackEnabled(const TraceConfig& trace_config,
                                        EventCallback cb) {
   AutoLock lock(lock_);
   subtle::NoBarrier_Store(&event_callback_,
                           reinterpret_cast<subtle::AtomicWord>(cb));
   event_callback_trace_config_ = trace_config;
   UpdateCategoryGroupEnabledFlags();
@@ skipping 366 matching lines @@
   if (flags & TRACE_EVENT_FLAG_MANGLE_ID) {
     if ((flags & TRACE_EVENT_FLAG_FLOW_IN) ||
         (flags & TRACE_EVENT_FLAG_FLOW_OUT))
       bind_id = MangleEventId(bind_id);
     id = MangleEventId(id);
   }
 
   TimeTicks offset_event_timestamp = OffsetTimestamp(timestamp);
   ThreadTicks thread_now = ThreadNow();
 
-  // |thread_local_event_buffer_| can be null if the current thread doesn't have
-  // a message loop or the message loop is blocked.
-  InitializeThreadLocalEventBufferIfSupported();
-  auto* thread_local_event_buffer = thread_local_event_buffer_.Get();
+  ThreadLocalEventBuffer* thread_local_event_buffer = nullptr;
+  if (enabled_modes_ & RECORDING_MODE) {
+    // |thread_local_event_buffer_| can be null if the current thread doesn't
+    // have a message loop or the message loop is blocked.
+    InitializeThreadLocalEventBufferIfSupported();
+    thread_local_event_buffer = thread_local_event_buffer_.Get();
+  }
 
   // Check and update the current thread name only if the event is for the
   // current thread to avoid locks in most cases.
   if (thread_id == static_cast<int>(PlatformThread::CurrentId())) {
     const char* new_name =
         ThreadIdNameManager::GetInstance()->GetName(thread_id);
     // Check if the thread name has been set or changed since the previous
     // call (if any), but don't bother if the new name is empty. Note this will
     // not detect a thread name change within the same char* buffer address: we
     // favor common case performance over corner case correctness.
@@ skipping 564 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
                                                 event_handle_);
   }
 }
 
 }  // namespace trace_event_internal