Revert "libhwc2.1: support setIdleTimerEnabled"

This reverts commit 91700d7c6e6cea728e3d8525745ddbf8a0517c98.

Reason for revert: Introduced untracked linux denials
BUG: 219857957

Change-Id: I924352333ff3c36e971c11a8f48831ab5cac75b3

15 files changed, 20 insertions, 187 deletions

diff --git a/hwc3/ComposerClient.cpp b/hwc3/ComposerClient.cpp
index 49d0e80..848d1f7 100644
--- a/hwc3/ComposerClient.cpp
+++ b/hwc3/ComposerClient.cpp
@@ -162,16 +162,6 @@ ndk::ScopedAStatus ComposerClient::getDisplayCapabilities(int64_t display,
         return TO_BINDER_STATUS(err);
     }
 
-    bool support = false;
-    err = mHal->getDisplayIdleTimerSupport(display, support);
-    if (err != ::android::OK) {
-        LOG(ERROR) << "failed to getDisplayIdleTimerSupport: " << err;
-    }
-
-    if (support) {
-        caps->push_back(DisplayCapability::DISPLAY_IDLE_TIMER);
-    }
-
     return TO_BINDER_STATUS(err);
 }
 
diff --git a/hwc3/impl/HalImpl.cpp b/hwc3/impl/HalImpl.cpp
index e16aff9..c999d50 100644
--- a/hwc3/impl/HalImpl.cpp
+++ b/hwc3/impl/HalImpl.cpp
@@ -939,11 +939,12 @@ int32_t HalImpl::setVsyncEnabled(int64_t display, bool enabled) {
     return halDisplay->setVsyncEnabled(hwcEnable);
 }
 
