Rename verifier function

mkardous-silabs · mkardous-silabs · commit 81d77746638e · 2024-03-26T15:09:48.000-04:00
diff --git a/src/app/icd/server/ICDManager.cpp b/src/app/icd/server/ICDManager.cpp
@@ -178,7 +178,7 @@ void ICDManager::SendCheckInMsgs()
                 continue;
             }
 
-            if (!CheckInWouldBeSentAtActiveModeVerifier(entry.fabricIndex, entry.monitoredSubject))
+            if (!ShouldCheckInMsgsBeSentAtActiveModeFunction(entry.fabricIndex, entry.monitoredSubject))
             {
                 continue;
             }
@@ -208,9 +208,9 @@ void ICDManager::SendCheckInMsgs()
 #endif // CONFIG_BUILD_FOR_HOST_UNIT_TEST
 }
 
-bool ICDManager::CheckInMessagesWouldBeSent(std::function<RegistrationVerificationFunction> RegistrationVerifier)
+bool ICDManager::CheckInMessagesWouldBeSent(const std::function<ShouldCheckInMsgsBeSentFunction> shouldCheckInMsgsBeSentFunction &)
 {
-    VerifyOrReturnValue(RegistrationVerifier, false);
+    VerifyOrReturnValue(shouldCheckInMsgsBeSentFunction, false);
 
     for (const auto & fabricInfo : *mFabricTable)
     {
@@ -240,7 +240,7 @@ bool ICDManager::CheckInMessagesWouldBeSent(std::function<RegistrationVerificati
             }
 
             // At least one registration would require a Check-In message
-            VerifyOrReturnValue(!RegistrationVerifier(entry.fabricIndex, entry.monitoredSubject), true);
+            VerifyOrReturnValue(!shouldCheckInMsgsBeSentFunction(entry.fabricIndex, entry.monitoredSubject), true);
         }
     }
 
@@ -249,7 +249,7 @@ bool ICDManager::CheckInMessagesWouldBeSent(std::function<RegistrationVerificati
 }
 
 /**
- * CheckInWouldBeSentAtActiveModeVerifier is used to determine if a Check-In message is required for a given registration.
+ * ShouldCheckInMsgsBeSentAtActiveModeFunction is used to determine if a Check-In message is required for a given registration.
  * Due to how the ICD Check-In use-case interacts with the persistent subscription and subscription timeout resumption,
  * having a single implementation of the function renders the implematention very difficult to understand and maintain.
  * Because of this, each valid feature combination has its own implementation of the verifier.
@@ -266,7 +266,7 @@ bool ICDManager::CheckInMessagesWouldBeSent(std::function<RegistrationVerificati
  * @return true Returns true if the fabricIndex and subjectId combination does not have an active or a persisted subscription.
  * @return false Returns false if the fabricIndex and subjectId combination has an active or persisted subscription.
  */
-bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex, NodeId subjectID)
+bool ICDManager::ShouldCheckInMsgsBeSentAtActiveModeFunction(FabricIndex aFabricIndex, NodeId subjectID)
 {
     return !(mSubInfoProvider->SubjectHasActiveSubscription(aFabricIndex, subjectID) ||
              mSubInfoProvider->SubjectHasPersistedSubscription(aFabricIndex, subjectID));
@@ -291,7 +291,7 @@ bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex
  *               If the boot up susbscription has not been completed,
  *               if the fabricIndex and subjectId combination has a persisted subscription.
  */
-bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex, NodeId subjectID)
+bool ICDManager::ShouldCheckInMsgsBeSentAtActiveModeFunction(FabricIndex aFabricIndex, NodeId subjectID)
 {
     bool wouldSendCheckIn = !(mSubInfoProvider->SubjectHasActiveSubscription(aFabricIndex, subjectID));
 
@@ -314,13 +314,13 @@ bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex
  * @return true Returns true if the fabricIndex and subjectId combination does not have an active subscription.
  * @return false Returns false if the fabricIndex and subjectId combination has an active subscription.
  */
-bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex, NodeId subjectID)
+bool ICDManager::ShouldCheckInMsgsBeSentAtActiveModeFunction(FabricIndex aFabricIndex, NodeId subjectID)
 {
     return !(mSubInfoProvider->SubjectHasActiveSubscription(aFabricIndex, subjectID));
 }
 #endif // CHIP_CONFIG_PERSIST_SUBSCRIPTIONS
 
