Notify TraceLog observers outside of the lock

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 892 matching lines @@
 
 void TraceLog::GetKnownCategoryGroups(
     std::vector<std::string>* category_groups) {
   AutoLock lock(lock_);
   for (int i = g_num_builtin_categories; i < g_category_index; i++)
     category_groups->push_back(g_category_groups[i]);
 }
 
 void TraceLog::SetEnabled(const CategoryFilter& category_filter,
                           Options options) {
-  AutoLock lock(lock_);
+  std::vector<EnabledStateObserver*> observer_list;
+  {
+    AutoLock lock(lock_);
 
-  if (enable_count_++ > 0) {
-    if (options != trace_options_) {
-      DLOG(ERROR) << "Attemting to re-enable tracing with a different "
-                  << "set of options.";
+    if (enable_count_++ > 0) {
+      if (options != trace_options_) {
+        DLOG(ERROR) << "Attemting to re-enable tracing with a different "
+                    << "set of options.";
+      }
+
+      category_filter_.Merge(category_filter);
+      EnableIncludedCategoryGroups();
+      return;
     }
 
-    category_filter_.Merge(category_filter);
+    if (options != trace_options_) {
+      trace_options_ = options;
+      logged_events_.reset(GetTraceBuffer());
+    }
+
+    if (dispatching_to_observer_list_) {
+      DLOG(ERROR) <<
+          "Cannot manipulate TraceLog::Enabled state from an observer.";
+      return;
+    }
+
+    num_traces_recorded_++;
+
+    category_filter_ = CategoryFilter(category_filter);
     EnableIncludedCategoryGroups();
-    return;
+
+    // Not supported in split-dll build. http://crbug.com/237249
+  #if !defined(CHROME_SPLIT_DLL)
+    if (options & ENABLE_SAMPLING) {
+      sampling_thread_.reset(new TraceSamplingThread);
+      sampling_thread_->RegisterSampleBucket(
+          &g_trace_state0,
+          "bucket0",
+          Bind(&TraceSamplingThread::DefaultSampleCallback));
+      sampling_thread_->RegisterSampleBucket(
+          &g_trace_state1,
+          "bucket1",
+          Bind(&TraceSamplingThread::DefaultSampleCallback));
+      sampling_thread_->RegisterSampleBucket(
+          &g_trace_state2,
+          "bucket2",
+          Bind(&TraceSamplingThread::DefaultSampleCallback));
+      if (!PlatformThread::Create(
+            0, sampling_thread_.get(), &sampling_thread_handle_)) {
+        DCHECK(false) << "failed to create thread";
+      }
+    }
+  #endif
+
+    dispatching_to_observer_list_ = true;
+    observer_list = enabled_state_observer_list_;
   }
+  // 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();
 
-  if (options != trace_options_) {
-    trace_options_ = options;
-    logged_events_.reset(GetTraceBuffer());
+  {
+    AutoLock lock(lock_);
+    dispatching_to_observer_list_ = false;
   }
-
-  if (dispatching_to_observer_list_) {
-    DLOG(ERROR) <<
-        "Cannot manipulate TraceLog::Enabled state from an observer.";
-    return;
-  }
-
-  num_traces_recorded_++;
-
-  dispatching_to_observer_list_ = true;
-  FOR_EACH_OBSERVER(EnabledStateChangedObserver, enabled_state_observer_list_,
-                    OnTraceLogWillEnable());
-  dispatching_to_observer_list_ = false;
-
-  category_filter_ = CategoryFilter(category_filter);
-  EnableIncludedCategoryGroups();
-
-  // Not supported in split-dll build. http://crbug.com/237249
-#if !defined(CHROME_SPLIT_DLL)
-  if (options & ENABLE_SAMPLING) {
-    sampling_thread_.reset(new TraceSamplingThread);
-    sampling_thread_->RegisterSampleBucket(
-        &g_trace_state0,
-        "bucket0",
-        Bind(&TraceSamplingThread::DefaultSampleCallback));
-    sampling_thread_->RegisterSampleBucket(
-        &g_trace_state1,
-        "bucket1",
-        Bind(&TraceSamplingThread::DefaultSampleCallback));
-    sampling_thread_->RegisterSampleBucket(
-        &g_trace_state2,
-        "bucket2",
-        Bind(&TraceSamplingThread::DefaultSampleCallback));
-    if (!PlatformThread::Create(
-          0, sampling_thread_.get(), &sampling_thread_handle_)) {
-      DCHECK(false) << "failed to create thread";
-    }
-  }
-#endif
 }
 
 const CategoryFilter& TraceLog::GetCurrentCategoryFilter() {
   AutoLock lock(lock_);
   DCHECK(enable_count_ > 0);
   return category_filter_;
 }
 
 void TraceLog::SetDisabled() {
-  AutoLock lock(lock_);
-  DCHECK(enable_count_ > 0);
-  if (--enable_count_ != 0)
-    return;
+  std::vector<EnabledStateObserver*> observer_list;
+  {
+    AutoLock lock(lock_);
+    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;
+    if (dispatching_to_observer_list_) {
+      DLOG(ERROR)
+          << "Cannot manipulate TraceLog::Enabled state from an observer.";
+      return;
+    }
+
+    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();
+    }
+
+    category_filter_.Clear();
+    watch_category_ = NULL;
+    watch_event_name_ = "";
+    for (int i = 0; i < g_category_index; i++)
+      SetCategoryGroupEnabled(i, false);
+    AddThreadNameMetadataEvents();
+
+    dispatching_to_observer_list_ = true;
+    observer_list = enabled_state_observer_list_;
   }
 
-  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();
+  // Dispatch to observers outside the lock in case the observer triggers a
+  // trace event.
+  for (size_t i = 0; i < observer_list.size(); ++i)
+    observer_list[i]->OnTraceLogDisabled();
+
+  {
+    AutoLock lock(lock_);
+    dispatching_to_observer_list_ = false;
   }
-
-  dispatching_to_observer_list_ = true;
-  FOR_EACH_OBSERVER(EnabledStateChangedObserver,
-                    enabled_state_observer_list_,
-                    OnTraceLogWillDisable());
-  dispatching_to_observer_list_ = false;
-
-  category_filter_.Clear();
-  watch_category_ = NULL;
-  watch_event_name_ = "";
-  for (int i = 0; i < g_category_index; i++)
-    SetCategoryGroupEnabled(i, false);
-  AddThreadNameMetadataEvents();
 }
 
 int TraceLog::GetNumTracesRecorded() {
   AutoLock lock(lock_);
   if (enable_count_ == 0)
     return -1;
   return num_traces_recorded_;
 }
 
-void TraceLog::AddEnabledStateObserver(EnabledStateChangedObserver* listener) {
-  enabled_state_observer_list_.AddObserver(listener);
+void TraceLog::AddEnabledStateObserver(EnabledStateObserver* listener) {
+  enabled_state_observer_list_.push_back(listener);
 }
 
-void TraceLog::RemoveEnabledStateObserver(
-    EnabledStateChangedObserver* listener) {
-  enabled_state_observer_list_.RemoveObserver(listener);
+void TraceLog::RemoveEnabledStateObserver(EnabledStateObserver* listener) {
+  std::vector<EnabledStateObserver*>::iterator it =
+      std::find(enabled_state_observer_list_.begin(),
+                enabled_state_observer_list_.end(),
+                listener);
+  if (it != enabled_state_observer_list_.end())
+    enabled_state_observer_list_.erase(it);
 }
 
 float TraceLog::GetBufferPercentFull() const {
   return (float)((double)logged_events_->Size()/(double)kTraceEventBufferSize);
 }
 
 void TraceLog::SetNotificationCallback(
     const TraceLog::NotificationCallback& cb) {
   AutoLock lock(lock_);
   notification_callback_ = cb;
@@ skipping 276 matching lines @@
   unsigned long long offset_basis = 14695981039346656037ull;
   unsigned long long fnv_prime = 1099511628211ull;
   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;
 }
 
+size_t TraceLog::GetObserverCountForTest() const {
+  return enabled_state_observer_list_.size();
+}
+
 bool CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
     const std::string& str) {
   return  str.empty() ||
           str.at(0) == ' ' ||
           str.at(str.length() - 1) == ' ';
 }
 
 bool CategoryFilter::DoesCategoryGroupContainCategory(
     const char* category_group,
     const char* category) const {
@@ skipping 187 matching lines @@
         0,                       // num_args
         NULL,                    // arg_names
         NULL,                    // arg_types
         NULL,                    // arg_values
         NULL,                    // convertable values
         TRACE_EVENT_FLAG_NONE);  // flags
   }
 }
 
 }  // namespace trace_event_internal