Implement about:tracing UI for the sampling profiler (Chromium part)

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 36 matching lines @@
 
 namespace base {
 namespace debug {
 
 // Controls the number of trace events we will buffer in-memory
 // before throwing them away.
 const size_t kTraceEventVectorBufferSize = 250000;
 const size_t kTraceEventRingBufferSize = kTraceEventVectorBufferSize / 4;
 const size_t kTraceEventBatchSize = 1000;
 const size_t kTraceEventInitialBufferSize = 1024;
+// Can store results for 30 seconds with 1 ms sampling interval.
+const size_t kSamplingTraceEventBufferSize = 30000;
 
 #define MAX_CATEGORY_GROUPS 100
 
 namespace {
 
 // Parallel arrays g_category_groups and g_category_group_enabled are separate
 // so that a pointer to a member of g_category_group_enabled can be easily
 // converted to an index into g_category_groups. This allows macros to deal
 // only with char enabled pointers from g_category_group_enabled, and we can
 // convert internally to determine the category name from the char enabled
@@ skipping 19 matching lines @@
     g_current_thread_name = LAZY_INSTANCE_INITIALIZER;
 
 const char kRecordUntilFull[] = "record-until-full";
 const char kRecordContinuously[] = "record-continuously";
 const char kEnableSampling[] = "enable-sampling";
 
 }  // namespace
 
 class TraceBufferRingBuffer : public TraceBuffer {
  public:
-  TraceBufferRingBuffer()
+  TraceBufferRingBuffer(size_t buffer_size)
       : unused_event_index_(0),
-        oldest_event_index_(0) {
+        oldest_event_index_(0),
+        buffer_size_(buffer_size) {
     logged_events_.reserve(kTraceEventInitialBufferSize);
   }
 
   virtual ~TraceBufferRingBuffer() {}
 
   virtual void AddEvent(const TraceEvent& event) OVERRIDE {
     if (unused_event_index_ < Size())
       logged_events_[unused_event_index_] = event;
     else
       logged_events_.push_back(event);
 
-    unused_event_index_ = NextIndex(unused_event_index_);
+    unused_event_index_ = NextIndex(unused_event_index_, buffer_size_);
     if (unused_event_index_ == oldest_event_index_) {
-      oldest_event_index_ = NextIndex(oldest_event_index_);
+      oldest_event_index_ = NextIndex(
+          oldest_event_index_, buffer_size_);
     }
   }
 
   virtual bool HasMoreEvents() const OVERRIDE {
     return oldest_event_index_ != unused_event_index_;
   }
 
   virtual const TraceEvent& NextEvent() OVERRIDE {
     DCHECK(HasMoreEvents());
 
     size_t next = oldest_event_index_;
-    oldest_event_index_ = NextIndex(oldest_event_index_);
+    oldest_event_index_ = NextIndex(oldest_event_index_, buffer_size_);
     return GetEventAt(next);
   }
 
   virtual bool IsFull() const OVERRIDE {
     return false;
   }
 
   virtual size_t CountEnabledByName(
       const unsigned char* category,
       const std::string& event_name) const OVERRIDE {
     size_t notify_count = 0;
     size_t index = oldest_event_index_;
     while (index != unused_event_index_) {
       const TraceEvent& event = GetEventAt(index);
       if (category == event.category_group_enabled() &&
           strcmp(event_name.c_str(), event.name()) == 0) {
         ++notify_count;
       }
-      index = NextIndex(index);
+      index = NextIndex(index, buffer_size_);
     }
     return notify_count;
   }
 
   virtual const TraceEvent& GetEventAt(size_t index) const OVERRIDE {
     DCHECK(index < logged_events_.size());
     return logged_events_[index];
   }
 
   virtual size_t Size() const OVERRIDE {
     return logged_events_.size();
   }
 
   virtual size_t Capacity() const OVERRIDE {
     return kTraceEventRingBufferSize;
   }
 
+  virtual TraceBuffer* Clone() const OVERRIDE {
+    TraceBufferRingBuffer* clonedBuffer =
+        new TraceBufferRingBuffer(buffer_size_);
+    size_t index = oldest_event_index_;
+    while (index != unused_event_index_) {
+      const TraceEvent& event = GetEventAt(index);
+      clonedBuffer->AddEvent(event);
+      index = NextIndex(index, buffer_size_);
+    }
+    return clonedBuffer;
+  }
+
  private:
-  static size_t NextIndex(size_t index) {
+  static size_t NextIndex(size_t index, size_t buffer_size) {
     index++;
-    if (index >= kTraceEventRingBufferSize)
+    if (index >= buffer_size)
       index = 0;
     return index;
   }
 
   size_t unused_event_index_;
   size_t oldest_event_index_;
+  size_t buffer_size_;
   std::vector<TraceEvent> logged_events_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceBufferRingBuffer);
 };
 
 class TraceBufferVector : public TraceBuffer {
  public:
   TraceBufferVector() : current_iteration_index_(0) {
     logged_events_.reserve(kTraceEventInitialBufferSize);
   }
@@ skipping 43 matching lines @@
   }
 
   virtual size_t Size() const OVERRIDE {
     return logged_events_.size();
   }
 
   virtual size_t Capacity() const OVERRIDE {
     return kTraceEventVectorBufferSize;
   }
 
+  virtual TraceBuffer* Clone() const OVERRIDE {
+    NOTIMPLEMENTED();
+    return NULL;
+  }
+
  private:
   size_t current_iteration_index_;
   std::vector<TraceEvent> logged_events_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceBufferVector);
 };
 
 class TraceBufferDiscardsEvents : public TraceBuffer {
  public:
   virtual ~TraceBufferDiscardsEvents() { }
@@ skipping 16 matching lines @@
 
   virtual size_t Size() const OVERRIDE { return 0; }
 
   // As this buffer is never full, we can return any positive number.
   virtual size_t Capacity() const OVERRIDE { return 1; }
 
   virtual const TraceEvent& GetEventAt(size_t index) const OVERRIDE {
     NOTREACHED();
     return *static_cast<TraceEvent*>(NULL);
   }
+
+  virtual TraceBuffer* Clone() const OVERRIDE {
+    NOTIMPLEMENTED();
+    return NULL;
+  }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceEvent
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
@@ skipping 365 matching lines @@
 
 // This object must be created on the IO thread.
 class TraceSamplingThread : public PlatformThread::Delegate {
  public:
   TraceSamplingThread();
   virtual ~TraceSamplingThread();
 
   // Implementation of PlatformThread::Delegate:
   virtual void ThreadMain() OVERRIDE;
 
-  static void DefaultSampleCallback(TraceBucketData* bucekt_data);
+  static void DefaultSamplingCallback(TraceBucketData* bucekt_data);
+  static void ContinuousSamplingCallback(TraceBucketData* bucekt_data);
 
   void Stop();
   void InstallWaitableEventForSamplingTesting(WaitableEvent* waitable_event);
 
  private:
   friend class TraceLog;
 
   void GetSamples();
   // Not thread-safe. Once the ThreadMain has been called, this can no longer
   // be called.
@@ skipping 26 matching lines @@
   while (!cancellation_flag_->IsSet()) {
     PlatformThread::Sleep(
         TimeDelta::FromMicroseconds(kSamplingFrequencyMicroseconds));
     GetSamples();
     if (waitable_event_for_testing_.get())
       waitable_event_for_testing_->Signal();
   }
 }
 
 // static
-void TraceSamplingThread::DefaultSampleCallback(TraceBucketData* bucket_data) {
+void TraceSamplingThread::DefaultSamplingCallback(
+    TraceBucketData* bucket_data) {
   TRACE_EVENT_API_ATOMIC_WORD category_and_name =
       TRACE_EVENT_API_ATOMIC_LOAD(*bucket_data->bucket);
   if (!category_and_name)
     return;
   const char* const combined =
       reinterpret_cast<const char* const>(category_and_name);
   const char* category_group;
   const char* name;
   ExtractCategoryAndName(combined, &category_group, &name);
   TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_SAMPLE,
       TraceLog::GetCategoryGroupEnabled(category_group),
       name, 0, 0, NULL, NULL, NULL, NULL, 0);
 }
 
+// static
+void TraceSamplingThread::ContinuousSamplingCallback(
+    TraceBucketData* bucket_data) {
+  TRACE_EVENT_API_ATOMIC_WORD category_and_name =
+      TRACE_EVENT_API_ATOMIC_LOAD(*bucket_data->bucket);
+  if (!category_and_name)
+    return;
+  const char* const combined =
+      reinterpret_cast<const char* const>(category_and_name);
+  const char* category_group;
+  const char* name;
+  ExtractCategoryAndName(combined, &category_group, &name);
+  TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_SAMPLE,
+      TraceLog::GetCategoryGroupEnabled(category_group),
+      name, 0, 0, NULL, NULL, NULL, NULL,
+      TRACE_EVENT_FLAG_CONTINUOUS_SAMPLING);
+}
+
 void TraceSamplingThread::GetSamples() {
   for (size_t i = 0; i < sample_buckets_.size(); ++i) {
     TraceBucketData* bucket_data = &sample_buckets_[i];
     bucket_data->callback.Run(bucket_data);
   }
 }
 
 void TraceSamplingThread::RegisterSampleBucket(
     TRACE_EVENT_API_ATOMIC_WORD* bucket,
     const char* const name,
@@ skipping 12 matching lines @@
 
 void TraceSamplingThread::Stop() {
   cancellation_flag_->Set();
 }
 
 void TraceSamplingThread::InstallWaitableEventForSamplingTesting(
     WaitableEvent* waitable_event) {
   waitable_event_for_testing_.reset(waitable_event);
 }
 
-
 TraceBucketData::TraceBucketData(base::subtle::AtomicWord* bucket,
                                  const char* name,
                                  TraceSampleCallback callback)
     : bucket(bucket),
       bucket_name(name),
       callback(callback) {
 }
 
 TraceBucketData::~TraceBucketData() {
 }
@@ skipping 52 matching lines @@
     }
   }
   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()
     : enable_count_(0),