-void ICDManager::TriggerCheckInMessages(const std::function<RegistrationVerificationFunction> & verifier)
+void ICDManager::TriggerCheckInMessages(const std::function<ShouldCheckInMsgsBeSentFunction> & verifier)
 {
     VerifyOrReturn(SupportsFeature(Feature::kCheckInProtocolSupport));
 
@@ -390,8 +390,8 @@ void ICDManager::UpdateOperationState(OperationalState state)
         mOperationalState = OperationalState::IdleMode;
 
 #if CHIP_CONFIG_ENABLE_ICD_CIP
-        std::function<RegistrationVerificationFunction> verifier =
-            std::bind(&ICDManager::CheckInWouldBeSentAtActiveModeVerifier, this, std::placeholders::_1, std::placeholders::_2);
+        std::function<ShouldCheckInMsgsBeSentFunction> verifier =
+            std::bind(&ICDManager::ShouldCheckInMsgsBeSentAtActiveModeFunction, this, std::placeholders::_1, std::placeholders::_2);
 #endif // CHIP_CONFIG_ENABLE_ICD_CIP
 
         // When the active mode interval is 0, we stay in idleMode until a notification brings the icd into active mode
diff --git a/src/app/icd/server/ICDManager.h b/src/app/icd/server/ICDManager.h
@@ -89,7 +89,7 @@ class ICDManager : public ICDListener
      *         false No Check-In messages would be sent
      */
 
-    using RegistrationVerificationFunction = bool(FabricIndex aFabricIndex, NodeId subjectID);
+    using ShouldCheckInMsgsBeSentFunction = bool(FabricIndex aFabricIndex, NodeId subjectID);
 
     ICDManager() {}
     void Init(PersistentStorageDelegate * storage, FabricTable * fabricTable, Crypto::SymmetricKeystore * symmetricKeyStore,
@@ -137,7 +137,7 @@ class ICDManager : public ICDListener
      *
      * @param[in] algo Verifier function to use to determine if we need to send check-in messages
      */
-    void TriggerCheckInMessages(const std::function<RegistrationVerificationFunction> & verifier);
+    void TriggerCheckInMessages(const std::function<ShouldCheckInMsgsBeSentFunction> & verifier);
 
 #if CHIP_CONFIG_PERSIST_SUBSCRIPTIONS && !CHIP_CONFIG_SUBSCRIPTION_TIMEOUT_RESUMPTION
     /**
@@ -190,28 +190,18 @@ class ICDManager : public ICDListener
 
 private:
 #if CHIP_CONFIG_ENABLE_ICD_CIP
-    /**
-     * @brief Verifier to determine if a Check-In message would be sent on transition to ActiveMode
-     *
-     * @param aFabricIndex client fabric index
-     * @param subjectID client subject ID
-     * @return true  Check-In message would be sent on transition to ActiveMode.
-     * @return false Device has an active subscription with the subjectID.
-     *               Device is trying to resume inactive subscriptions with the client. See CHIP_CONFIG_PERSIST_SUBSCRIPTIONS and
-     *               CHIP_CONFIG_SUBSCRIPTION_TIMEOUT_RESUMPTION
-     */
-    bool CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex, NodeId subjectID);
+    bool ShouldCheckInMsgsBeSentAtActiveModeFunction(FabricIndex aFabricIndex, NodeId subjectID);
 
     /**
      * @brief Function checks if at least one client registration would require a Check-In message
      *
-     * @param[in] RegistrationVerifier  function to use to determine if a Check-In message would be sent for a given registration
+     * @param[in] function  function to use to determine if a Check-In message would be sent for a given registration
      *
      * @return true At least one registration would require an Check-In message if we were entering ActiveMode.
      * @return false None of the registration would require a Check-In message either because there are no registration or
      * because they all have associated subscriptions.
      */
-    bool CheckInMessagesWouldBeSent(std::function<RegistrationVerificationFunction> RegistrationVerifier);
+    bool CheckInMessagesWouldBeSent(std::function<ShouldCheckInMsgsBeSentFunction> function);
 #endif // CHIP_CONFIG_ENABLE_ICD_CIP
 
     KeepActiveFlags mKeepActiveFlags{ 0 };
diff --git a/src/app/server/Server.cpp b/src/app/server/Server.cpp
@@ -449,7 +449,7 @@ void Server::OnPlatformEvent(const DeviceLayer::ChipDeviceEvent & event)
         // We trigger Check-In messages before resuming subscriptions to avoid doing both.
         if (!mFailSafeContext.IsFailSafeArmed())
         {
-            std::function<chip::app::ICDManager::RegistrationVerificationFunction> verifier =
+            std::function<chip::app::ICDManager::ShouldCheckInMsgsBeSentFunction> verifier =
                 std::bind(&Server::CheckInWouldBeSentAtBootVerifier, this, std::placeholders::_1, std::placeholders::_2);
             mICDManager.TriggerCheckInMessages(verifier);
         }
@@ -525,7 +525,7 @@ void Server::RejoinExistingMulticastGroups()
 }
 
 #if CHIP_CONFIG_ENABLE_ICD_CIP
