Notify TraceLog observers outside of the lock

base/debug/trace_event_impl.h

 // 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.
 
 
 #ifndef BASE_DEBUG_TRACE_EVENT_IMPL_H_
 #define BASE_DEBUG_TRACE_EVENT_IMPL_H_
 
 #include <stack>
 #include <string>
@@ skipping 314 matching lines @@
   int GetNumTracesRecorded();
 
 #if defined(OS_ANDROID)
   void StartATrace();
   void StopATrace();
 #endif
 
   // Enabled state listeners give a callback when tracing is enabled or
   // disabled. This can be used to tie into other library's tracing systems
   // on-demand.
-  class EnabledStateChangedObserver {
+  class EnabledStateObserver {
    public:
-    // Called just before the tracing system becomes
-    // enabled. TraceLog::IsEnabled will return false at this point and trace
-    // macros and methods called within the observer will deadlock.
-    virtual void OnTraceLogWillEnable() { }
+    // Called just after the tracing system becomes enabled, outside of the
+    // |lock_|.  TraceLog::IsEnabled() is true at this point.
+    virtual void OnTraceLogEnabled() = 0;
 
-    // Called just before the tracing system disables. TraceLog::IsEnabled is
-    // still false at this point TRACE macros will still be capturing
-    // data. However, trace macros and methods called within the observer will
-    // deadlock.
-    virtual void OnTraceLogWillDisable() { }
+    // Called just after the tracing system disables, outside of the |lock_|.
+    // TraceLog::IsEnabled() is false at this point.
+    virtual void OnTraceLogDisabled() = 0;
   };
-  void AddEnabledStateObserver(EnabledStateChangedObserver* listener);
-  void RemoveEnabledStateObserver(EnabledStateChangedObserver* listener);
+  void AddEnabledStateObserver(EnabledStateObserver* listener);
+  void RemoveEnabledStateObserver(EnabledStateObserver* listener);
 
   float GetBufferPercentFull() const;
 
   // Set the thread-safe notification callback. The callback can occur at any
   // time and from any thread. WARNING: It is possible for the previously set
   // callback to be called during OR AFTER a call to SetNotificationCallback.
   // Therefore, the target of the callback must either be a global function,
   // ref-counted object or a LazyInstance with Leaky traits (or equivalent).
   typedef base::Callback<void(int)> NotificationCallback;
   void SetNotificationCallback(const NotificationCallback& cb);
@@ skipping 91 matching lines @@
   const TraceEvent& GetEventAt(size_t index) const {
     return logged_events_->GetEventAt(index);
   }
 
   void SetProcessID(int process_id);
 
   // Allow setting an offset between the current TimeTicks time and the time
   // that should be reported.
   void SetTimeOffset(TimeDelta offset);
 
+  size_t GetObserverCountForTest() const;
+
  private:
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
   friend struct StaticMemorySingletonTraits<TraceLog>;
 
   // Enable/disable each category group based on the current category_filter_.
   // If the category group contains a category that matches an included category
   // pattern, that category group will be enabled.
   void EnableIncludedCategoryGroups();
   void EnableIncludedCategoryGroup(int category_index);
@@ skipping 60 matching lines @@
   // TODO(nduca): switch to per-thread trace buffers to reduce thread
   // synchronization.
   // This lock protects TraceLog member accesses from arbitrary threads.
   Lock lock_;
   int enable_count_;
   int num_traces_recorded_;
   NotificationCallback notification_callback_;
   scoped_ptr<TraceBuffer> logged_events_;
   EventCallback event_callback_;
   bool dispatching_to_observer_list_;
-  ObserverList<EnabledStateChangedObserver> enabled_state_observer_list_;
+  std::vector<EnabledStateObserver*> enabled_state_observer_list_;
 
   base::hash_map<int, std::string> thread_names_;
   base::hash_map<int, std::stack<TimeTicks> > thread_event_start_times_;
   base::hash_map<std::string, int> thread_colors_;
 
   // XORed with TraceID to make it unlikely to collide with other processes.
   unsigned long long process_id_hash_;
 
   int process_id_;
 
@@ skipping 11 matching lines @@
 
   CategoryFilter category_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_