+      continuous_sampling_enable_count_(0),
       num_traces_recorded_(0),
       event_callback_(NULL),
       dispatching_to_observer_list_(false),
       process_sort_index_(0),
       watch_category_(NULL),
       trace_options_(RECORD_UNTIL_FULL),
       sampling_thread_handle_(0),
       category_filter_(CategoryFilter::kDefaultCategoryFilterString) {
   // Trace is enabled or disabled on one thread while other threads are
   // accessing the enabled flag. We don't care whether edge-case events are
@@ skipping 164 matching lines @@
     num_traces_recorded_++;
 
     category_filter_ = CategoryFilter(category_filter);
     UpdateCategoryGroupEnabledFlags();
 
     if (options & ENABLE_SAMPLING) {
       sampling_thread_.reset(new TraceSamplingThread);
       sampling_thread_->RegisterSampleBucket(
           &g_trace_state[0],
           "bucket0",
-          Bind(&TraceSamplingThread::DefaultSampleCallback));
+          Bind(&TraceSamplingThread::DefaultSamplingCallback));
       sampling_thread_->RegisterSampleBucket(
           &g_trace_state[1],
           "bucket1",
-          Bind(&TraceSamplingThread::DefaultSampleCallback));
+          Bind(&TraceSamplingThread::DefaultSamplingCallback));
       sampling_thread_->RegisterSampleBucket(
           &g_trace_state[2],
           "bucket2",
-          Bind(&TraceSamplingThread::DefaultSampleCallback));
+          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.
@@ skipping 33 matching lines @@
       PlatformThread::Join(sampling_thread_handle_);
       lock_.Acquire();
       sampling_thread_handle_ = PlatformThreadHandle();
       sampling_thread_.reset();
     }
 
     category_filter_.Clear();
     watch_category_ = NULL;
     watch_event_name_ = "";
     UpdateCategoryGroupEnabledFlags();
