Protect TraceLog::enabled_state_observer_list_ with a dedicated lock

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 551 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 = g_num_builtin_categories; i < category_index; i++)
     category_groups->push_back(g_category_groups[i]);
 }
 
 void TraceLog::SetEnabled(const TraceConfig& trace_config, Mode mode) {
-  std::vector<EnabledStateObserver*> observer_list;
-  {
-    AutoLock lock(lock_);
+  AutoLock lock(lock_);
 
-    // Can't enable tracing when Flush() is in progress.
-    DCHECK(!flush_task_runner_);
+  // Can't enable tracing when Flush() is in progress.
+  DCHECK(!flush_task_runner_);
 
-    InternalTraceOptions new_options =
-        GetInternalOptionsFromTraceConfig(trace_config);
+  InternalTraceOptions new_options =
+      GetInternalOptionsFromTraceConfig(trace_config);
 
-    InternalTraceOptions old_options = trace_options();
+  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.";
-      }
-
-      trace_config_.Merge(trace_config);
-      UpdateCategoryGroupEnabledFlags();
-      return;
+  if (IsEnabled()) {
+    if (new_options != old_options) {
+      DLOG(ERROR) << "Attempting to re-enable tracing with a different "
+                  << "set of options.";
     }
 
-    if (dispatching_to_observer_list_) {
-      DLOG(ERROR)
-          << "Cannot manipulate TraceLog::Enabled state from an observer.";
-      return;
+    if (mode != mode_) {
+      DLOG(ERROR) << "Attempting to re-enable tracing with a different mode.";
     }
 
-    mode_ = mode;
+    trace_config_.Merge(trace_config);
+    UpdateCategoryGroupEnabledFlags();
+    return;
+  }
 
-    if (new_options != old_options) {
-      subtle::NoBarrier_Store(&trace_options_, new_options);
-      UseNextTraceBuffer();
+  if (dispatching_to_observer_list_) {
+    DLOG(ERROR)
+        << "Cannot manipulate TraceLog::Enabled state from an observer.";
+    return;
+  }
+
+  mode_ = mode;
+
+  if (new_options != old_options) {
+    subtle::NoBarrier_Store(&trace_options_, new_options);
+    UseNextTraceBuffer();
+  }
+
+  num_traces_recorded_++;
+
+  trace_config_ = TraceConfig(trace_config);
+  UpdateCategoryGroupEnabledFlags();
+  UpdateSyntheticDelaysFromTraceConfig();
+
+  if (new_options & kInternalEnableSampling) {
+    sampling_thread_.reset(new TraceSamplingThread);
+    sampling_thread_->RegisterSampleBucket(
+        &g_trace_state[0], "bucket0",
+        Bind(&TraceSamplingThread::DefaultSamplingCallback));
+    sampling_thread_->RegisterSampleBucket(
+        &g_trace_state[1], "bucket1",
+        Bind(&TraceSamplingThread::DefaultSamplingCallback));
+    sampling_thread_->RegisterSampleBucket(
+        &g_trace_state[2], "bucket2",
+        Bind(&TraceSamplingThread::DefaultSamplingCallback));
+    if (!PlatformThread::Create(0, sampling_thread_.get(),
+                                &sampling_thread_handle_)) {
+      DCHECK(false) << "failed to create thread";
     }
-
-    num_traces_recorded_++;
-
-    trace_config_ = TraceConfig(trace_config);
-    UpdateCategoryGroupEnabledFlags();
-    UpdateSyntheticDelaysFromTraceConfig();
-
-    if (new_options & kInternalEnableSampling) {
-      sampling_thread_.reset(new TraceSamplingThread);
-      sampling_thread_->RegisterSampleBucket(
-          &g_trace_state[0], "bucket0",
-          Bind(&TraceSamplingThread::DefaultSamplingCallback));
-      sampling_thread_->RegisterSampleBucket(
-          &g_trace_state[1], "bucket1",
-          Bind(&TraceSamplingThread::DefaultSamplingCallback));
-      sampling_thread_->RegisterSampleBucket(
-          &g_trace_state[2], "bucket2",
-          Bind(&TraceSamplingThread::DefaultSamplingCallback));
-      if (!PlatformThread::Create(0, sampling_thread_.get(),
-                                  &sampling_thread_handle_)) {
-        DCHECK(false) << "failed to create thread";
-      }
-    }
-
-    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();
 
   {
-    AutoLock lock(lock_);
+    AutoLock observer_list_lock(observer_list_lock_);
+    dispatching_to_observer_list_ = true;
+    {
+      // Notify observers outside the lock in case they trigger trace events.
+      AutoUnlock unlock(lock_);
+      for (size_t i = 0; i < enabled_state_observer_list_.size(); ++i)
+        enabled_state_observer_list_[i]->OnTraceLogEnabled();
+    }
     dispatching_to_observer_list_ = false;
   }
 }
 
 void TraceLog::SetArgumentFilterPredicate(
     const ArgumentFilterPredicate& argument_filter_predicate) {
   AutoLock lock(lock_);
   DCHECK(!argument_filter_predicate.is_null());
   DCHECK(argument_filter_predicate_.is_null());
   argument_filter_predicate_ = argument_filter_predicate;
@@ skipping 55 matching lines @@
 
   trace_config_.Clear();
   subtle::NoBarrier_Store(&watch_category_, 0);
   watch_event_name_ = "";
   UpdateCategoryGroupEnabledFlags();
   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_;
-
   {
-    // Dispatch to observers outside the lock in case the observer triggers a
-    // trace event.
-    AutoUnlock unlock(lock_);
-    for (size_t i = 0; i < observer_list.size(); ++i)
-      observer_list[i]->OnTraceLogDisabled();
+    AutoLock observer_list_lock(observer_list_lock_);
+    dispatching_to_observer_list_ = true;
+    {
+      // Dispatch to observers outside the lock in case the observer triggers a
+      // trace event.
+      AutoUnlock unlock(lock_);
+      for (size_t i = 0; i < enabled_state_observer_list_.size(); ++i)
+        enabled_state_observer_list_[i]->OnTraceLogDisabled();
+    }
+    dispatching_to_observer_list_ = false;
   }
-  dispatching_to_observer_list_ = false;
 }
 
 int TraceLog::GetNumTracesRecorded() {
   AutoLock lock(lock_);
   if (!IsEnabled())
     return -1;
   return num_traces_recorded_;
 }
 
 void TraceLog::AddEnabledStateObserver(EnabledStateObserver* listener) {
-  AutoLock lock(lock_);
+  AutoLock observer_list_lock(observer_list_lock_);
   enabled_state_observer_list_.push_back(listener);
 }
 
 void TraceLog::RemoveEnabledStateObserver(EnabledStateObserver* listener) {
-  AutoLock lock(lock_);
+  AutoLock observer_list_lock(observer_list_lock_);
   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);
 }
 
 bool TraceLog::HasEnabledStateObserver(EnabledStateObserver* listener) const {
-  AutoLock lock(lock_);
+  AutoLock observer_list_lock(observer_list_lock_);
   return ContainsValue(enabled_state_observer_list_, listener);
 }
 
 TraceLogStatus TraceLog::GetStatus() const {
   AutoLock lock(lock_);
   TraceLogStatus result;
   result.event_capacity = static_cast<uint32_t>(logged_events_->Capacity());
   result.event_count = static_cast<uint32_t>(logged_events_->Size());
   return result;
 }
@@ skipping 976 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