-int32_t HalImpl::setIdleTimerEnabled(int64_t display, int32_t timeout) {
+int32_t HalImpl::setIdleTimerEnabled(int64_t display, int32_t __unused timeout) {
     ExynosDisplay* halDisplay;
     RET_IF_ERR(getHalDisplay(display, halDisplay));
 
-    return halDisplay->setDisplayIdleTimer(timeout);
+    // TODO(b/198808492): implement setIdleTimerEnabled
+    return HWC2_ERROR_UNSUPPORTED;
 }
 
 int32_t HalImpl::validateDisplay(int64_t display, std::vector<int64_t>* outChangedLayers,
@@ -1013,11 +1014,4 @@ int32_t HalImpl::getRCDLayerSupport(int64_t display, bool& outSupport) {
     return halDisplay->getRCDLayerSupport(outSupport);
 }
 
-int32_t HalImpl::getDisplayIdleTimerSupport(int64_t display, bool& outSupport) {
-    ExynosDisplay* halDisplay;
-    RET_IF_ERR(getHalDisplay(display, halDisplay));
-
-    return halDisplay->getDisplayIdleTimerSupport(outSupport);
-}
-
 } // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/hwc3/impl/HalImpl.h b/hwc3/impl/HalImpl.h
index 4b87b82..518870f 100644
--- a/hwc3/impl/HalImpl.h
+++ b/hwc3/impl/HalImpl.h
@@ -135,7 +135,6 @@ class HalImpl : public IComposerHal {
     int32_t setReadbackBuffer(int64_t display, buffer_handle_t buffer,
                               const ndk::ScopedFileDescriptor& releaseFence) override;
     int32_t setVsyncEnabled(int64_t display, bool enabled) override;
-    int32_t getDisplayIdleTimerSupport(int64_t display, bool& outSupport) override;
     int32_t setIdleTimerEnabled(int64_t display, int32_t timeout) override;
     int32_t getRCDLayerSupport(int64_t display, bool& outSupport) override;
     int32_t validateDisplay(int64_t display, std::vector<int64_t>* outChangedLayers,
diff --git a/hwc3/include/IComposerHal.h b/hwc3/include/IComposerHal.h
index 6f78f8e..a367868 100644
--- a/hwc3/include/IComposerHal.h
+++ b/hwc3/include/IComposerHal.h
@@ -119,8 +119,6 @@ class IComposerHal {
     virtual int32_t getDisplayAttribute(int64_t display, int32_t config,
                                       DisplayAttribute attribute, int32_t* outValue) = 0;
     virtual int32_t getDisplayBrightnessSupport(int64_t display, bool& outSupport) = 0;
-    virtual int32_t getDisplayIdleTimerSupport(int64_t display, bool& outSupport) = 0;
-
     virtual int32_t getDisplayCapabilities(int64_t display,
                                            std::vector<DisplayCapability>* caps) = 0;
     virtual int32_t getDisplayConfigs(int64_t display, std::vector<int32_t>* configs) = 0;
diff --git a/libhwc2.1/libdevice/ExynosDevice.cpp b/libhwc2.1/libdevice/ExynosDevice.cpp
index 7f67d1d..4bd9d39 100644
--- a/libhwc2.1/libdevice/ExynosDevice.cpp
+++ b/libhwc2.1/libdevice/ExynosDevice.cpp
@@ -1119,11 +1119,10 @@ int ExynosDevice::setRefreshRateThrottle(const int delayMs) {
 
     ExynosDisplay *display = getDisplay(getDisplayId(HWC_DISPLAY_PRIMARY, 0));
     if (display) {
-        return display
-                ->setRefreshRateThrottleNanos(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                                                      std::chrono::milliseconds(delayMs))
-                                                      .count(),
-                                              DispIdleTimerRequester::PIXEL_DISP);
+        return display->setRefreshRateThrottleNanos(
+                std::chrono::duration_cast<std::chrono::nanoseconds>(
+                        std::chrono::milliseconds(delayMs))
+                        .count());
     }
     return BAD_VALUE;
 }
diff --git a/libhwc2.1/libdevice/ExynosDisplay.cpp b/libhwc2.1/libdevice/ExynosDisplay.cpp
index 5e572cb..65c0528 100644
--- a/libhwc2.1/libdevice/ExynosDisplay.cpp
+++ b/libhwc2.1/libdevice/ExynosDisplay.cpp
@@ -5920,7 +5920,3 @@ int32_t ExynosDisplay::getRCDLayerSupport(bool &outSupport) {
     outSupport = mDpuData.rcdConfigs.size() > 0;
     return NO_ERROR;
 }
-
-int32_t ExynosDisplay::getDisplayIdleTimerSupport(bool &outSupport) {
-    return mDisplayInterface->getDisplayIdleTimerSupport(outSupport);
-}
diff --git a/libhwc2.1/libdevice/ExynosDisplay.h b/libhwc2.1/libdevice/ExynosDisplay.h
index fcbaf11..c6ce160 100644
--- a/libhwc2.1/libdevice/ExynosDisplay.h
+++ b/libhwc2.1/libdevice/ExynosDisplay.h
@@ -145,13 +145,6 @@ enum class hwc_request_state_t {
     SET_CONFIG_STATE_REQUESTED,
 };
 
-enum class DispIdleTimerRequester : uint32_t {
-    SF = 0,
-    PIXEL_DISP,
-    TEST,
-    MAX,
-};
-
 #define NUM_SKIP_STATIC_LAYER  5
 struct ExynosFrameInfo
 {
@@ -1193,10 +1186,6 @@ class ExynosDisplay {
         virtual void setExpectedPresentTime(uint64_t __unused timestamp) {}
         virtual uint64_t getPendingExpectedPresentTime() { return 0; }
         virtual void applyExpectedPresentTime() {}
-        virtual int32_t getDisplayIdleTimerSupport(bool& outSupport);
-        virtual int32_t setDisplayIdleTimer(const int32_t __unused timeoutMs) {
-            return HWC2_ERROR_UNSUPPORTED;
-        }
 
         /* getDisplayPreAssignBit support mIndex up to 1.
            It supports only dual LCD and 2 external displays */
@@ -1225,8 +1214,7 @@ class ExynosDisplay {
         void requestLhbm(bool on);
 
         virtual int setMinIdleRefreshRate(const int __unused fps) { return NO_ERROR; }
-        virtual int setRefreshRateThrottleNanos(const int64_t __unused delayNanos,
-                                                const DispIdleTimerRequester __unused requester) {
+        virtual int setRefreshRateThrottleNanos(const int64_t __unused delayNanos) {
             return NO_ERROR;
         }
 
diff --git a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.cpp b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.cpp
index a08de5d..ec1ea99 100644
--- a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.cpp
+++ b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.cpp
@@ -403,18 +403,6 @@ void ExynosDisplayDrmInterface::destroyLayer(ExynosLayer *layer) {
     mFBManager.cleanup(layer);
 }
 
-int32_t ExynosDisplayDrmInterface::getDisplayIdleTimerSupport(bool &outSupport) {
-    auto [ret, support] = mDrmConnector->panel_idle_support().value();
-    if (ret) {
-        ALOGI("no panel_idle_support drm property or invalid value (%d)", ret);
-        outSupport = false;
-    } else {
-        outSupport = (support > 0);
-    }
-
-    return NO_ERROR;
-}
-
 ExynosDisplayDrmInterface::ExynosDisplayDrmInterface(ExynosDisplay *exynosDisplay)
 {
     mType = INTERFACE_TYPE_DRM;
diff --git a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.h b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.h
index 71ecbd3..02303ed 100644
--- a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.h
+++ b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.h
@@ -295,9 +295,6 @@ class ExynosDisplayDrmInterface :
         { return NO_ERROR;};
         virtual void destroyLayer(ExynosLayer *layer) override;
 
-        /* For HWC 3.0 APIs */
-        virtual int32_t getDisplayIdleTimerSupport(bool &outSupport);
-
         virtual int32_t waitVBlank();
         float getDesiredRefreshRate() { return mDesiredModeState.mode.v_refresh(); }
 
diff --git a/libhwc2.1/libdisplayinterface/ExynosDisplayInterface.h b/libhwc2.1/libdisplayinterface/ExynosDisplayInterface.h
index ac773b5..5028e39 100644
--- a/libhwc2.1/libdisplayinterface/ExynosDisplayInterface.h
+++ b/libhwc2.1/libdisplayinterface/ExynosDisplayInterface.h
@@ -71,11 +71,6 @@ class ExynosDisplayInterface {
         /* For HWC 2.4 APIs */
         virtual int32_t getVsyncAppliedTime(hwc2_config_t __unused config, int64_t* __unused actualChangeTime) {return NO_ERROR;}
         virtual void destroyLayer(ExynosLayer* __unused layer){};
-        /* For HWC 3.0 APIs */
-        virtual int32_t getDisplayIdleTimerSupport(bool& outSupport) {
-            outSupport = false;
-            return NO_ERROR;
-        }
 
         virtual int32_t waitVBlank() { return 0; };
     public:
diff --git a/libhwc2.1/libdrmresource/drm/drmconnector.cpp b/libhwc2.1/libdrmresource/drm/drmconnector.cpp
index 3cbd24e..56e9070 100644
--- a/libhwc2.1/libdrmresource/drm/drmconnector.cpp
+++ b/libhwc2.1/libdrmresource/drm/drmconnector.cpp
@@ -150,11 +150,6 @@ int DrmConnector::Init() {
       ALOGE("Could not get mipi_sync property\n");
   }
 
-  ret = drm_->GetConnectorProperty(*this, "panel_idle_support", &panel_idle_support_);
-  if (ret) {
-      ALOGE("Could not get panel_idle_support property\n");
-  }
-
   properties_.push_back(&dpms_property_);
   properties_.push_back(&crtc_id_property_);
   properties_.push_back(&edid_property_);
@@ -175,7 +170,6 @@ int DrmConnector::Init() {
   properties_.push_back(&dimming_on_);
   properties_.push_back(&lhbm_on_);
   properties_.push_back(&mipi_sync_);
-  properties_.push_back(&panel_idle_support_);
 
   return 0;
 }
@@ -387,10 +381,6 @@ int DrmConnector::ResetLpMode() {
     return 0;
 }
 
-const DrmProperty &DrmConnector::panel_idle_support() const {
-    return panel_idle_support_;
-}
-
 DrmEncoder *DrmConnector::encoder() const {
   return encoder_;
 }
diff --git a/libhwc2.1/libdrmresource/include/drmconnector.h b/libhwc2.1/libdrmresource/include/drmconnector.h
index cb6d1b2..441c89f 100644
--- a/libhwc2.1/libdrmresource/include/drmconnector.h
+++ b/libhwc2.1/libdrmresource/include/drmconnector.h
@@ -80,7 +80,6 @@ class DrmConnector {
   const DrmProperty &dimming_on() const;
   const DrmProperty &lhbm_on() const;
   const DrmProperty &mipi_sync() const;
-  const DrmProperty &panel_idle_support() const;
 
   const std::vector<DrmProperty *> &properties() const {
       return properties_;
@@ -137,7 +136,6 @@ class DrmConnector {
   DrmProperty dimming_on_;
   DrmProperty lhbm_on_;
   DrmProperty mipi_sync_;
-  DrmProperty panel_idle_support_;
   std::vector<DrmProperty *> properties_;
 
   std::vector<DrmEncoder *> possible_encoders_;
diff --git a/libhwc2.1/libhwcService/ExynosHWCService.cpp b/libhwc2.1/libhwcService/ExynosHWCService.cpp
index 8c95e02..33d42ea 100644
--- a/libhwc2.1/libhwcService/ExynosHWCService.cpp
+++ b/libhwc2.1/libhwcService/ExynosHWCService.cpp
@@ -462,11 +462,10 @@ int32_t ExynosHWCService::setRefreshRateThrottle(uint32_t display_id, int32_t de
     auto display = mHWCCtx->device->getDisplay(display_id);
 
     if (display != nullptr) {
-        return display
-                ->setRefreshRateThrottleNanos(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                                                      std::chrono::milliseconds(delayMs))
-                                                      .count(),
-                                              DispIdleTimerRequester::TEST);
+        return display->setRefreshRateThrottleNanos(
+                std::chrono::duration_cast<std::chrono::nanoseconds>(
+                        std::chrono::milliseconds(delayMs))
+                        .count());
     }
 
     return -EINVAL;
diff --git a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
index 48e32e3..ef122cd 100644
--- a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
+++ b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
@@ -74,8 +74,7 @@ ExynosPrimaryDisplay::ExynosPrimaryDisplay(uint32_t index, ExynosDevice *device)
         mMinIdleRefreshRate(0),
         mRefreshRateDelayNanos(0),
         mLastRefreshRateAppliedNanos(0),
-        mAppliedActiveConfig(0),
-        mDisplayIdleTimerEnabled(false) {
+        mAppliedActiveConfig(0) {
     // TODO : Hard coded here
     mNumMaxPriorityAllowed = 5;
 
@@ -301,7 +300,6 @@ int32_t ExynosPrimaryDisplay::setPowerMode(int32_t mode) {
 void ExynosPrimaryDisplay::firstPowerOn() {
     SetCurrentPanelGammaSource(DisplayType::DISPLAY_PRIMARY, PanelGammaSource::GAMMA_CALIBRATION);
     mFirstPowerOn = false;
-    getDisplayIdleTimerEnabled(mDisplayIdleTimerEnabled);
 }
 
 bool ExynosPrimaryDisplay::getHDRException(ExynosLayer* __unused layer)
@@ -462,68 +460,6 @@ void ExynosPrimaryDisplay::applyExpectedPresentTime() {
     mExpectedPresentTime.clear_dirty();
 }
 
-int32_t ExynosPrimaryDisplay::setDisplayIdleTimer(const int32_t timeoutMs) {
-    bool support = false;
-    if (getDisplayIdleTimerSupport(support) || support == false) {
-        return HWC2_ERROR_UNSUPPORTED;
-    }
-
-    if (timeoutMs < 0) {
-        return HWC2_ERROR_BAD_PARAMETER;
-    }
-
-    if (timeoutMs > 0) {
-        setRefreshRateThrottleNanos(std::chrono::duration_cast<std::chrono::nanoseconds>(
-                                            std::chrono::milliseconds(timeoutMs))
-                                            .count(),
-                                    DispIdleTimerRequester::SF);
-    }
-
-    bool enabled = (timeoutMs > 0);
-    if (enabled != mDisplayIdleTimerEnabled) {
-        if (setDisplayIdleTimerEnabled(enabled) == NO_ERROR) {
-            mDisplayIdleTimerEnabled = enabled;
-        }
-    }
-
-    return HWC2_ERROR_NONE;
-}
-
-int32_t ExynosPrimaryDisplay::getDisplayIdleTimerEnabled(bool &enabled) {
-    bool support = false;
-    if (getDisplayIdleTimerSupport(support) || support == false) {
-        return HWC2_ERROR_UNSUPPORTED;
-    }
-
-    const std::string path = getPanelSysfsPath(DisplayType::DISPLAY_PRIMARY) + "panel_idle";
-    std::ifstream ifs(path);
-    if (!ifs.is_open()) {
-        ALOGW("%s() unable to open node '%s', error = %s", __func__, path.c_str(), strerror(errno));
-        return errno;
-    } else {
-        std::string panel_idle;
-        std::getline(ifs, panel_idle);
-        ifs.close();
-        enabled = (panel_idle == "1");
-        ALOGI("%s() get panel_idle(%d) from the sysfs node", __func__, enabled);
-    }
-    return NO_ERROR;
-}
-
-int32_t ExynosPrimaryDisplay::setDisplayIdleTimerEnabled(const bool enabled) {
-    const std::string path = getPanelSysfsPath(DisplayType::DISPLAY_PRIMARY) + "panel_idle";
-    std::ofstream ofs(path);
-    if (!ofs.is_open()) {
-        ALOGW("%s() unable to open node '%s', error = %s", __func__, path.c_str(), strerror(errno));
-        return errno;
-    } else {
-        ofs << enabled;
-        ofs.close();
-        ALOGI("%s() writes panel_idle(%d) to the sysfs node", __func__, enabled);
-    }
-    return NO_ERROR;
-}
-
 int ExynosPrimaryDisplay::setMinIdleRefreshRate(const int fps) {
     mMinIdleRefreshRate = fps;
 
@@ -541,30 +477,8 @@ int ExynosPrimaryDisplay::setMinIdleRefreshRate(const int fps) {
     return NO_ERROR;
 }
 
-int ExynosPrimaryDisplay::setRefreshRateThrottleNanos(const int64_t delayNanos,
-                                                      const DispIdleTimerRequester requester) {
-    ALOGI("%s() requester(%u) set delay to %" PRId64 "ns", __func__, toUnderlying(requester),
-          delayNanos);
-    if (delayNanos < 0) {
-        ALOGW("%s() set invalid delay(%" PRId64 ")", __func__, delayNanos);
-        return BAD_VALUE;
-    }
-
-    std::lock_guard<std::mutex> lock(mIdleRefreshRateThrottleMutex);
-
-    int64_t maxDelayNanos = 0;
-    mDisplayIdleTimerNanos[toUnderlying(requester)] = delayNanos;
-    for (uint32_t i = 0; i < toUnderlying(DispIdleTimerRequester::MAX); i++) {
-        if (mDisplayIdleTimerNanos[i] > maxDelayNanos) {
-            maxDelayNanos = mDisplayIdleTimerNanos[i];
-        }
-    }
-
-    if (mRefreshRateDelayNanos == maxDelayNanos) {
-        return NO_ERROR;
-    }
-
-    mRefreshRateDelayNanos = maxDelayNanos;
+int ExynosPrimaryDisplay::setRefreshRateThrottleNanos(const int64_t delayNanos) {
+    mRefreshRateDelayNanos = delayNanos;
 
     const int32_t refreshRateDelayMs = std::chrono::duration_cast<std::chrono::milliseconds>(
                                                std::chrono::nanoseconds(mRefreshRateDelayNanos))
@@ -572,13 +486,13 @@ int ExynosPrimaryDisplay::setRefreshRateThrottleNanos(const int64_t delayNanos,
     const std::string path = getPanelSysfsPath(DisplayType::DISPLAY_PRIMARY) + "idle_delay_ms";
     std::ofstream ofs(path);
     if (!ofs.is_open()) {
-        ALOGW("%s() unable to open node '%s', error = %s", __func__, path.c_str(), strerror(errno));
+        ALOGW("Unable to open node '%s', error = %s", path.c_str(), strerror(errno));
         return errno;
     } else {
         ofs << refreshRateDelayMs;
-        ALOGI("%s() writes idle_delay_ms(%d) to the sysfs node (0x%x)", __func__,
-              refreshRateDelayMs, ofs.rdstate());
         ofs.close();
+        ALOGI("ExynosPrimaryDisplay::%s() writes idle_delay_ms(%d) to the sysfs node", __func__,
+              refreshRateDelayMs);
     }
 
     return NO_ERROR;
@@ -587,11 +501,7 @@ int ExynosPrimaryDisplay::setRefreshRateThrottleNanos(const int64_t delayNanos,
 void ExynosPrimaryDisplay::dump(String8 &result) {
     ExynosDisplay::dump(result);
     result.appendFormat("Min idle refresh rate: %d\n", mMinIdleRefreshRate);
-    result.appendFormat("Refresh rate delay: %" PRId64 "ns\n", mRefreshRateDelayNanos);
-    for (uint32_t i = 0; i < toUnderlying(DispIdleTimerRequester::MAX); i++) {
-        result.appendFormat("    [%u] set to %" PRId64 "ns\n", i, mDisplayIdleTimerNanos[i]);
-    }
-    result.appendFormat("\n\n");
+    result.appendFormat("Refresh rate delay: %" PRId64 "ns\n\n", mRefreshRateDelayNanos);
 }
 
 void ExynosPrimaryDisplay::calculateTimeline(
diff --git a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.h b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.h
index 655194f..0c1df46 100644
--- a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.h
+++ b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.h
@@ -41,14 +41,12 @@ class ExynosPrimaryDisplay : public ExynosDisplay {
         virtual void setExpectedPresentTime(uint64_t timestamp);
         virtual uint64_t getPendingExpectedPresentTime();
         virtual void applyExpectedPresentTime();
-        virtual int32_t setDisplayIdleTimer(const int32_t timeoutMs) override;
 
         virtual void initDisplayInterface(uint32_t interfaceType);
         virtual int32_t doDisplayConfigInternal(hwc2_config_t config) override;
 
         virtual int setMinIdleRefreshRate(const int fps) override;
-        virtual int setRefreshRateThrottleNanos(const int64_t delayNs,
-                                                const DispIdleTimerRequester requester) override;
+        virtual int setRefreshRateThrottleNanos(const int64_t delayNs) override;
         virtual void dump(String8& result) override;
         virtual void updateAppliedActiveConfig(const hwc2_config_t newConfig,
                                                const int64_t ts) override;
@@ -86,8 +84,6 @@ class ExynosPrimaryDisplay : public ExynosDisplay {
         int32_t setPowerOff();
         int32_t setPowerDoze(hwc2_power_mode_t mode);
         void firstPowerOn();
-        int32_t setDisplayIdleTimerEnabled(const bool enabled);
-        int32_t getDisplayIdleTimerEnabled(bool& enabled);
 
         // LHBM
         FILE* mLhbmFd;
@@ -106,14 +102,10 @@ class ExynosPrimaryDisplay : public ExynosDisplay {
         void calculateTimeline(hwc2_config_t config,
                                hwc_vsync_period_change_constraints_t* vsyncPeriodChangeConstraints,
                                hwc_vsync_period_change_timeline_t* outTimeline) override;
-        std::mutex mIdleRefreshRateThrottleMutex;
         int mMinIdleRefreshRate;
         int64_t mRefreshRateDelayNanos;
         int64_t mLastRefreshRateAppliedNanos;
         hwc2_config_t mAppliedActiveConfig;
-
-        bool mDisplayIdleTimerEnabled;
-        int64_t mDisplayIdleTimerNanos[toUnderlying(DispIdleTimerRequester::MAX)];
 };
 
 #endif