-    AddMetadataEvents();
+    AddMetadataEvents(0);
 
     dispatching_to_observer_list_ = true;
     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();
 
   {
     AutoLock lock(lock_);
     dispatching_to_observer_list_ = false;
   }
 }
 
+void TraceLog::SetContinuousSamplingEnabled() {
+  AutoLock lock(lock_);
+  if (continuous_sampling_enable_count_++ > 0)
+    return;
+
+  continuous_sampling_logged_events_.reset(
+      new TraceBufferRingBuffer(kSamplingTraceEventBufferSize));
+
+  continuous_sampling_thread_.reset(new TraceSamplingThread);
+  continuous_sampling_thread_->RegisterSampleBucket(
+      &g_trace_state[0],
+      "bucket0",
+      Bind(&TraceSamplingThread::ContinuousSamplingCallback));
+  continuous_sampling_thread_->RegisterSampleBucket(
+      &g_trace_state[1],
+      "bucket1",
+      Bind(&TraceSamplingThread::ContinuousSamplingCallback));
+  continuous_sampling_thread_->RegisterSampleBucket(
+      &g_trace_state[2],
+      "bucket2",
+      Bind(&TraceSamplingThread::ContinuousSamplingCallback));
+  if (!PlatformThread::Create(
+      0,
+      continuous_sampling_thread_.get(),
+      &continuous_sampling_thread_handle_)) {
+    DCHECK(false) << "failed to create thread";
+  }
+}
+
+void TraceLog::SetContinuousSamplingDisabled() {
+  AutoLock lock(lock_);
+  DCHECK(continuous_sampling_enable_count_ > 0);
+  if (--continuous_sampling_enable_count_ != 0)
+    return;
+
+  if (continuous_sampling_thread_.get()) {
+    continuous_sampling_thread_->Stop();
+    lock_.Release();
+    PlatformThread::Join(continuous_sampling_thread_handle_);
+    lock_.Acquire();
+    continuous_sampling_thread_handle_ = PlatformThreadHandle();
+    continuous_sampling_thread_.reset();
+  }
+}
+
 int TraceLog::GetNumTracesRecorded() {
   AutoLock lock(lock_);
   if (enable_count_ == 0)
     return -1;
   return num_traces_recorded_;
 }
 
 void TraceLog::AddEnabledStateObserver(EnabledStateObserver* listener) {
   enabled_state_observer_list_.push_back(listener);
 }
