Use a unique ID for each Renderer Scheduler trace event

Renderer Scheduler trace events now use the location of the
TraceableState/TraceableCounter to generate the local ID instead of all
using the address of the MainThreadSchedulerImpl. This is done by
removing the object_ field from TraceableState/TraceableCounter and just
using "this" to generate the ID.

Change-Id: I33f126b23e1f4f149d939e08c09843b695a2073a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2324121Reviewed-by: Sami Kyöstilä <skyostil@chromium.org>
Commit-Queue: Dan Elphick <delphick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#793588}

third_party/blink/renderer/platform/scheduler/common/throttling/cpu_time_budget_pool.cc

@@ -23,7 +23,6 @@ CPUTimeBudgetPool::CPUTimeBudgetPool(
     : BudgetPool(name, budget_pool_controller),
       current_budget_level_(base::TimeDelta(),
                             "RendererScheduler.BackgroundBudgetMs",
-                            budget_pool_controller,
                             tracing_controller,
                             TimeDeltaToMilliseconds),
       last_checkpoint_(now),

third_party/blink/renderer/platform/scheduler/common/tracing_helper.h

@@ -93,14 +93,13 @@ class StateTracer {
   DISALLOW_NEW();
 
  public:
-  StateTracer(const char* name, const void* object)
-      : name_(name), object_(object), slice_is_open_(false) {
+  explicit StateTracer(const char* name) : name_(name), slice_is_open_(false) {
     internal::ValidateTracingCategory(category);
   }
 
   ~StateTracer() {
     if (slice_is_open_)
-      TRACE_EVENT_NESTABLE_ASYNC_END0(category, name_, TRACE_ID_LOCAL(object_));
+      TRACE_EVENT_NESTABLE_ASYNC_END0(category, name_, TRACE_ID_LOCAL(this));
   }
 
   // String will be copied before leaving this function.
@@ -122,25 +121,23 @@ class StateTracer {
  private:
   void TraceImpl(const char* state, bool need_copy) {
     if (slice_is_open_) {
-      TRACE_EVENT_NESTABLE_ASYNC_END0(category, name_, TRACE_ID_LOCAL(object_));
+      TRACE_EVENT_NESTABLE_ASYNC_END0(category, name_, TRACE_ID_LOCAL(this));
       slice_is_open_ = false;
     }
     if (!state || !is_enabled())
       return;
 
     if (need_copy) {
-      TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(category, name_,
-                                        TRACE_ID_LOCAL(object_), "state",
-                                        TRACE_STR_COPY(state));
+      TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(category, name_, TRACE_ID_LOCAL(this),
+                                        "state", TRACE_STR_COPY(state));
     } else {
-      TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(
-          category, name_, TRACE_ID_LOCAL(object_), "state", state);
+      TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(category, name_, TRACE_ID_LOCAL(this),
+                                        "state", state);
     }
     slice_is_open_ = true;
   }
 
   const char* const name_;    // Not owned.
-  const void* const object_;  // Not owned.
 
   // We have to track whether slice is open to avoid confusion since assignment,
   // "absent" state and OnTraceLogEnabled can happen anytime.
@@ -160,11 +157,10 @@ class TraceableState : public TraceableVariable, private StateTracer<category> {
 
   TraceableState(T initial_state,
                  const char* name,
-                 const void* object,
                  TraceableVariableController* controller,
                  ConverterFuncPtr converter)
       : TraceableVariable(controller),
-        StateTracer<category>(name, object),
+        StateTracer<category>(name),
         converter_(converter),
         state_(initial_state) {
     Trace();
@@ -227,12 +223,10 @@ class TraceableCounter : public TraceableVariable {
 
   TraceableCounter(T initial_value,
                    const char* name,
-                   const void* object,
                    TraceableVariableController* controller,
                    ConverterFuncPtr converter)
       : TraceableVariable(controller),
         name_(name),
-        object_(object),
         converter_(converter),
         value_(initial_value) {
     internal::ValidateTracingCategory(category);
@@ -241,16 +235,10 @@ class TraceableCounter : public TraceableVariable {
 
   TraceableCounter(T initial_value,
                    const char* name,
-                   const void* object,
                    TraceableVariableController* controller)
-      : TraceableVariable(controller),
-        name_(name),
-        object_(object),
-        converter_([](const T& value) { return static_cast<double>(value); }),
-        value_(initial_value) {
-    internal::ValidateTracingCategory(category);
-    Trace();
-  }
+      : TraceableCounter(initial_value, name, controller, [](const T& value) {
+          return static_cast<double>(value);
+        }) {}
 
   TraceableCounter& operator=(const T& value) {
     value_ = value;
@@ -281,12 +269,11 @@ class TraceableCounter : public TraceableVariable {
   void OnTraceLogEnabled() final { Trace(); }
 
   void Trace() const {
-    TRACE_COUNTER_ID1(category, name_, object_, converter_(value_));
+    TRACE_COUNTER_ID1(category, name_, this, converter_(value_));
   }
 
  private:
   const char* const name_;    // Not owned.
-  const void* const object_;  // Not owned.
   const ConverterFuncPtr converter_;
 
   T value_;

third_party/blink/renderer/platform/scheduler/common/tracing_helper_unittest.cc

@@ -36,7 +36,7 @@ class TraceableStateForTest
     : public TraceableState<int, TracingCategoryName::kDefault> {
  public:
   TraceableStateForTest(TraceableVariableController* controller)
-      : TraceableState(0, "State", controller, controller, SignOfInt) {
+      : TraceableState(0, "State", controller, SignOfInt) {
     // We shouldn't expect trace in constructor here because mock isn't set yet.
     mock_trace_for_test_ = &MockTrace;
   }
@@ -73,9 +73,9 @@ TEST(TracingHelperTest, TraceableState) {
 TEST(TracingHelperTest, TraceableStateOperators) {
   TraceableVariableController controller;
   TraceableState<int, TracingCategoryName::kDebug> x(-1, "X", &controller,
-                                                     &controller, SignOfInt);
+                                                     SignOfInt);
   TraceableState<int, TracingCategoryName::kDebug> y(1, "Y", &controller,
-                                                     &controller, SignOfInt);
+                                                     SignOfInt);
   EXPECT_EQ(0, x + y);
   EXPECT_FALSE(x == y);
   EXPECT_TRUE(x != y);

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc

@@ -123,62 +123,52 @@ FrameSchedulerImpl::FrameSchedulerImpl(
       throttling_state_(SchedulingLifecycleState::kNotThrottled),
       frame_visible_(true,
                      "FrameScheduler.FrameVisible",
-                     this,
                      &tracing_controller_,
                      VisibilityStateToString),
       frame_paused_(false,
                     "FrameScheduler.FramePaused",
-                    this,
                     &tracing_controller_,
                     PausedStateToString),
       frame_origin_type_(frame_type == FrameType::kMainFrame
                              ? FrameOriginType::kMainFrame
                              : FrameOriginType::kSameOriginToMainFrame,
                          "FrameScheduler.Origin",
-                         this,
                          &tracing_controller_,
                          FrameOriginTypeToString),
       subresource_loading_paused_(false,
                                   "FrameScheduler.SubResourceLoadingPaused",
-                                  this,
                                   &tracing_controller_,
                                   PausedStateToString),
-      url_tracer_("FrameScheduler.URL", this),
+      url_tracer_("FrameScheduler.URL"),
       task_queues_throttled_(false,
                              "FrameScheduler.TaskQueuesThrottled",
-                             this,
                              &tracing_controller_,
                              YesNoStateToString),
       preempted_for_cooperative_scheduling_(
           false,
           "FrameScheduler.PreemptedForCooperativeScheduling",
-          this,
           &tracing_controller_,
           YesNoStateToString),
       all_throttling_opt_out_count_(0),
       aggressive_throttling_opt_out_count_(0),
       opted_out_from_all_throttling_(false,
                                      "FrameScheduler.AllThrottlingDisabled",
-                                     this,
                                      &tracing_controller_,
                                      YesNoStateToString),
       opted_out_from_aggressive_throttling_(
           false,
           "FrameScheduler.AggressiveThrottlingDisabled",
-          this,
           &tracing_controller_,
           YesNoStateToString),
       subresource_loading_pause_count_(0u),
       opted_out_from_back_forward_cache_(
           false,
           "FrameScheduler.OptedOutFromBackForwardCache",
-          this,
           &tracing_controller_,
           YesNoStateToString),
       page_frozen_for_tracing_(
           parent_page_scheduler_ ? parent_page_scheduler_->IsFrozen() : true,
           "FrameScheduler.PageFrozen",
-          this,
           &tracing_controller_,
           FrozenStateToString),
       page_visibility_for_tracing_(
@@ -186,23 +176,19 @@ FrameSchedulerImpl::FrameSchedulerImpl(
               ? PageVisibilityState::kVisible
               : PageVisibilityState::kHidden,
           "FrameScheduler.PageVisibility",
-          this,
           &tracing_controller_,
           PageVisibilityStateToString),
       page_keep_active_for_tracing_(
           parent_page_scheduler_ ? parent_page_scheduler_->KeepActive() : false,
           "FrameScheduler.KeepActive",
-          this,
           &tracing_controller_,
           KeepActiveStateToString),
       waiting_for_contentful_paint_(true,
                                     "FrameScheduler.WaitingForContentfulPaint",
-                                    this,
                                     &tracing_controller_,
                                     YesNoStateToString),
       waiting_for_meaningful_paint_(true,
                                     "FrameScheduler.WaitingForMeaningfulPaint",
-                                    this,
                                     &tracing_controller_,
                                     YesNoStateToString) {
   frame_task_queue_controller_.reset(

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -348,94 +348,77 @@ MainThreadSchedulerImpl::MainThreadOnly::MainThreadOnly(
                           kShortIdlePeriodDurationPercentile),
       current_use_case(UseCase::kNone,
                        "Scheduler.UseCase",
-                       main_thread_scheduler_impl,
                        &main_thread_scheduler_impl->tracing_controller_,
                        UseCaseToString),
       longest_jank_free_task_duration(
           base::TimeDelta(),
           "Scheduler.LongestJankFreeTaskDuration",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           TimeDeltaToMilliseconds),
       renderer_pause_count(0,
                            "Scheduler.PauseCount",
-                           main_thread_scheduler_impl,
                            &main_thread_scheduler_impl->tracing_controller_),
       rail_mode_for_tracing(current_policy.rail_mode(),
                             "Scheduler.RAILMode",
-                            main_thread_scheduler_impl,
                             &main_thread_scheduler_impl->tracing_controller_,
                             RAILModeToString),
       renderer_hidden(false,
                       "RendererVisibility",
-                      main_thread_scheduler_impl,
                       &main_thread_scheduler_impl->tracing_controller_,
                       HiddenStateToString),
       renderer_backgrounded(kLaunchingProcessIsBackgrounded,
                             "RendererPriority",
-                            main_thread_scheduler_impl,
                             &main_thread_scheduler_impl->tracing_controller_,
                             BackgroundStateToString),
       keep_active_fetch_or_worker(
           false,
           "Scheduler.KeepRendererActive",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       blocking_input_expected_soon(
           false,
           "Scheduler.BlockingInputExpectedSoon",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       have_reported_blocking_intervention_in_current_policy(
           false,
           "Scheduler.HasReportedBlockingInterventionInCurrentPolicy",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       have_reported_blocking_intervention_since_navigation(
           false,
           "Scheduler.HasReportedBlockingInterventionSinceNavigation",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       has_visible_render_widget_with_touch_handler(
           false,
           "Scheduler.HasVisibleRenderWidgetWithTouchHandler",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       in_idle_period_for_testing(
           false,
           "Scheduler.InIdlePeriod",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       use_virtual_time(false,
                        "Scheduler.UseVirtualTime",
-                       main_thread_scheduler_impl,
                        &main_thread_scheduler_impl->tracing_controller_,
                        YesNoStateToString),
       is_audio_playing(false,
                        "RendererAudioState",
-                       main_thread_scheduler_impl,
                        &main_thread_scheduler_impl->tracing_controller_,
                        AudioPlayingStateToString),
       compositor_will_send_main_frame_not_expected(
           false,
           "Scheduler.CompositorWillSendMainFrameNotExpected",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       has_navigated(false,
                     "Scheduler.HasNavigated",
-                    main_thread_scheduler_impl,
                     &main_thread_scheduler_impl->tracing_controller_,
                     YesNoStateToString),
       pause_timers_for_webview(false,
                                "Scheduler.PauseTimersForWebview",
-                               main_thread_scheduler_impl,
                                &main_thread_scheduler_impl->tracing_controller_,
                                YesNoStateToString),
       background_status_changed_at(now),
@@ -446,19 +429,16 @@ MainThreadSchedulerImpl::MainThreadOnly::MainThreadOnly(
           renderer_backgrounded),
       process_type(WebRendererProcessType::kRenderer,
                    "RendererProcessType",
-                   main_thread_scheduler_impl,
                    &main_thread_scheduler_impl->tracing_controller_,
                    RendererProcessTypeToString),
       task_description_for_tracing(
           base::nullopt,
           "Scheduler.MainThreadTask",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           OptionalTaskDescriptionToString),
       task_priority_for_tracing(
           base::nullopt,
           "Scheduler.TaskPriority",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           OptionalTaskPriorityToString),
       virtual_time_policy(VirtualTimePolicy::kAdvance),
@@ -469,7 +449,6 @@ MainThreadSchedulerImpl::MainThreadOnly::MainThreadOnly(
       prioritize_compositing_after_input(
           false,
           "Scheduler.PrioritizeCompositingAfterInput",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       compositor_priority_experiments(main_thread_scheduler_impl),
@@ -482,60 +461,50 @@ MainThreadSchedulerImpl::AnyThread::AnyThread(
     : awaiting_touch_start_response(
           false,
           "Scheduler.AwaitingTouchstartResponse",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       in_idle_period(false,
                      "Scheduler.InIdlePeriod",
-                     main_thread_scheduler_impl,
                      &main_thread_scheduler_impl->tracing_controller_,
                      YesNoStateToString),
       begin_main_frame_on_critical_path(
           false,
           "Scheduler.BeginMainFrameOnCriticalPath",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       last_gesture_was_compositor_driven(
           false,
           "Scheduler.LastGestureWasCompositorDriven",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       default_gesture_prevented(
           true,
           "Scheduler.DefaultGesturePrevented",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       have_seen_a_blocking_gesture(
           false,
           "Scheduler.HaveSeenBlockingGesture",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       waiting_for_any_main_frame_contentful_paint(
           false,
           "Scheduler.WaitingForMainFrameContentfulPaint",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       waiting_for_any_main_frame_meaningful_paint(
           false,
           "Scheduler.WaitingForMeaningfulPaint",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       have_seen_input_since_navigation(
           false,
           "Scheduler.HaveSeenInputSinceNavigation",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
       begin_main_frame_scheduled_count(
           0,
           "Scheduler.BeginMainFrameScheduledCount",
-          main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_) {}
 
 MainThreadSchedulerImpl::SchedulingSettings::SchedulingSettings() {