-bool Server::CheckInWouldBeSentAtBootVerifier(FabricIndex aFabricIndex, NodeId subjectID)
+bool Server::ShouldCheckInMsgsBeSentAtBootFunction(FabricIndex aFabricIndex, NodeId subjectID)
 {
 #if CHIP_CONFIG_PERSIST_SUBSCRIPTIONS
     // If at least one registration has a persisted entry, do not send Check-In message.
diff --git a/src/app/tests/TestICDManager.cpp b/src/app/tests/TestICDManager.cpp
@@ -624,72 +624,72 @@ class TestICDManager
 
 #if CHIP_CONFIG_PERSIST_SUBSCRIPTIONS
 #if CHIP_CONFIG_SUBSCRIPTION_TIMEOUT_RESUMPTION
-    static void TestCheckInWouldBeSentAtActiveModeVerifier(nlTestSuite * aSuite, void * aContext)
+    static void TestShouldCheckInMsgsBeSentAtActiveModeFunction(nlTestSuite * aSuite, void * aContext)
     {
         TestContext * ctx = static_cast<TestContext *>(aContext);
 
         // Test 1 - Has no ActiveSubscription & no persisted subscription
         ctx->mSubInfoProvider.SetHasActiveSubscription(false);
         ctx->mSubInfoProvider.SetHasPersistedSubscription(false);
-        NL_TEST_ASSERT(aSuite, ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11));
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11));
 
         // Test 2 - Has no active subscription & a persisted subscription
         ctx->mSubInfoProvider.SetHasActiveSubscription(false);
         ctx->mSubInfoProvider.SetHasPersistedSubscription(true);
-        NL_TEST_ASSERT(aSuite, !(ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11)));
+        NL_TEST_ASSERT(aSuite, !(ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11)));
 
         // Test 3 - Has an active subscription & a persisted subscription
         ctx->mSubInfoProvider.SetHasActiveSubscription(true);
         ctx->mSubInfoProvider.SetHasPersistedSubscription(true);
-        NL_TEST_ASSERT(aSuite, !(ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11)));
+        NL_TEST_ASSERT(aSuite, !(ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11)));
     }
 #else
-    static void TestCheckInWouldBeSentAtActiveModeVerifier(nlTestSuite * aSuite, void * aContext)
+    static void TestShouldCheckInMsgsBeSentAtActiveModeFunction(nlTestSuite * aSuite, void * aContext)
     {
         TestContext * ctx = static_cast<TestContext *>(aContext);
 
         // Test 1 - Has no active subscription and no persisted subscription at boot up
         ctx->mSubInfoProvider.SetHasActiveSubscription(false);
         ctx->mSubInfoProvider.SetHasPersistedSubscription(false);
         ctx->mICDManager.mIsBootUpResumeSubscriptionExecuted = false;
-        NL_TEST_ASSERT(aSuite, ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11));
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11));
 
         // Test 2 - Has no active subscription and a persisted subscription at boot up
         ctx->mSubInfoProvider.SetHasActiveSubscription(false);
         ctx->mSubInfoProvider.SetHasPersistedSubscription(true);
         ctx->mICDManager.mIsBootUpResumeSubscriptionExecuted = false;