@@ skipping 21 matching lines @@
 }
 
 void TraceLog::SetNotificationCallback(
     const TraceLog::NotificationCallback& cb) {
   AutoLock lock(lock_);
   notification_callback_ = cb;
 }
 
 TraceBuffer* TraceLog::GetTraceBuffer() {
   if (trace_options_ & RECORD_CONTINUOUSLY)
-    return new TraceBufferRingBuffer();
+    return new TraceBufferRingBuffer(kTraceEventRingBufferSize);
   else if (trace_options_ & ECHO_TO_CONSOLE)
     return new TraceBufferDiscardsEvents();
   return new TraceBufferVector();
 }
 
 void TraceLog::SetEventCallback(EventCallback cb) {
   AutoLock lock(lock_);
   event_callback_ = cb;
 };
 
@@ skipping 20 matching lines @@
           &(json_events_str_ptr->data()));
 
       if (!previous_logged_events->HasMoreEvents())
         break;
     }
 
     cb.Run(json_events_str_ptr);
   }
 }
 
+void TraceLog::FlushContinuousSamplingTracing(
+    const TraceLog::OutputCallback& cb) {
+  if (!continuous_sampling_enable_count_)
+      return;
+
+  scoped_ptr<TraceBuffer> previous_logged_events;
+  {
+    AutoLock lock(lock_);
+    AddMetadataEvents(TRACE_EVENT_FLAG_CONTINUOUS_SAMPLING);
+    previous_logged_events.reset(continuous_sampling_logged_events_->Clone());
+  }  // release lock
+
+  while (previous_logged_events->HasMoreEvents()) {
+    scoped_refptr<RefCountedString> json_events_str_ptr =
+        new RefCountedString();
+
+    for (size_t i = 0; i < kTraceEventBatchSize; ++i) {
+      if (i > 0)
+        *(&(json_events_str_ptr->data())) += ",";
+
+      previous_logged_events->NextEvent().AppendAsJSON(
+          &(json_events_str_ptr->data()));
+
+      if (!previous_logged_events->HasMoreEvents())
+        break;
+    }
+
+    cb.Run(json_events_str_ptr);
+  }
+}
+
 void TraceLog::AddTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
     scoped_ptr<ConvertableToTraceFormat> convertable_values[],
