Add OnBeforeTraceLogDisabled notification to EnabledStateObserver

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 800 matching lines @@
   NOTREACHED();
   return kInternalNone;
 }
 
 TraceConfig TraceLog::GetCurrentTraceConfig() const {
   AutoLock lock(lock_);
   return trace_config_;
 }
 
 void TraceLog::SetDisabled() {
-  AutoLock lock(lock_);
+  AutoLock lock1(disabling_lock_);
+  AutoLock lock2(lock_);
   SetDisabledWhileLocked();
 }
 
 void TraceLog::SetDisabledWhileLocked() {
   lock_.AssertAcquired();
 
   if (!IsEnabled())
     return;
 
   if (dispatching_to_observer_list_) {
     DLOG(ERROR)
         << "Cannot manipulate TraceLog::Enabled state from an observer.";
     return;
   }
 
+  std::vector<EnabledStateObserver*> observer_list =
+      enabled_state_observer_list_;
+  dispatching_to_observer_list_ = true;
+  {
+    // Dispatch to observers outside the lock in case the observer triggers a
+    // trace event.
+    AutoUnlock unlock(lock_);
+    for (EnabledStateObserver* observer : observer_list)
+      observer->OnBeforeTraceLogDisabled();
+  }
+  dispatching_to_observer_list_ = false;
+
   mode_ = DISABLED;
 
   if (sampling_thread_) {
     // Stop the sampling thread.
     sampling_thread_->Stop();
     lock_.Release();
     PlatformThread::Join(sampling_thread_handle_);
     lock_.Acquire();
     sampling_thread_handle_ = PlatformThreadHandle();
     sampling_thread_.reset();
   }
 
   trace_config_.Clear();
   subtle::NoBarrier_Store(&watch_category_, 0);
   watch_event_name_.clear();
   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_;
   std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver> observer_map =
       async_observers_;
-
+  dispatching_to_observer_list_ = true;
   {
     // Dispatch to observers outside the lock in case the observer triggers a
     // trace event.
     AutoUnlock unlock(lock_);
     for (EnabledStateObserver* observer : observer_list)
       observer->OnTraceLogDisabled();
     for (const auto& it : observer_map) {
       it.second.task_runner->PostTask(
           FROM_HERE, Bind(&AsyncEnabledStateObserver::OnTraceLogDisabled,
                           it.second.observer));
@@ skipping 1049 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