-        NL_TEST_ASSERT(aSuite, !(ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11)));
+        NL_TEST_ASSERT(aSuite, !(ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11)));
 
         // Test 3 - Has an active subscription and a persisted subscription during normal operations
         ctx->mSubInfoProvider.SetHasActiveSubscription(true);
         ctx->mSubInfoProvider.SetHasPersistedSubscription(true);
         ctx->mICDManager.mIsBootUpResumeSubscriptionExecuted = true;
-        NL_TEST_ASSERT(aSuite, !(ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11)));
+        NL_TEST_ASSERT(aSuite, !(ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11)));
 
         // Test 4 - Has no active subscription and a persisted subscription during normal operations
         ctx->mSubInfoProvider.SetHasActiveSubscription(false);
         ctx->mSubInfoProvider.SetHasPersistedSubscription(true);
         ctx->mICDManager.mIsBootUpResumeSubscriptionExecuted = true;
-        NL_TEST_ASSERT(aSuite, ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11));
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11));
     }
 #endif // CHIP_CONFIG_SUBSCRIPTION_TIMEOUT_RESUMPTION
 #else
-    static void TestCheckInWouldBeSentAtActiveModeVerifier(nlTestSuite * aSuite, void * aContext)
+    static void TestShouldCheckInMsgsBeSentAtActiveModeFunction(nlTestSuite * aSuite, void * aContext)
     {
         TestContext * ctx = static_cast<TestContext *>(aContext);
 
         // Test 1 - Has an active subscription
         ctx->mSubInfoProvider.SetHasActiveSubscription(true);
         NL_TEST_ASSERT(aSuite,
-                       ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11) == false);
+                       ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11) == false);
 
         // Test 2 - Has no active subscription
         ctx->mSubInfoProvider.SetHasActiveSubscription(false);
-        NL_TEST_ASSERT(aSuite, ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11));
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11));
 
         // Test 3 - Make sure that the persisted subscription has no impact
         ctx->mSubInfoProvider.SetHasPersistedSubscription(true);
-        NL_TEST_ASSERT(aSuite, ctx->mICDManager.CheckInWouldBeSentAtActiveModeVerifier(kTestFabricIndex1, kClientNodeId11));
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.ShouldCheckInMsgsBeSentAtActiveModeFunction(kTestFabricIndex1, kClientNodeId11));
     }
 #endif // CHIP_CONFIG_PERSIST_SUBSCRIPTIONS
 };
@@ -709,7 +709,7 @@ static const nlTest sTests[] = {
     NL_TEST_DEF("TestICDMRegisterUnregisterEvents", TestICDManager::TestICDMRegisterUnregisterEvents),
     NL_TEST_DEF("TestICDCounter", TestICDManager::TestICDCounter),
     NL_TEST_DEF("TestICDStayActive", TestICDManager::TestICDMStayActive),
-    NL_TEST_DEF("TestCheckInWouldBeSentAtActiveModeVerifier", TestICDManager::TestCheckInWouldBeSentAtActiveModeVerifier),
+    NL_TEST_DEF("TestShouldCheckInMsgsBeSentAtActiveModeFunction", TestICDManager::TestShouldCheckInMsgsBeSentAtActiveModeFunction),
     NL_TEST_SENTINEL(),
 };
 

Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ void ICDManager::SendCheckInMsgs()`
`178`	`178`	`continue;`
`179`	`179`	`}`
`180`	`180`
`181`		`- if (!CheckInWouldBeSentAtActiveModeVerifier(entry.fabricIndex, entry.monitoredSubject))`
	`181`	`+ if (!ShouldCheckInMsgsBeSentAtActiveModeFunction(entry.fabricIndex, entry.monitoredSubject))`
`182`	`182`	`{`
`183`	`183`	`continue;`
`184`	`184`	`}`
`@@ -208,9 +208,9 @@ void ICDManager::SendCheckInMsgs()`
`208`	`208`	`#endif // CONFIG_BUILD_FOR_HOST_UNIT_TEST`
`209`	`209`	`}`
`210`	`210`
`211`		`-bool ICDManager::CheckInMessagesWouldBeSent(std::function<RegistrationVerificationFunction> RegistrationVerifier)`
	`211`	`+bool ICDManager::CheckInMessagesWouldBeSent(const std::function<ShouldCheckInMsgsBeSentFunction> shouldCheckInMsgsBeSentFunction &)`