@@ skipping 17 matching lines @@
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
     scoped_ptr<ConvertableToTraceFormat> convertable_values[],
     unsigned char flags) {
   DCHECK(name);
 
   if (flags & TRACE_EVENT_FLAG_MANGLE_ID)
     id ^= process_id_hash_;
 
+  TraceBuffer* logged_events = (flags & TRACE_EVENT_FLAG_CONTINUOUS_SAMPLING) ?
+      continuous_sampling_logged_events_.get() : logged_events_.get();
+
 #if defined(OS_ANDROID)
   SendToATrace(phase, GetCategoryGroupName(category_group_enabled), name, id,
                num_args, arg_names, arg_types, arg_values, convertable_values,
                flags);
 #endif
 
-  if (!IsCategoryGroupEnabled(category_group_enabled))
-    return;
+  // We enable all categories in continuous sampling tracing because it doesn't
+  // make sense to filter categories in sampling tracing.
+  if (!IsCategoryGroupEnabled(category_group_enabled) &&
+      !(flags & TRACE_EVENT_FLAG_CONTINUOUS_SAMPLING))
+      return;
 
   TimeTicks now = timestamp - time_offset_;
   base::TimeTicks thread_now;
   if (base::TimeTicks::IsThreadNowSupported())
     thread_now = base::TimeTicks::ThreadNow();
   EventCallback event_callback_copy;
 
   NotificationHelper notifier(this);
 
   // Check and update the current thread name only if the event is for the
@@ skipping 36 matching lines @@
       num_args, arg_names, arg_types, arg_values,
       convertable_values, flags);
 
   do {
     AutoLock lock(lock_);
 
     event_callback_copy = event_callback_;
     if (logged_events_->IsFull())
       break;
 
-    logged_events_->AddEvent(trace_event);
+    logged_events->AddEvent(trace_event);
 
     if (trace_options_ & ECHO_TO_CONSOLE) {
       TimeDelta duration;
       if (phase == TRACE_EVENT_PHASE_END) {
         duration = timestamp - thread_event_start_times_[thread_id].top();
         thread_event_start_times_[thread_id].pop();
       }
 
       std::string thread_name = thread_names_[thread_id];
       if (thread_colors_.find(thread_name) == thread_colors_.end())
@@ skipping 107 matching lines @@
       thread_id,
       TimeTicks(), TimeTicks(), TRACE_EVENT_PHASE_METADATA,
       &g_category_group_enabled[g_category_metadata],
       metadata_name, trace_event_internal::kNoEventId,
       num_args, &arg_name, &arg_type, &arg_value, NULL,
       TRACE_EVENT_FLAG_NONE));
 }
 
 }
 
