Independently enable recording and event callback

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/base_switches.h"
 #include "base/bind.h"
@@ skipping 1131 matching lines @@
       NOTREACHED();  // Unknown option provided.
     }
   }
   if (!(ret & RECORD_UNTIL_FULL) && !(ret & RECORD_CONTINUOUSLY))
     ret |= RECORD_UNTIL_FULL;  // Default when no options are specified.
 
   return static_cast<Options>(ret);
 }
 
 TraceLog::TraceLog()
-    : enable_count_(0),
+    : enabled_(false),
       num_traces_recorded_(0),
       buffer_is_full_(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_(RECORD_UNTIL_FULL),
       sampling_thread_handle_(0),
       category_filter_(CategoryFilter::kDefaultCategoryFilterString),
+      event_callback_category_filter_(
+          CategoryFilter::kDefaultCategoryFilterString),
       thread_shared_chunk_index_(0),
       generation_(0) {
   // 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_group_enabled,
   //                            sizeof(g_category_group_enabled),
   //                           "trace_event category enabled");
@@ skipping 46 matching lines @@
   DCHECK(category_ptr >= category_begin &&
          category_ptr < reinterpret_cast<uintptr_t>(
              g_category_group_enabled + MAX_CATEGORY_GROUPS)) <<
       "out of bounds category pointer";
   uintptr_t category_index =
       (category_ptr - category_begin) / sizeof(g_category_group_enabled[0]);
   return g_category_groups[category_index];
 }
 
 void TraceLog::UpdateCategoryGroupEnabledFlag(int category_index) {
-  g_category_group_enabled[category_index] =
-      enable_count_ &&
-      category_filter_.IsCategoryGroupEnabled(
-          g_category_groups[category_index]);
+  unsigned char enabled_flag = 0;
+  const char* category_group = g_category_groups[category_index];
+  if (enabled_ && category_filter_.IsCategoryGroupEnabled(category_group))
+    enabled_flag |= ENABLED_FOR_RECORDING;
+  if (event_callback_ &&
+      event_callback_category_filter_.IsCategoryGroupEnabled(category_group))
+    enabled_flag |= ENABLED_FOR_EVENT_CALLBACK;
+  g_category_group_enabled[category_index] = enabled_flag;
 }
 
 void TraceLog::UpdateCategoryGroupEnabledFlags() {
   for (int i = 0; i < g_category_index; i++)
     UpdateCategoryGroupEnabledFlag(i);
 }
 
 const unsigned char* TraceLog::GetCategoryGroupEnabledInternal(
     const char* category_group) {
   DCHECK(!strchr(category_group, '"')) <<
@@ skipping 48 matching lines @@
                           Options options) {
   std::vector<EnabledStateObserver*> observer_list;
   {
     AutoLock lock(lock_);
 
     // Can't enable tracing when Flush() is in progress.
     DCHECK(!flush_message_loop_proxy_.get());
 
     Options old_options = trace_options();
 
-    if (enable_count_++ > 0) {
+    if (enabled_) {
       if (options != old_options) {
         DLOG(ERROR) << "Attemting to re-enable tracing with a different "
                     << "set of options.";
       }
 
       category_filter_.Merge(category_filter);
       UpdateCategoryGroupEnabledFlags();
       return;
     }
 
+    if (dispatching_to_observer_list_) {
+      DLOG(ERROR) <<
+          "Cannot manipulate TraceLog::Enabled state from an observer.";
+      return;
+    }
+
+    enabled_ = true;
+
     if (options != old_options) {
       subtle::NoBarrier_Store(&trace_options_, options);
       logged_events_.reset(CreateTraceBuffer());
       NextGeneration();
       subtle::NoBarrier_Store(&buffer_is_full_, 0);
     }
 
-    if (dispatching_to_observer_list_) {
-      DLOG(ERROR) <<
-          "Cannot manipulate TraceLog::Enabled state from an observer.";
-      return;
-    }
-
     num_traces_recorded_++;
 
     category_filter_ = CategoryFilter(category_filter);
     UpdateCategoryGroupEnabledFlags();
 
     if ((options & ENABLE_SAMPLING) || (options & MONITOR_SAMPLING)) {
       sampling_thread_.reset(new TraceSamplingThread);
       sampling_thread_->RegisterSampleBucket(
           &g_trace_state[0],
           "bucket0",
@@ skipping 18 matching lines @@
   // Notify observers outside the lock in case they trigger trace events.
   for (size_t i = 0; i < observer_list.size(); ++i)
     observer_list[i]->OnTraceLogEnabled();
 
   {
     AutoLock lock(lock_);
     dispatching_to_observer_list_ = false;
   }
 }
 
-const CategoryFilter& TraceLog::GetCurrentCategoryFilter() {
+CategoryFilter TraceLog::GetCurrentCategoryFilter() {
   AutoLock lock(lock_);
-  DCHECK(enable_count_ > 0);
   return category_filter_;
 }
 
 void TraceLog::SetDisabled() {
   std::vector<EnabledStateObserver*> observer_list;
   {
     AutoLock lock(lock_);
-    DCHECK(enable_count_ > 0);
-
-    if (--enable_count_ != 0)
+    if (!enabled_)
       return;
 
     if (dispatching_to_observer_list_) {
       DLOG(ERROR)
           << "Cannot manipulate TraceLog::Enabled state from an observer.";
       return;
     }
 
+    enabled_ = false;
+
     if (sampling_thread_.get()) {
       // Stop the sampling thread.
       sampling_thread_->Stop();
       lock_.Release();
       PlatformThread::Join(sampling_thread_handle_);
       lock_.Acquire();
       sampling_thread_handle_ = PlatformThreadHandle();
       sampling_thread_.reset();
     }
 
@@ skipping 13 matching lines @@
     observer_list[i]->OnTraceLogDisabled();
 
   {
     AutoLock lock(lock_);
     dispatching_to_observer_list_ = false;
   }
 }
 
 int TraceLog::GetNumTracesRecorded() {
   AutoLock lock(lock_);
-  if (enable_count_ == 0)
+  if (!enabled_)
     return -1;
   return num_traces_recorded_;
 }
 
 void TraceLog::AddEnabledStateObserver(EnabledStateObserver* listener) {
   enabled_state_observer_list_.push_back(listener);
 }
 
 void TraceLog::RemoveEnabledStateObserver(EnabledStateObserver* listener) {
   std::vector<EnabledStateObserver*>::iterator it =
@@ skipping 63 matching lines @@
 
 void TraceLog::CheckIfBufferIsFullWhileLocked(NotificationHelper* notifier) {
   lock_.AssertAcquired();
   if (!subtle::NoBarrier_Load(&buffer_is_full_) && logged_events_->IsFull()) {
     subtle::NoBarrier_Store(&buffer_is_full_,
                             static_cast<subtle::AtomicWord>(1));
     notifier->AddNotificationWhileLocked(TRACE_BUFFER_FULL);
   }
 }
 
-void TraceLog::SetEventCallback(EventCallback cb) {
+void TraceLog::SetEventCallbackEnabled(const CategoryFilter& category_filter,
+                                       EventCallback cb) {
+  AutoLock lock(lock_);
   subtle::NoBarrier_Store(&event_callback_,
                           reinterpret_cast<subtle::AtomicWord>(cb));
+  event_callback_category_filter_ = category_filter;
+  UpdateCategoryGroupEnabledFlags();
 };
 
+void TraceLog::SetEventCallbackDisabled() {
+  AutoLock lock(lock_);
+  subtle::NoBarrier_Store(&event_callback_, 0);
+  UpdateCategoryGroupEnabledFlags();
+}
+
 // Flush() works as the following:
 // 1. Flush() is called in threadA whose message loop is saved in
 //    flush_message_loop_proxy_;
 // 2. If thread_message_loops_ is not empty, threadA posts task to each message
 //    loop to flush the thread local buffers; otherwise finish the flush;
 // 3. FlushCurrentThread() deletes the thread local event buffer:
 //    - The last batch of events of the thread are flushed into the main buffer;
 //    - The message loop will be removed from thread_message_loops_;
 //    If this is the last message loop, finish the flush;
 // 4. If any thread hasn't finish its flush in time, finish the flush.
@@ skipping 260 matching lines @@
                                new_name) != existing_names.end();
         if (!found) {
           existing_name->second.push_back(',');
           existing_name->second.append(new_name);
         }
       }
     }
   }
 
   TraceEvent* trace_event = NULL;
-  if (!subtle::NoBarrier_Load(&buffer_is_full_)) {
+  if ((*category_group_enabled & ENABLED_FOR_RECORDING) &&
+      !subtle::NoBarrier_Load(&buffer_is_full_)) {
     if (thread_local_event_buffer) {
       lock.EnsureReleased();
       trace_event = thread_local_event_buffer->AddTraceEvent(&notifier,
                                                              &handle);
     } else {
       lock.EnsureAcquired();
       trace_event = AddEventToThreadSharedChunkWhileLocked(&notifier, &handle);
     }
 
     if (trace_event) {
@@ skipping 16 matching lines @@
   }
 
   if (reinterpret_cast<const unsigned char*>(subtle::NoBarrier_Load(
       &watch_category_)) == category_group_enabled) {
     lock.EnsureAcquired();
     if (watch_event_name_ == name)
       notifier.AddNotificationWhileLocked(EVENT_WATCH_NOTIFICATION);
   }
 
   lock.EnsureReleased();
-  EventCallback event_callback = reinterpret_cast<EventCallback>(
-      subtle::NoBarrier_Load(&event_callback_));
-  if (event_callback) {
-    // TODO(wangxianzhu): Should send TRACE_EVENT_PHASE_COMPLETE directly to
-    // clients if it is beneficial and feasible.
-    event_callback(now,
-                   phase == TRACE_EVENT_PHASE_COMPLETE ?
-                       TRACE_EVENT_PHASE_BEGIN : phase,
-                   category_group_enabled, name, id,
-                   num_args, arg_names, arg_types, arg_values,
-                   flags);
+  if (*category_group_enabled & ENABLED_FOR_EVENT_CALLBACK) {
+    EventCallback event_callback = reinterpret_cast<EventCallback>(
+        subtle::NoBarrier_Load(&event_callback_));
+    if (event_callback) {
+      event_callback(now,
+                     phase == TRACE_EVENT_PHASE_COMPLETE ?
+                         TRACE_EVENT_PHASE_BEGIN : phase,
+                     category_group_enabled, name, id,
+                     num_args, arg_names, arg_types, arg_values,
+                     flags);
+    }
   }
 
   if (thread_local_event_buffer)
     thread_local_event_buffer->ReportOverhead(now, thread_now, &notifier);
 
   notifier.SendNotificationIfAny();
 
   return handle;
 }
 
@@ skipping 59 matching lines @@
                                 const void* id,
                                 const std::string& extra)
 {
 #if defined(OS_WIN)
   TraceEventETWProvider::Trace(name, phase, id, extra);
 #endif
   INTERNAL_TRACE_EVENT_ADD(phase, "ETW Trace Event", name,
                            TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
 }
 
-void TraceLog::UpdateTraceEventDuration(TraceEventHandle handle) {
+void TraceLog::UpdateTraceEventDuration(
+    const unsigned char* category_group_enabled,
+    const char* name,
+    TraceEventHandle handle) {
   OptionalAutoLock lock(lock_);
 
   TimeTicks now = OffsetNow();
-  TraceEvent* trace_event = GetEventByHandleInternal(handle, &lock);
-  if (trace_event) {
-    DCHECK(trace_event->phase() == TRACE_EVENT_PHASE_COMPLETE);
-    trace_event->UpdateDuration(now);
+  TraceEvent* trace_event = NULL;
+  // TODO(wangxianzhu): Remove the !category_group_enabled condition after
+  // all clients migrate to the new UpdateTraceEventDuration API.
+  if (!category_group_enabled ||
+      (*category_group_enabled & ENABLED_FOR_RECORDING)) {
+    trace_event = GetEventByHandleInternal(handle, &lock);
+    if (trace_event) {
+      DCHECK(trace_event->phase() == TRACE_EVENT_PHASE_COMPLETE);
+      trace_event->UpdateDuration(now);
 #if defined(OS_ANDROID)
-    trace_event->SendToATrace();
+      trace_event->SendToATrace();
 #endif
+    }
+
+    if (trace_options() & ECHO_TO_CONSOLE) {
+      lock.EnsureAcquired();
+      OutputEventToConsoleWhileLocked(TRACE_EVENT_PHASE_END, now, trace_event);
+    }
   }
 
-  if (trace_options() & ECHO_TO_CONSOLE) {
-    lock.EnsureAcquired();
-    OutputEventToConsoleWhileLocked(TRACE_EVENT_PHASE_END, now, trace_event);
+  // TODO(wangxianzhu): Remove this block after all clients migrate to the
+  // new UpdateTraceEventDuration API.
+  if (!category_group_enabled || !name) {
+    if (!trace_event)
+      return;
+    category_group_enabled = trace_event->category_group_enabled();
+    name = trace_event->name();
   }
 
-  EventCallback event_callback = reinterpret_cast<EventCallback>(
-      subtle::NoBarrier_Load(&event_callback_));
-  if (event_callback && trace_event) {
-    // The copy is needed when trace_event is from the main buffer in which case
-    // the lock has been locked.
-    TraceEvent event_copy;
-    event_copy.CopyFrom(*trace_event);
-    lock.EnsureReleased();
-    // TODO(wangxianzhu): Should send TRACE_EVENT_PHASE_COMPLETE directly to
-    // clients if it is beneficial and feasible.
-    event_callback(now, TRACE_EVENT_PHASE_END,
-                   event_copy.category_group_enabled(),
-                   event_copy.name(), event_copy.id(),
-                   0, NULL, NULL, NULL, event_copy.flags());
+  lock.EnsureReleased();
+  if (*category_group_enabled & ENABLED_FOR_EVENT_CALLBACK) {
+    EventCallback event_callback = reinterpret_cast<EventCallback>(
+        subtle::NoBarrier_Load(&event_callback_));
+    event_callback(now, TRACE_EVENT_PHASE_END, category_group_enabled, name,
+                   trace_event_internal::kNoEventId, 0, NULL, NULL, NULL,
+                   TRACE_EVENT_FLAG_NONE);
   }
 }
 
 void TraceLog::SetWatchEvent(const std::string& category_name,
                              const std::string& event_name) {
   const unsigned char* category = GetCategoryGroupEnabled(
       category_name.c_str());
   AutoLock lock(lock_);
   subtle::NoBarrier_Store(&watch_category_,
                           reinterpret_cast<subtle::AtomicWord>(category));
@@ skipping 323 matching lines @@
 
 namespace trace_event_internal {
 
 ScopedTraceBinaryEfficient::ScopedTraceBinaryEfficient(
     const char* category_group, const char* name) {
   // The single atom works because for now the category_group can only be "gpu".
   DCHECK(strcmp(category_group, "gpu") == 0);
   static TRACE_EVENT_API_ATOMIC_WORD atomic = 0;
   INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(
       category_group, atomic, category_group_enabled_);
+  name_ = name;
   if (*category_group_enabled_) {
     event_handle_ =
         TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
             TRACE_EVENT_PHASE_COMPLETE, category_group_enabled_, name,
             trace_event_internal::kNoEventId,
             static_cast<int>(base::PlatformThread::CurrentId()),
             base::TimeTicks::NowFromSystemTraceTime(),
             0, NULL, NULL, NULL, NULL, TRACE_EVENT_FLAG_NONE);
   }
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
-  if (*category_group_enabled_)
-    TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(event_handle_);
+  if (*category_group_enabled_) {
+    TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_,
+                                                name_, event_handle_);
+  }
 }
 
 }  // namespace trace_event_internal