Revert of Revert "Revert 237280 "Remove TraceController""

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 81 matching lines @@
 const int g_category_trace_event_overhead = 3;
 const int g_num_builtin_categories = 4;
 int g_category_index = g_num_builtin_categories; // Skip default categories.
 
 // The name of the current thread. This is used to decide if the current
 // thread name has changed. We combine all the seen thread names into the
 // output name for the thread.
 LazyInstance<ThreadLocalPointer<const char> >::Leaky
     g_current_thread_name = LAZY_INSTANCE_INITIALIZER;
 
+const char kRecordUntilFull[] = "record-until-full";
+const char kRecordContinuously[] = "record-continuously";
+const char kEnableSampling[] = "enable-sampling";
+const char kMonitorSampling[] = "monitor-sampling";
+
 TimeTicks ThreadNow() {
   return TimeTicks::IsThreadNowSupported() ?
       TimeTicks::ThreadNow() : TimeTicks();
 }
 
 class TraceBufferRingBuffer : public TraceBuffer {
  public:
   TraceBufferRingBuffer(size_t max_chunks)
       : max_chunks_(max_chunks),
         recyclable_chunks_queue_(new size_t[queue_capacity()]),
@@ skipping 827 matching lines @@
 // TraceLog
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 class TraceLog::ThreadLocalEventBuffer
     : public MessageLoop::DestructionObserver {
  public:
   ThreadLocalEventBuffer(TraceLog* trace_log);
   virtual ~ThreadLocalEventBuffer();
 
-  TraceEvent* AddTraceEvent(TraceEventHandle* handle);
+  TraceEvent* AddTraceEvent(NotificationHelper* notifier,
+                            TraceEventHandle* handle);
 
   void ReportOverhead(const TimeTicks& event_timestamp,
-                      const TimeTicks& event_thread_timestamp);
+                      const TimeTicks& event_thread_timestamp,
+                      NotificationHelper* notifier);
 
   TraceEvent* GetEventByHandle(TraceEventHandle handle) {
     if (!chunk_ || handle.chunk_seq != chunk_->seq() ||
         handle.chunk_index != chunk_index_)
       return NULL;
 
     return chunk_->GetEventAt(handle.event_index);
   }
 
   int generation() const { return generation_; }
@@ skipping 36 matching lines @@
 
 TraceLog::ThreadLocalEventBuffer::~ThreadLocalEventBuffer() {
   CheckThisIsCurrentBuffer();
   MessageLoop::current()->RemoveDestructionObserver(this);
 
   // Zero event_count_ happens in either of the following cases:
   // - no event generated for the thread;
   // - the thread has no message loop;
   // - trace_event_overhead is disabled.
   if (event_count_) {
-    InitializeMetadataEvent(AddTraceEvent(NULL),
+    NotificationHelper notifier(trace_log_);
+    InitializeMetadataEvent(AddTraceEvent(&notifier, NULL),
                             static_cast<int>(base::PlatformThread::CurrentId()),
                             "overhead", "average_overhead",
                             overhead_.InMillisecondsF() / event_count_);
+    notifier.SendNotificationIfAny();
   }
 
   {
     AutoLock lock(trace_log_->lock_);
     FlushWhileLocked();
     trace_log_->thread_message_loops_.erase(MessageLoop::current());
   }
   trace_log_->thread_local_event_buffer_.Set(NULL);
 }
 
 TraceEvent* TraceLog::ThreadLocalEventBuffer::AddTraceEvent(
+    NotificationHelper* notifier,
     TraceEventHandle* handle) {
   CheckThisIsCurrentBuffer();
 
   if (chunk_ && chunk_->IsFull()) {
     AutoLock lock(trace_log_->lock_);
     FlushWhileLocked();
     chunk_.reset();
   }
   if (!chunk_) {
     AutoLock lock(trace_log_->lock_);
     chunk_ = trace_log_->logged_events_->GetChunk(&chunk_index_);
-    trace_log_->CheckIfBufferIsFullWhileLocked();
+    trace_log_->CheckIfBufferIsFullWhileLocked(notifier);
   }
   if (!chunk_)
     return NULL;
 
   size_t event_index;
   TraceEvent* trace_event = chunk_->AddTraceEvent(&event_index);
   if (trace_event && handle)
     MakeHandle(chunk_->seq(), chunk_index_, event_index, handle);
 
   return trace_event;
 }
 
 void TraceLog::ThreadLocalEventBuffer::ReportOverhead(
     const TimeTicks& event_timestamp,
-    const TimeTicks& event_thread_timestamp) {
+    const TimeTicks& event_thread_timestamp,
+    NotificationHelper* notifier) {
   if (!g_category_group_enabled[g_category_trace_event_overhead])
     return;
 
   CheckThisIsCurrentBuffer();
 
   event_count_++;
   TimeTicks thread_now = ThreadNow();
   TimeTicks now = trace_log_->OffsetNow();
   TimeDelta overhead = now - event_timestamp;
   if (overhead.InMicroseconds() >= kOverheadReportThresholdInMicroseconds) {
-    TraceEvent* trace_event = AddTraceEvent(NULL);
+    TraceEvent* trace_event = AddTraceEvent(notifier, NULL);
     if (trace_event) {
       trace_event->Initialize(
           static_cast<int>(PlatformThread::CurrentId()),
           event_timestamp, event_thread_timestamp,
           TRACE_EVENT_PHASE_COMPLETE,
           &g_category_group_enabled[g_category_trace_event_overhead],
           "overhead", 0, 0, NULL, NULL, NULL, NULL, 0);
       trace_event->UpdateDuration(now, thread_now);
     }
   }
@@ skipping 10 matching lines @@
 
   trace_log_->lock_.AssertAcquired();
   if (trace_log_->CheckGeneration(generation_)) {
     // Return the chunk to the buffer only if the generation matches,
     trace_log_->logged_events_->ReturnChunk(chunk_index_, chunk_.Pass());
   }
   // Otherwise this method may be called from the destructor, or TraceLog will
   // find the generation mismatch and delete this buffer soon.
 }
 
+TraceLog::NotificationHelper::NotificationHelper(TraceLog* trace_log)
+    : trace_log_(trace_log),
+      notification_(0) {
+}
+
+TraceLog::NotificationHelper::~NotificationHelper() {
+}
+
+void TraceLog::NotificationHelper::AddNotificationWhileLocked(
+    int notification) {
+  trace_log_->lock_.AssertAcquired();
+  if (trace_log_->notification_callback_.is_null())
+    return;
+  if (notification_ == 0)
+    callback_copy_ = trace_log_->notification_callback_;
+  notification_ |= notification;
+}
+
+void TraceLog::NotificationHelper::SendNotificationIfAny() {
+  if (notification_)
+    callback_copy_.Run(notification_);
+}
+
 // static
 TraceLog* TraceLog::GetInstance() {
   return Singleton<TraceLog, LeakySingletonTraits<TraceLog> >::get();
 }
 
+// static
+// Note, if you add more options here you also need to update:
+// content/browser/devtools/devtools_tracing_handler:TraceOptionsFromString
+TraceLog::Options TraceLog::TraceOptionsFromString(const std::string& options) {
+  std::vector<std::string> split;
+  base::SplitString(options, ',', &split);
+  int ret = 0;
+  for (std::vector<std::string>::iterator iter = split.begin();
+       iter != split.end();
+       ++iter) {
+    if (*iter == kRecordUntilFull) {
+      ret |= RECORD_UNTIL_FULL;
+    } else if (*iter == kRecordContinuously) {
+      ret |= RECORD_CONTINUOUSLY;
+    } else if (*iter == kEnableSampling) {
+      ret |= ENABLE_SAMPLING;
+    } else if (*iter == kMonitorSampling) {
+      ret |= MONITOR_SAMPLING;
+    } else {
+      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()
     : 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_(
@@ skipping 156 matching lines @@
           "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);
     }
 
     num_traces_recorded_++;
 
     category_filter_ = CategoryFilter(category_filter);
     UpdateCategoryGroupEnabledFlags();
 
     if ((options & ENABLE_SAMPLING) || (options & MONITOR_SAMPLING)) {
       sampling_thread_.reset(new TraceSamplingThread);
       sampling_thread_->RegisterSampleBucket(
@@ skipping 26 matching lines @@
     dispatching_to_observer_list_ = false;
   }
 }
 
 CategoryFilter TraceLog::GetCurrentCategoryFilter() {
   AutoLock lock(lock_);
   return category_filter_;
 }
 
 void TraceLog::SetDisabled() {
-  AutoLock lock(lock_);
-  SetDisabledWhileLocked();
-}
+  std::vector<EnabledStateObserver*> observer_list;
+  {
+    AutoLock lock(lock_);
+    if (!enabled_)
+      return;
 
-void TraceLog::SetDisabledWhileLocked() {
-  lock_.AssertAcquired();
+    if (dispatching_to_observer_list_) {
+      DLOG(ERROR)
+          << "Cannot manipulate TraceLog::Enabled state from an observer.";
+      return;
+    }
 
-  if (!enabled_)
-    return;
+    enabled_ = false;
 
-  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();
+    subtle::NoBarrier_Store(&watch_category_, 0);
+    watch_event_name_ = "";
+    UpdateCategoryGroupEnabledFlags();
+    AddMetadataEventsWhileLocked();
+
+    dispatching_to_observer_list_ = true;
+    observer_list = enabled_state_observer_list_;
   }
 
-  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();
-  }
-
-  category_filter_.Clear();
-  subtle::NoBarrier_Store(&watch_category_, 0);
-  watch_event_name_ = "";
-  UpdateCategoryGroupEnabledFlags();
-  AddMetadataEventsWhileLocked();
-
-  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.
+  for (size_t i = 0; i < observer_list.size(); ++i)
+    observer_list[i]->OnTraceLogDisabled();
 
   {
-    // 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 lock(lock_);
+    dispatching_to_observer_list_ = false;
   }
-  dispatching_to_observer_list_ = false;
 }
 
 int TraceLog::GetNumTracesRecorded() {
   AutoLock lock(lock_);
   if (!enabled_)
     return -1;
   return num_traces_recorded_;
 }
 
 void TraceLog::AddEnabledStateObserver(EnabledStateObserver* listener) {
@@ skipping 11 matching lines @@
 
 bool TraceLog::HasEnabledStateObserver(EnabledStateObserver* listener) const {
   std::vector<EnabledStateObserver*>::const_iterator it =
       std::find(enabled_state_observer_list_.begin(),
                 enabled_state_observer_list_.end(),
                 listener);
   return it != enabled_state_observer_list_.end();
 }
 
 float TraceLog::GetBufferPercentFull() const {
-  AutoLock lock(lock_);
   return static_cast<float>(static_cast<double>(logged_events_->Size()) /
                             logged_events_->Capacity());
 }
 
-bool TraceLog::BufferIsFull() const {
+void TraceLog::SetNotificationCallback(
+    const TraceLog::NotificationCallback& cb) {
   AutoLock lock(lock_);
-  return logged_events_->IsFull();
+  notification_callback_ = cb;
 }
 
 TraceBuffer* TraceLog::CreateTraceBuffer() {
   Options options = trace_options();
   if (options & RECORD_CONTINUOUSLY)
     return new TraceBufferRingBuffer(kTraceEventRingBufferChunks);
   else if (options & MONITOR_SAMPLING)
     return new TraceBufferRingBuffer(kMonitorTraceEventBufferChunks);
   else if (options & ECHO_TO_CONSOLE)
     return new TraceBufferRingBuffer(kEchoToConsoleTraceEventBufferChunks);
   return new TraceBufferVector();
 }
 
 TraceEvent* TraceLog::AddEventToThreadSharedChunkWhileLocked(
-    TraceEventHandle* handle, bool check_buffer_is_full) {
+    NotificationHelper* notifier, TraceEventHandle* handle) {
   lock_.AssertAcquired();
 
   if (thread_shared_chunk_ && thread_shared_chunk_->IsFull()) {
     logged_events_->ReturnChunk(thread_shared_chunk_index_,
                                 thread_shared_chunk_.Pass());
   }
 
   if (!thread_shared_chunk_) {
     thread_shared_chunk_ = logged_events_->GetChunk(
         &thread_shared_chunk_index_);
-    if (check_buffer_is_full)
-      CheckIfBufferIsFullWhileLocked();
+    if (notifier)
+      CheckIfBufferIsFullWhileLocked(notifier);
   }
   if (!thread_shared_chunk_)
     return NULL;
 
   size_t event_index;
   TraceEvent* trace_event = thread_shared_chunk_->AddTraceEvent(&event_index);
   if (trace_event && handle) {
     MakeHandle(thread_shared_chunk_->seq(), thread_shared_chunk_index_,
                event_index, handle);
   }
   return trace_event;
 }
 
-void TraceLog::CheckIfBufferIsFullWhileLocked() {
+void TraceLog::CheckIfBufferIsFullWhileLocked(NotificationHelper* notifier) {
   lock_.AssertAcquired();
-  if (logged_events_->IsFull())
-    SetDisabledWhileLocked();
+  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::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();
 };
@@ skipping 96 matching lines @@
 
   if (!CheckGeneration(generation))
     return;
 
   {
     AutoLock lock(lock_);
 
     previous_logged_events.swap(logged_events_);
     logged_events_.reset(CreateTraceBuffer());
     NextGeneration();
+    subtle::NoBarrier_Store(&buffer_is_full_, 0);
     thread_message_loops_.clear();
 
     flush_message_loop_proxy_ = NULL;
     flush_output_callback = flush_output_callback_;
     flush_output_callback_.Reset();
   }
 
   ConvertTraceEventsToTraceFormat(previous_logged_events.Pass(),
                                   flush_output_callback);
 }
@@ skipping 99 matching lines @@
     return handle;
 
   DCHECK(name);
 
   if (flags & TRACE_EVENT_FLAG_MANGLE_ID)
     id ^= process_id_hash_;
 
   TimeTicks now = OffsetTimestamp(timestamp);
   TimeTicks thread_now = ThreadNow();
 
+  NotificationHelper notifier(this);
+
   ThreadLocalEventBuffer* thread_local_event_buffer = NULL;
   // A ThreadLocalEventBuffer needs the message loop
   // - to know when the thread exits;
   // - to handle the final flush.
   // For a thread without a message loop or the message loop may be blocked, the
   // trace events will be added into the main buffer directly.
   if (!thread_blocks_message_loop_.Get() && MessageLoop::current()) {
     thread_local_event_buffer = thread_local_event_buffer_.Get();
     if (thread_local_event_buffer &&
         !CheckGeneration(thread_local_event_buffer->generation())) {
@@ skipping 36 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 ((*category_group_enabled & ENABLED_FOR_RECORDING)) {
+  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(&handle);
+      trace_event = thread_local_event_buffer->AddTraceEvent(&notifier,
+                                                             &handle);
     } else {
       lock.EnsureAcquired();
-      trace_event = AddEventToThreadSharedChunkWhileLocked(&handle, true);
+      trace_event = AddEventToThreadSharedChunkWhileLocked(&notifier, &handle);
     }
 
     if (trace_event) {
       trace_event->Initialize(thread_id, now, thread_now, phase,
                               category_group_enabled, name, id,
                               num_args, arg_names, arg_types, arg_values,
                               convertable_values, flags);
 
 #if defined(OS_ANDROID)
       trace_event->SendToATrace();
 #endif
     }
+  }
 
-    if (trace_options() & ECHO_TO_CONSOLE) {
-      lock.EnsureAcquired();
-      OutputEventToConsoleWhileLocked(
-          phase == TRACE_EVENT_PHASE_COMPLETE ? TRACE_EVENT_PHASE_BEGIN : phase,
-          timestamp, trace_event);
-    }
+  if (trace_options() & ECHO_TO_CONSOLE) {
+    lock.EnsureAcquired();
+    OutputEventToConsoleWhileLocked(
+        phase == TRACE_EVENT_PHASE_COMPLETE ? TRACE_EVENT_PHASE_BEGIN : phase,
+        timestamp, trace_event);
   }
 
   if (reinterpret_cast<const unsigned char*>(subtle::NoBarrier_Load(
       &watch_category_)) == category_group_enabled) {
     lock.EnsureAcquired();
-    if (watch_event_name_ == name) {
-      WatchEventCallback watch_event_callback_copy = watch_event_callback_;
-      lock.EnsureReleased();
-      if (!watch_event_callback_copy.is_null())
-        watch_event_callback_copy.Run();
-    }
+    if (watch_event_name_ == name)
+      notifier.AddNotificationWhileLocked(EVENT_WATCH_NOTIFICATION);
   }
 
   lock.EnsureReleased();
   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);
+    thread_local_event_buffer->ReportOverhead(now, thread_now, &notifier);
+
+  notifier.SendNotificationIfAny();
 
   return handle;
 }
 
 // May be called when a COMPELETE event ends and the unfinished event has been
 // recycled (phase == TRACE_EVENT_PHASE_END and trace_event == NULL).
 void TraceLog::OutputEventToConsoleWhileLocked(unsigned char phase,
                                                const TimeTicks& timestamp,
                                                TraceEvent* trace_event) {
   // The caller should translate TRACE_EVENT_PHASE_COMPLETE to
@@ skipping 90 matching lines @@
         subtle::NoBarrier_Load(&event_callback_));
     if (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 WatchEventCallback& callback) {
+                             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));
   watch_event_name_ = event_name;
-  watch_event_callback_ = callback;
 }
 
 void TraceLog::CancelWatchEvent() {
   AutoLock lock(lock_);
   subtle::NoBarrier_Store(&watch_category_, 0);
   watch_event_name_ = "";
-  watch_event_callback_.Reset();
 }
 
 void TraceLog::AddMetadataEventsWhileLocked() {
   lock_.AssertAcquired();
 
   int current_thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   if (process_sort_index_ != 0) {
-    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, false),
+    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, NULL),
                             current_thread_id,
                             "process_sort_index", "sort_index",
                             process_sort_index_);
   }
 
   if (process_name_.size()) {
-    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, false),
+    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, NULL),
                             current_thread_id,
                             "process_name", "name",
                             process_name_);
   }
 
   if (process_labels_.size() > 0) {
     std::vector<std::string> labels;
     for(base::hash_map<int, std::string>::iterator it = process_labels_.begin();
         it != process_labels_.end();
         it++) {
       labels.push_back(it->second);
     }
-    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, false),
+    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, NULL),
                             current_thread_id,
                             "process_labels", "labels",
                             JoinString(labels, ','));
   }
 
   // Thread sort indices.
   for(hash_map<int, int>::iterator it = thread_sort_indices_.begin();
       it != thread_sort_indices_.end();
       it++) {
     if (it->second == 0)
       continue;
-    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, false),
+    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, NULL),
                             it->first,
                             "thread_sort_index", "sort_index",
                             it->second);
   }
 
   // Thread names.
   for(hash_map<int, std::string>::iterator it = thread_names_.begin();
       it != thread_names_.end();
       it++) {
     if (it->second.empty())
       continue;
-    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, false),
+    InitializeMetadataEvent(AddEventToThreadSharedChunkWhileLocked(NULL, NULL),
                             it->first,
                             "thread_name", "name",
                             it->second);
   }
 }
 
 void TraceLog::WaitSamplingEventForTesting() {
   if (!sampling_thread_)
     return;
   sampling_thread_->WaitSamplingEventForTesting();
@@ skipping 274 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