SF: plumb PhysicalDisplayId to kernelIdleTimerCallback and vrrDisplayIdle

Scheduler::kernelIdleTimerCallback() and
ISchedulerCallback::vrrDisplayIdle() both hardcode in active/pacesetter
displays in the body. This CL adds PhysicalDisplayId as an argument to
these functions and passes the display in that way instead to make it
more general.

Flag: EXEMPT trivial refactor
Bug: 255635821
Test: presubmit
Change-Id: I739e4e5bd2621e1459f6d3d9c152f06ed24f1602

Author: Su Hong Koo

services/surfaceflinger/Scheduler/ISchedulerCallback.h

@@ -32,7 +32,7 @@ struct ISchedulerCallback {
     virtual void onExpectedPresentTimePosted(TimePoint, ftl::NonNull<DisplayModePtr>,
                                              Fps renderRate) = 0;
     virtual void onCommitNotComposited() = 0;
-    virtual void vrrDisplayIdle(bool idle) = 0;
+    virtual void vrrDisplayIdle(PhysicalDisplayId, bool idle) = 0;
 
 protected:
     ~ISchedulerCallback() = default;

services/surfaceflinger/Scheduler/Scheduler.cpp

@@ -840,12 +840,23 @@ auto Scheduler::getVsyncScheduleLocked(std::optional<PhysicalDisplayId> idOpt) c
     return displayOpt->get().schedulePtr;
 }
 
-void Scheduler::kernelIdleTimerCallback(TimerState state) {
+void Scheduler::kernelIdleTimerCallback(PhysicalDisplayId displayId, TimerState state) {
     SFTRACE_INT("ExpiredKernelIdleTimer", static_cast<int>(state));
 
-    // TODO(145561154): cleanup the kernel idle timer implementation and the refresh rate
-    // magic number
-    const Fps refreshRate = pacesetterSelectorPtr()->getActiveMode().modePtr->getPeakFps();
+    Fps refreshRate;
+    {
+        std::scoped_lock lock(mDisplayLock);
+        ftl::FakeGuard guard(kMainThreadContext);
+        const auto displayOpt = mDisplays.get(displayId);
+        if (!displayOpt) {
+            ALOGW("%s: Invalid display %s!", __func__, to_string(displayId).c_str());
+            return;
+        }
+
+        // TODO: b/145561154 - Clean up the kernel idle timer implementation and the refresh rate
+        // magic number
+        refreshRate = displayOpt->get().selectorPtr->getActiveMode().modePtr->getPeakFps();
+    }
 
     constexpr Fps FPS_THRESHOLD_FOR_KERNEL_TIMER = 65_Hz;
     using namespace fps_approx_ops;
@@ -1010,11 +1021,24 @@ std::shared_ptr<VsyncSchedule> Scheduler::promotePacesetterDisplayLocked(
             pacesetter.selectorPtr->setIdleTimerCallbacks(
                     {.platform = {.onReset = [this] { idleTimerCallback(TimerState::Reset); },
                                   .onExpired = [this] { idleTimerCallback(TimerState::Expired); }},
-                     .kernel = {.onReset = [this] { kernelIdleTimerCallback(TimerState::Reset); },
+                     .kernel = {.onReset =
+                                        [this, pacesetterId] {
+                                            kernelIdleTimerCallback(pacesetterId,
+                                                                    TimerState::Reset);
+                                        },
                                 .onExpired =
-                                        [this] { kernelIdleTimerCallback(TimerState::Expired); }},
-                     .vrr = {.onReset = [this] { mSchedulerCallback.vrrDisplayIdle(false); },
-                             .onExpired = [this] { mSchedulerCallback.vrrDisplayIdle(true); }}});
+                                        [this, pacesetterId] {
+                                            kernelIdleTimerCallback(pacesetterId,
+                                                                    TimerState::Expired);
+                                        }},
+                     .vrr = {.onReset =
+                                     [this, pacesetterId] {
+                                         mSchedulerCallback.vrrDisplayIdle(pacesetterId, false);
+                                     },
+                             .onExpired =
+                                     [this, pacesetterId] {
+                                         mSchedulerCallback.vrrDisplayIdle(pacesetterId, true);
+                                     }}});
 
             pacesetter.selectorPtr->startIdleTimer();
         }

services/surfaceflinger/Scheduler/Scheduler.h

@@ -381,7 +381,7 @@ class Scheduler : public IEventThreadCallback, android::impl::MessageQueue {
     }
 
     // Update feature state machine to given state when corresponding timer resets or expires.
-    void kernelIdleTimerCallback(TimerState) EXCLUDES(mDisplayLock);
+    void kernelIdleTimerCallback(PhysicalDisplayId, TimerState) EXCLUDES(mDisplayLock);
     void idleTimerCallback(TimerState);
     void touchTimerCallback(TimerState);
     void displayPowerTimerCallback(TimerState);

services/surfaceflinger/SurfaceFlinger.cpp

@@ -7266,19 +7266,16 @@ void SurfaceFlinger::kernelTimerChanged(bool expired) {
     }));
 }
 
-void SurfaceFlinger::vrrDisplayIdle(bool idle) {
+void SurfaceFlinger::vrrDisplayIdle(PhysicalDisplayId displayId, bool idle) {
     // Update the overlay on the main thread to avoid race conditions with
     // RefreshRateSelector::getActiveMode
     static_cast<void>(mScheduler->schedule([=, this] {
-        const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
-        if (!display) {
-            ALOGW("%s: default display is null", __func__);
-            return;
+        if (const auto display = FTL_FAKE_GUARD(mStateLock, getDisplayDeviceLocked(displayId))) {
+            if (display->isRefreshRateOverlayEnabled()) {
+                display->onVrrIdle(idle);
+                mScheduler->scheduleFrame();
+            }
         }
-        if (!display->isRefreshRateOverlayEnabled()) return;
-
-        display->onVrrIdle(idle);
-        mScheduler->scheduleFrame();
     }));
 }
 

services/surfaceflinger/SurfaceFlinger.h

@@ -701,7 +701,7 @@ class SurfaceFlinger : public BnSurfaceComposer,
                                      Fps renderRate) override;
     void onCommitNotComposited() override
             REQUIRES(kMainThreadContext);
-    void vrrDisplayIdle(bool idle) override;
+    void vrrDisplayIdle(PhysicalDisplayId displayId, bool idle) override;
 
     // ICEPowerCallback overrides:
     void notifyCpuLoadUp() override;

services/surfaceflinger/tests/unittests/mock/MockSchedulerCallback.h

@@ -30,7 +30,7 @@ struct SchedulerCallback final : ISchedulerCallback {
     MOCK_METHOD(void, onExpectedPresentTimePosted, (TimePoint, ftl::NonNull<DisplayModePtr>, Fps),
                 (override));
     MOCK_METHOD(void, onCommitNotComposited, (), (override));
-    MOCK_METHOD(void, vrrDisplayIdle, (bool), (override));
+    MOCK_METHOD(void, vrrDisplayIdle, (PhysicalDisplayId, bool), (override));
 };
 
 struct NoOpSchedulerCallback final : ISchedulerCallback {
@@ -40,7 +40,7 @@ struct NoOpSchedulerCallback final : ISchedulerCallback {
     void onChoreographerAttached() override {}
     void onExpectedPresentTimePosted(TimePoint, ftl::NonNull<DisplayModePtr>, Fps) override {}
     void onCommitNotComposited() override {}
-    void vrrDisplayIdle(bool) override {}
+    void vrrDisplayIdle(PhysicalDisplayId, bool) override {}
 };
 
 } // namespace android::scheduler::mock