-void TraceLog::AddMetadataEvents() {
+void TraceLog::AddMetadataEvents(unsigned char flags) {
   lock_.AssertAcquired();
 
+  TraceBuffer* logged_events = (flags & TRACE_EVENT_FLAG_CONTINUOUS_SAMPLING) ?
+      continuous_sampling_logged_events_.get() : logged_events_.get();
+
   int current_thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   if (process_sort_index_ != 0) {
-    AddMetadataEventToBuffer(logged_events_.get(),
+    AddMetadataEventToBuffer(logged_events,
                              current_thread_id,
                              "process_sort_index", "sort_index",
                              process_sort_index_);
   }
 
   if (process_name_.size()) {
-    AddMetadataEventToBuffer(logged_events_.get(),
+    AddMetadataEventToBuffer(logged_events,
                              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);
     }
-    AddMetadataEventToBuffer(logged_events_.get(),
+    AddMetadataEventToBuffer(logged_events,
                              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;
-    AddMetadataEventToBuffer(logged_events_.get(),
+    AddMetadataEventToBuffer(logged_events,
                              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;
-    AddMetadataEventToBuffer(logged_events_.get(),
+
+    AddMetadataEventToBuffer(logged_events,
                              it->first,
                              "thread_name", "name",
                              it->second);
   }
 }
 
 void TraceLog::InstallWaitableEventForSamplingTesting(
     WaitableEvent* waitable_event) {
-  sampling_thread_->InstallWaitableEventForSamplingTesting(waitable_event);
+  if (sampling_thread_)
+    sampling_thread_->InstallWaitableEventForSamplingTesting(waitable_event);
+}
+
+void TraceLog::InstallWaitableEventForContinuousSamplingTesting(
+    WaitableEvent* waitable_event) {
+  if (continuous_sampling_thread_) {
+    continuous_sampling_thread_->
+        InstallWaitableEventForSamplingTesting(waitable_event);
+  }
 }
 
 void TraceLog::DeleteForTesting() {
   DeleteTraceLogForTesting::Delete();
 }
 
 void TraceLog::SetProcessID(int process_id) {
   process_id_ = process_id;
   // Create a FNV hash from the process ID for XORing.
   // See http://isthe.com/chongo/tech/comp/fnv/ for algorithm details.
@@ skipping 18 matching lines @@
   if(!current_label.length())
     return RemoveProcessLabel(label_id);
 
   AutoLock lock(lock_);
   process_labels_[label_id] = current_label;
 }
 
 void TraceLog::RemoveProcessLabel(int label_id) {
   AutoLock lock(lock_);
   base::hash_map<int, std::string>::iterator it = process_labels_.find(
-        label_id);
+      label_id);
   if (it == process_labels_.end())
     return;
 
   process_labels_.erase(it);
 }
 
 void TraceLog::SetThreadSortIndex(PlatformThreadId thread_id, int sort_index) {
   AutoLock lock(lock_);
   thread_sort_indices_[static_cast<int>(thread_id)] = sort_index;
 }
@@ skipping 175 matching lines @@
   if (!category_group_enabled_) {
     category_group_enabled_ = TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("gpu");
     TRACE_EVENT_API_ATOMIC_STORE(
         *event_uid,
         reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(category_group_enabled_));
   }
   if (*category_group_enabled_) {
     name_ = name;
     TRACE_EVENT_API_ADD_TRACE_EVENT(
         TRACE_EVENT_PHASE_BEGIN,    // phase
-        category_group_enabled_,          // category enabled
+        category_group_enabled_,    // category enabled
         name,                       // name
         0,                          // id
         0,                          // num_args
         NULL,                       // arg_names
         NULL,                       // arg_types
         NULL,                       // arg_values
         NULL,                       // convertable_values
         TRACE_EVENT_FLAG_NONE);     // flags
   } else {
     category_group_enabled_ = NULL;
@@ skipping 10 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