base/tracing: Set async phases for ETW export of typed events

Typed events' phases, categories, and names are already exported to ETW
via TraceLog::ShouldAddAfterUpdatingState(). However, when the typed
event is emitted onto a different track, this wasn't yet reflected in
the phase of the event as exported by ETW.

This patch overrides the phase passed on to ETW export for such events
with explicit tracks.

Bug: 1141860
Change-Id: Ia7b0b5b3dcb44e415110396baf9c2239f2fc656b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2494937
Commit-Queue: Eric Seckler <eseckler@chromium.org>
Reviewed-by: Stephen Nusko <nuskos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#820339}

base/trace_event/typed_macros_internal.cc

@@ -27,6 +27,28 @@ base::trace_event::ThreadInstructionCount ThreadInstructionNow() {
 base::trace_event::PrepareTrackEventFunction g_typed_event_callback = nullptr;
 base::trace_event::PrepareTracePacketFunction g_trace_packet_callback = nullptr;
 
+std::pair<char /*phase*/, unsigned long long /*id*/>
+GetPhaseAndIdForTraceLog(bool explicit_track, uint64_t track_uuid, char phase) {
+  if (!explicit_track)
+    return std::make_pair(phase, trace_event_internal::kNoId);
+
+  switch (phase) {
+    case TRACE_EVENT_PHASE_BEGIN:
+      phase = TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN;
+      break;
+    case TRACE_EVENT_PHASE_END:
+      phase = TRACE_EVENT_PHASE_NESTABLE_ASYNC_END;
+      break;
+    case TRACE_EVENT_PHASE_INSTANT:
+      phase = TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT;
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+  return std::make_pair(phase, static_cast<unsigned long long>(track_uuid));
+}
+
 }  // namespace
 
 namespace base {
@@ -95,7 +117,7 @@ base::trace_event::TrackEventHandle CreateTrackEvent(
     const char* name,
     unsigned int flags,
     base::TimeTicks ts,
-    bool explicit_track) {
+    uint64_t track_uuid) {
   DCHECK(phase == TRACE_EVENT_PHASE_BEGIN || phase == TRACE_EVENT_PHASE_END ||
          phase == TRACE_EVENT_PHASE_INSTANT);
   DCHECK(category_group_enabled);
@@ -106,9 +128,17 @@ base::trace_event::TrackEventHandle CreateTrackEvent(
   const int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   auto* trace_log = base::trace_event::TraceLog::GetInstance();
   DCHECK(trace_log);
-  if (!trace_log->ShouldAddAfterUpdatingState(phase, category_group_enabled,
-                                              name, trace_event_internal::kNoId,
-                                              thread_id, nullptr)) {
+
+  // Provide events emitted onto different tracks as NESTABLE_ASYNC events to
+  // TraceLog, so that e.g. ETW export is aware of them not being a sync event
+  // for the current thread.
+  bool explicit_track = track_uuid != perfetto::Track().uuid;
+  auto phase_and_id_for_trace_log =
+      GetPhaseAndIdForTraceLog(explicit_track, track_uuid, phase);
+
+  if (!trace_log->ShouldAddAfterUpdatingState(
+          phase_and_id_for_trace_log.first, category_group_enabled, name,
+          phase_and_id_for_trace_log.second, thread_id, nullptr)) {
     return base::trace_event::TrackEventHandle();
   }
 

base/trace_event/typed_macros_internal.h

@@ -91,7 +91,7 @@ CreateTrackEvent(char phase,
                  const char* name,
                  unsigned int flags,
                  base::TimeTicks timestamp,
-                 bool explicit_track);
+                 uint64_t track_uuid);
 
 base::trace_event::TracePacketHandle BASE_EXPORT CreateTracePacket();
 
@@ -121,9 +121,8 @@ inline void AddTraceEvent(char phase,
                           TrackEventArgumentFunction argument_func) {
   bool emit_track_descriptor = false;
   {
-    base::trace_event::TrackEventHandle track_event =
-        CreateTrackEvent(phase, category_group_enabled, name, flags, timestamp,
-                         track.uuid != perfetto::Track().uuid);
+    base::trace_event::TrackEventHandle track_event = CreateTrackEvent(
+        phase, category_group_enabled, name, flags, timestamp, track.uuid);
     if (!track_event)
       return;