base/trace_event: Remove flags/scope parameter from typed trace points

Perfetto doesn't use a flags or scope parameter with typed trace points,
so remove these parameters from the compatibility shim in Chrome too.

Bug: 1006541
Change-Id: I7b184de3a0cacba975446da6be8b4ea5316496b7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2633994
Commit-Queue: Sami Kyöstilä <skyostil@chromium.org>
Auto-Submit: Sami Kyöstilä <skyostil@chromium.org>
Reviewed-by: Eric Seckler <eseckler@chromium.org>
Cr-Commit-Position: refs/heads/master@{#845172}

base/trace_event/task_execution_macros.h

@@ -32,9 +32,7 @@
 // Implementation detail: internal macro to trace a log message, with the source
 // location of the log statement.
 #define INTERNAL_TRACE_LOG_MESSAGE(file, message, line)                      \
-  TRACE_EVENT_INSTANT(                                                \
-      "log", "LogMessage", TRACE_EVENT_SCOPE_THREAD,                  \
-      [&](perfetto::EventContext ctx) {                               \
+  TRACE_EVENT_INSTANT("log", "LogMessage", [&](perfetto::EventContext ctx) { \
     perfetto::protos::pbzero::LogMessage* log =                              \
         ctx.event()->set_log_message();                                      \
     log->set_source_location_iid(                                            \

base/trace_event/trace_event_stub.h

@@ -69,8 +69,8 @@ struct IgnoredValue {
   INTERNAL_TRACE_IGNORE(category, name)
 #define TRACE_EVENT_END(category, ...) INTERNAL_TRACE_IGNORE(category)
 #define TRACE_EVENT(category, name, ...) INTERNAL_TRACE_IGNORE(category, name)
-#define TRACE_EVENT_INSTANT(category, name, scope, ...) \
-  INTERNAL_TRACE_IGNORE(category, name, scope)
+#define TRACE_EVENT_INSTANT(category, name, ...) \
+  INTERNAL_TRACE_IGNORE(category, name)
 
 namespace base {
 namespace trace_event {

base/trace_event/typed_macros.h

@@ -45,13 +45,13 @@
 //       });
 #define TRACE_EVENT_BEGIN(category, name, ...)                              \
   TRACING_INTERNAL_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_BEGIN, category, name, \
-                                   TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__)
+                                   ##__VA_ARGS__)
 
 // End a thread-scoped slice under |category|.
 #define TRACE_EVENT_END(category, ...)                                       \
   TRACING_INTERNAL_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_END, category,          \
                                    trace_event_internal::kTraceEventEndName, \
-                                   TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__)
+                                   ##__VA_ARGS__)
 
 // Begin a thread-scoped slice which gets automatically closed when going out
 // of scope.
@@ -67,8 +67,8 @@
   TRACING_INTERNAL_SCOPED_ADD_TRACE_EVENT(category, name, ##__VA_ARGS__)
 
 // Emit a single event called "name" immediately, with zero duration.
-#define TRACE_EVENT_INSTANT(category, name, scope, ...)                       \
+#define TRACE_EVENT_INSTANT(category, name, ...)                              \
   TRACING_INTERNAL_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_INSTANT, category, name, \
-                                   scope, ##__VA_ARGS__)
+                                   ##__VA_ARGS__)
 
 #endif  // BASE_TRACE_EVENT_TYPED_MACROS_H_

base/trace_event/typed_macros_internal.cc

@@ -115,9 +115,9 @@ base::trace_event::TrackEventHandle CreateTrackEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
-    unsigned int flags,
     base::TimeTicks ts,
-    uint64_t track_uuid) {
+    uint64_t track_uuid,
+    bool explicit_track) {
   DCHECK(phase == TRACE_EVENT_PHASE_BEGIN || phase == TRACE_EVENT_PHASE_END ||
          phase == TRACE_EVENT_PHASE_INSTANT);
   DCHECK(category_group_enabled);
@@ -132,7 +132,6 @@ base::trace_event::TrackEventHandle CreateTrackEvent(
   // 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);
 
@@ -142,12 +141,17 @@ base::trace_event::TrackEventHandle CreateTrackEvent(
     return base::trace_event::TrackEventHandle();
   }
 
+  unsigned int flags = TRACE_EVENT_FLAG_NONE;
   if (ts.is_null()) {
     ts = TRACE_TIME_TICKS_NOW();
   } else {
     flags |= TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP;
   }
 
+  if (phase == TRACE_EVENT_PHASE_INSTANT && !explicit_track) {
+    flags |= TRACE_EVENT_SCOPE_THREAD;
+  }
+
   // Only emit thread time / instruction count for events on the default track
   // without explicit timestamp.
   base::ThreadTicks thread_now;

base/trace_event/typed_macros_internal.h

@@ -23,13 +23,13 @@
 #define TRACING_INTERNAL_CONCAT(a, b) TRACING_INTERNAL_CONCAT2(a, b)
 #define TRACING_INTERNAL_UID(prefix) TRACING_INTERNAL_CONCAT(prefix, __LINE__)
 
-#define TRACING_INTERNAL_ADD_TRACE_EVENT(phase, category, name, flags, ...) \
+#define TRACING_INTERNAL_ADD_TRACE_EVENT(phase, category, name, ...)     \
   do {                                                                   \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category);                    \
     if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED()) {                 \
       trace_event_internal::AddTraceEvent(                               \
           phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
-          flags, ##__VA_ARGS__);                                            \
+          ##__VA_ARGS__);                                                \
     }                                                                    \
   } while (false)
 
@@ -48,18 +48,19 @@
         /* field. As described in macros.h we shouldn't need it in our */     \
         /* end state.                                                  */     \
         TRACING_INTERNAL_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_END, category, "", \
-                                         TRACE_EVENT_FLAG_NONE,               \
                                          [](perfetto::EventContext) {});      \
       }                                                                       \
     } event;                                                                  \
   } TRACING_INTERNAL_UID(scoped_event){[&]() {                                \
     TRACING_INTERNAL_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_BEGIN, category, name, \
-                                     TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__);   \
+                                     ##__VA_ARGS__);                          \
     return 0;                                                                 \
   }()};
 
 namespace trace_event_internal {
 
+static constexpr perfetto::Track kDefaultTrack{};
+
 // Copy of function with the same name from Perfetto client library.
 template <typename T>
 constexpr bool IsValidTraceLambdaImpl(
@@ -89,9 +90,9 @@ base::trace_event::TrackEventHandle BASE_EXPORT
 CreateTrackEvent(char phase,
                  const unsigned char* category_group_enabled,
                  const char* name,
-                 unsigned int flags,
                  base::TimeTicks timestamp,
-                 uint64_t track_uuid);
+                 uint64_t track_uuid,
+                 bool explicit_track);
 
 base::trace_event::TracePacketHandle BASE_EXPORT CreateTracePacket();
 
@@ -115,18 +116,19 @@ template <
 inline void AddTraceEvent(char phase,
                           const unsigned char* category_group_enabled,
                           const char* name,
-                          unsigned int flags,
                           const perfetto::Track& track,
                           base::TimeTicks timestamp,
                           TrackEventArgumentFunction argument_func) {
   bool emit_track_descriptor = false;
   {
-    base::trace_event::TrackEventHandle track_event = CreateTrackEvent(
-        phase, category_group_enabled, name, flags, timestamp, track.uuid);
+    bool explicit_track = &track != &kDefaultTrack;
+    base::trace_event::TrackEventHandle track_event =
+        CreateTrackEvent(phase, category_group_enabled, name, timestamp,
+                         track.uuid, explicit_track);
     if (!track_event)
       return;
 
-    if (track) {
+    if (explicit_track) {
       track_event->set_track_uuid(track.uuid);
       emit_track_descriptor = ShouldEmitTrackDescriptor(
           track.uuid, track_event.incremental_state());
@@ -150,11 +152,10 @@ template <
 inline void AddTraceEvent(char phase,
                           const unsigned char* category_group_enabled,
                           const char* name,
-                          unsigned int flags,
                           const TrackType& track,
                           TrackEventArgumentFunction argument_func) {
-  AddTraceEvent(phase, category_group_enabled, name, flags, track,
-                base::TimeTicks(), argument_func);
+  AddTraceEvent(phase, category_group_enabled, name, track, base::TimeTicks(),
+                argument_func);
 }
 
 template <
@@ -164,17 +165,15 @@ template <
 inline void AddTraceEvent(char phase,
                           const unsigned char* category_group_enabled,
                           const char* name,
-                          unsigned int flags,
                           TrackEventArgumentFunction argument_func) {
-  AddTraceEvent(phase, category_group_enabled, name, flags, perfetto::Track(),
+  AddTraceEvent(phase, category_group_enabled, name, kDefaultTrack,
                 base::TimeTicks(), argument_func);
 }
 
 inline void AddTraceEvent(char phase,
                           const unsigned char* category_group_enabled,
-                          const char* name,
-                          unsigned int flags) {
-  AddTraceEvent(phase, category_group_enabled, name, flags, perfetto::Track(),
+                          const char* name) {
+  AddTraceEvent(phase, category_group_enabled, name, kDefaultTrack,
                 base::TimeTicks(), [](perfetto::EventContext ctx) {});
 }
 
@@ -184,10 +183,9 @@ template <typename TrackType,
 inline void AddTraceEvent(char phase,
                           const unsigned char* category_group_enabled,
                           const char* name,
-                          unsigned int flags,
                           const TrackType& track) {
-  AddTraceEvent(phase, category_group_enabled, name, flags, track,
-                base::TimeTicks(), [](perfetto::EventContext ctx) {});
+  AddTraceEvent(phase, category_group_enabled, name, track, base::TimeTicks(),
+                [](perfetto::EventContext ctx) {});
 }
 
 template <typename TrackType,
@@ -196,10 +194,9 @@ template <typename TrackType,
 inline void AddTraceEvent(char phase,
                           const unsigned char* category_group_enabled,
                           const char* name,
-                          unsigned int flags,
                           const TrackType& track,
                           base::TimeTicks timestamp) {
-  AddTraceEvent(phase, category_group_enabled, name, flags, track, timestamp,
+  AddTraceEvent(phase, category_group_enabled, name, track, timestamp,
                 [](perfetto::EventContext ctx) {});
 }
 

base/trace_event/typed_macros_unittest.cc

@@ -113,6 +113,14 @@ class TypedTraceEventTest : public testing::Test {
 
   ~TypedTraceEventTest() override { ResetTypedTraceEventsForTesting(); }
 
+  perfetto::protos::TrackEvent ParseTrackEvent() {
+    auto serialized_data = event_.event.SerializeAsArray();
+    perfetto::protos::TrackEvent track_event;
+    EXPECT_TRUE(track_event.ParseFromArray(serialized_data.data(),
+                                           serialized_data.size()));
+    return track_event;
+  }
+
  protected:
   TestTrackEvent event_;
   TestTracePacket packet_;
@@ -221,5 +229,43 @@ TEST_F(TypedTraceEventTest, InternedData) {
   CancelTrace();
 }
 
+TEST_F(TypedTraceEventTest, InstantThreadEvent) {
+  TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
+                                      TraceLog::RECORDING_MODE);
+  TRACE_EVENT_INSTANT("cat", "ThreadEvent", [](perfetto::EventContext) {});
+  auto track_event = ParseTrackEvent();
+  EXPECT_FALSE(track_event.has_track_uuid());
+}
+
+TEST_F(TypedTraceEventTest, InstantProcessEvent) {
+  TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
+                                      TraceLog::RECORDING_MODE);
+  TRACE_EVENT_INSTANT("cat", "ProcessEvent", perfetto::ProcessTrack::Current(),
+                      [](perfetto::EventContext) {});
+  auto track_event = ParseTrackEvent();
+  EXPECT_TRUE(track_event.has_track_uuid());
+  EXPECT_EQ(track_event.track_uuid(), perfetto::ProcessTrack::Current().uuid);
+}
+
+TEST_F(TypedTraceEventTest, InstantGlobalEvent) {
+  TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
+                                      TraceLog::RECORDING_MODE);
+  TRACE_EVENT_INSTANT("cat", "GlobalEvent", perfetto::Track::Global(1234),
+                      [](perfetto::EventContext) {});
+  auto track_event = ParseTrackEvent();
+  EXPECT_TRUE(track_event.has_track_uuid());
+  EXPECT_EQ(track_event.track_uuid(), perfetto::Track::Global(1234).uuid);
+}
+
+TEST_F(TypedTraceEventTest, InstantGlobalDefaultEvent) {
+  TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
+                                      TraceLog::RECORDING_MODE);
+  TRACE_EVENT_INSTANT("cat", "GlobalDefaultEvent", perfetto::Track::Global(0),
+                      [](perfetto::EventContext) {});
+  auto track_event = ParseTrackEvent();
+  EXPECT_TRUE(track_event.has_track_uuid());
+  EXPECT_EQ(track_event.track_uuid(), perfetto::Track::Global(0).uuid);
+}
+
 }  // namespace trace_event
 }  // namespace base

services/tracing/public/cpp/perfetto/trace_event_data_source.cc

@@ -1165,7 +1165,7 @@ void TraceEventDataSource::OnMetricsSampleCallback(
     base::HistogramBase::Sample sample) {
   TRACE_EVENT_INSTANT(
       TRACE_DISABLED_BY_DEFAULT("histogram_samples"), "HistogramSample",
-      TRACE_EVENT_SCOPE_THREAD, [&](perfetto::EventContext ctx) {
+      [&](perfetto::EventContext ctx) {
         bool privacy_filtering_enabled =
             TraceEventDataSource::GetInstance()->IsPrivacyFilteringEnabled();
         perfetto::protos::pbzero::ChromeHistogramSample* new_sample =
@@ -1182,9 +1182,11 @@ void TraceEventDataSource::OnMetricsSampleCallback(
 void TraceEventDataSource::OnUserActionSampleCallback(
     const std::string& action,
     base::TimeTicks action_time) {
+  constexpr uint64_t kGlobalInstantTrackId = 0;
   TRACE_EVENT_INSTANT(
       TRACE_DISABLED_BY_DEFAULT("user_action_samples"), "UserAction",
-      TRACE_EVENT_SCOPE_GLOBAL, [&](perfetto::EventContext ctx) {
+      perfetto::Track::Global(kGlobalInstantTrackId),
+      [&](perfetto::EventContext ctx) {
         bool privacy_filtering_enabled =
             TraceEventDataSource::GetInstance()->IsPrivacyFilteringEnabled();
         perfetto::protos::pbzero::ChromeUserEvent* new_sample =

services/tracing/public/cpp/perfetto/trace_event_data_source_unittest.cc

@@ -1789,8 +1789,7 @@ TEST_F(TraceEventDataSourceTest, TypedArgumentsTracingOnBeginAndEnd) {
 TEST_F(TraceEventDataSourceTest, TypedArgumentsTracingOnInstant) {
   StartTraceEventDataSource();
 
-  TRACE_EVENT_INSTANT("browser", "bar", TRACE_EVENT_SCOPE_THREAD,
-                      [&](perfetto::EventContext ctx) {
+  TRACE_EVENT_INSTANT("browser", "bar", [&](perfetto::EventContext ctx) {
     ctx.event()->set_log_message()->set_body_iid(42);
   });