`212`	`212`	`{`
`213`		`- VerifyOrReturnValue(RegistrationVerifier, false);`
	`213`	`+ VerifyOrReturnValue(shouldCheckInMsgsBeSentFunction, false);`
`214`	`214`
`215`	`215`	`for (const auto & fabricInfo : *mFabricTable)`
`216`	`216`	`{`
`@@ -240,7 +240,7 @@ bool ICDManager::CheckInMessagesWouldBeSent(std::function<RegistrationVerificati`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`// At least one registration would require a Check-In message`
`243`		`- VerifyOrReturnValue(!RegistrationVerifier(entry.fabricIndex, entry.monitoredSubject), true);`
	`243`	`+ VerifyOrReturnValue(!shouldCheckInMsgsBeSentFunction(entry.fabricIndex, entry.monitoredSubject), true);`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`
`@@ -249,7 +249,7 @@ bool ICDManager::CheckInMessagesWouldBeSent(std::function<RegistrationVerificati`
`249`	`249`	`}`
`250`	`250`
`251`	`251`	`/**`
`252`		`- * CheckInWouldBeSentAtActiveModeVerifier is used to determine if a Check-In message is required for a given registration.`
	`252`	`+ * ShouldCheckInMsgsBeSentAtActiveModeFunction is used to determine if a Check-In message is required for a given registration.`
`253`	`253`	`* Due to how the ICD Check-In use-case interacts with the persistent subscription and subscription timeout resumption,`
`254`	`254`	`* having a single implementation of the function renders the implematention very difficult to understand and maintain.`
`255`	`255`	`* Because of this, each valid feature combination has its own implementation of the verifier.`
`@@ -266,7 +266,7 @@ bool ICDManager::CheckInMessagesWouldBeSent(std::function<RegistrationVerificati`
`266`	`266`	`* @return true Returns true if the fabricIndex and subjectId combination does not have an active or a persisted subscription.`
`267`	`267`	`* @return false Returns false if the fabricIndex and subjectId combination has an active or persisted subscription.`
`268`	`268`	`*/`
`269`		`-bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex, NodeId subjectID)`
	`269`	`+bool ICDManager::ShouldCheckInMsgsBeSentAtActiveModeFunction(FabricIndex aFabricIndex, NodeId subjectID)`
`270`	`270`	`{`
`271`	`271`	`return !(mSubInfoProvider->SubjectHasActiveSubscription(aFabricIndex, subjectID) \|\|`
`272`	`272`	`mSubInfoProvider->SubjectHasPersistedSubscription(aFabricIndex, subjectID));`
`@@ -291,7 +291,7 @@ bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex`
`291`	`291`	`* If the boot up susbscription has not been completed,`
`292`	`292`	`* if the fabricIndex and subjectId combination has a persisted subscription.`
`293`	`293`	`*/`
`294`		`-bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex, NodeId subjectID)`
	`294`	`+bool ICDManager::ShouldCheckInMsgsBeSentAtActiveModeFunction(FabricIndex aFabricIndex, NodeId subjectID)`
`295`	`295`	`{`
`296`	`296`	`bool wouldSendCheckIn = !(mSubInfoProvider->SubjectHasActiveSubscription(aFabricIndex, subjectID));`
`297`	`297`
`@@ -314,13 +314,13 @@ bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex`
`314`	`314`	`* @return true Returns true if the fabricIndex and subjectId combination does not have an active subscription.`
`315`	`315`	`* @return false Returns false if the fabricIndex and subjectId combination has an active subscription.`
`316`	`316`	`*/`
`317`		`-bool ICDManager::CheckInWouldBeSentAtActiveModeVerifier(FabricIndex aFabricIndex, NodeId subjectID)`
	`317`	`+bool ICDManager::ShouldCheckInMsgsBeSentAtActiveModeFunction(FabricIndex aFabricIndex, NodeId subjectID)`
`318`	`318`	`{`
`319`	`319`	`return !(mSubInfoProvider->SubjectHasActiveSubscription(aFabricIndex, subjectID));`
`320`	`320`	`}`
`321`	`321`	`#endif // CHIP_CONFIG_PERSIST_SUBSCRIPTIONS`
`322`	`322`
`323`		`-void ICDManager::TriggerCheckInMessages(const std::function<RegistrationVerificationFunction> & verifier)`
	`323`	`+void ICDManager::TriggerCheckInMessages(const std::function<ShouldCheckInMsgsBeSentFunction> & verifier)`
`324`	`324`	`{`
`325`	`325`	`VerifyOrReturn(SupportsFeature(Feature::kCheckInProtocolSupport));`
`326`	`326`
`@@ -390,8 +390,8 @@ void ICDManager::UpdateOperationState(OperationalState state)`
`390`	`390`	`mOperationalState = OperationalState::IdleMode;`
`391`	`391`
`392`	`392`	`#if CHIP_CONFIG_ENABLE_ICD_CIP`
`393`		`- std::function<RegistrationVerificationFunction> verifier =`
`394`		`- std::bind(&ICDManager::CheckInWouldBeSentAtActiveModeVerifier, this, std::placeholders::_1, std::placeholders::_2);`
	`393`	`+ std::function<ShouldCheckInMsgsBeSentFunction> verifier =`
	`394`	`+ std::bind(&ICDManager::ShouldCheckInMsgsBeSentAtActiveModeFunction, this, std::placeholders::_1, std::placeholders::_2);`
`395`	`395`	`#endif // CHIP_CONFIG_ENABLE_ICD_CIP`
`396`	`396`
`397`	`397`	`// When the active mode interval is 0, we stay in idleMode until a notification brings the icd into active mode`
Original file line number	Diff line number	Diff line change
`@@ -449,7 +449,7 @@ void Server::OnPlatformEvent(const DeviceLayer::ChipDeviceEvent & event)`
`449`	`449`	`// We trigger Check-In messages before resuming subscriptions to avoid doing both.`
`450`	`450`	`if (!mFailSafeContext.IsFailSafeArmed())`
`451`	`451`	`{`
`452`		`- std::function<chip::app::ICDManager::RegistrationVerificationFunction> verifier =`
	`452`	`+ std::function<chip::app::ICDManager::ShouldCheckInMsgsBeSentFunction> verifier =`
`453`	`453`	`std::bind(&Server::CheckInWouldBeSentAtBootVerifier, this, std::placeholders::_1, std::placeholders::_2);`
`454`	`454`	`mICDManager.TriggerCheckInMessages(verifier);`
`455`	`455`	`}`
`@@ -525,7 +525,7 @@ void Server::RejoinExistingMulticastGroups()`
`525`	`525`	`}`
`526`	`526`
`527`	`527`	`#if CHIP_CONFIG_ENABLE_ICD_CIP`
`528`		`-bool Server::CheckInWouldBeSentAtBootVerifier(FabricIndex aFabricIndex, NodeId subjectID)`
	`528`	`+bool Server::ShouldCheckInMsgsBeSentAtBootFunction(FabricIndex aFabricIndex, NodeId subjectID)`
`529`	`529`	`{`
`530`	`530`	`#if CHIP_CONFIG_PERSIST_SUBSCRIPTIONS`
`531`	`531`	`// If at least one registration has a persisted entry, do not send Check-In message.`