Remove some conditional compilation

examples/platform/esp32/common/CHIPDeviceManager.cpp

@@ -79,10 +79,8 @@ CHIP_ERROR CHIPDeviceManager::Init(CHIPDeviceManagerCallbacks * cb)
     // this function will happen on the CHIP event loop thread, not the app_main thread.
     PlatformMgr().AddEventHandler(CHIPDeviceManager::CommonDeviceEventHandler, reinterpret_cast<intptr_t>(cb));
 
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     // Start a task to run the CHIP Device background event loop.
     ReturnErrorOnFailure(PlatformMgr().StartBackgroundEventLoopTask());
-#endif
 
     // Start a task to run the CHIP Device event loop.
     return PlatformMgr().StartEventLoopTask();

src/include/platform/PlatformManager.h

@@ -202,17 +202,11 @@ class PlatformManager
      */
     CHIP_ERROR StopEventLoopTask();
 
-    // These functions should be gated by CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
-    // but the PlatformManagerImpl header (included below) makes that tricky
-    // so always declare them here even if they are not defined by the platform implementation
-    // (by using #if 1).
-#if 1 || defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     CHIP_ERROR ScheduleBackgroundWork(AsyncWorkFunct workFunct, intptr_t arg = 0);
     CHIP_ERROR PostBackgroundEvent(const ChipDeviceEvent * event);
     void RunBackgroundEventLoop();
     CHIP_ERROR StartBackgroundEventLoopTask();
     CHIP_ERROR StopBackgroundEventLoopTask();
-#endif
 
 private:
     bool mInitialized                   = false;
@@ -445,8 +439,6 @@ inline CHIP_ERROR PlatformManager::StopEventLoopTask()
     return static_cast<ImplClass *>(this)->_StopEventLoopTask();
 }
 
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
-
 inline CHIP_ERROR PlatformManager::ScheduleBackgroundWork(AsyncWorkFunct workFunct, intptr_t arg)
 {
     return static_cast<ImplClass *>(this)->_ScheduleBackgroundWork(workFunct, arg);
@@ -472,8 +464,6 @@ inline CHIP_ERROR PlatformManager::StopBackgroundEventLoopTask()
     return static_cast<ImplClass *>(this)->_StopBackgroundEventLoopTask();
 }
 
-#endif
-
 inline void PlatformManager::DispatchEvent(const ChipDeviceEvent * event)
 {
     static_cast<ImplClass *>(this)->_DispatchEvent(event);

src/include/platform/internal/GenericPlatformManagerImpl.h

@@ -58,9 +58,7 @@ class GenericPlatformManagerImpl
     void _HandleServerStarted();
     void _HandleServerShuttingDown();
     CHIP_ERROR _ScheduleWork(AsyncWorkFunct workFunct, intptr_t arg);
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     CHIP_ERROR _ScheduleBackgroundWork(AsyncWorkFunct workFunct, intptr_t arg);
-#endif
     void _DispatchEvent(const ChipDeviceEvent * event);
 
     // ===== Support methods that can be overridden by the implementation subclass.

src/include/platform/internal/GenericPlatformManagerImpl.ipp

@@ -231,22 +231,25 @@ CHIP_ERROR GenericPlatformManagerImpl<ImplClass>::_ScheduleWork(AsyncWorkFunct w
     return err;
 }
 
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
 template <class ImplClass>
 CHIP_ERROR GenericPlatformManagerImpl<ImplClass>::_ScheduleBackgroundWork(AsyncWorkFunct workFunct, intptr_t arg)
 {
+#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     ChipDeviceEvent event{
         .Type = DeviceEventType::kCallWorkFunct,
         .CallWorkFunct {.WorkFunct = workFunct, .Arg = arg}
     };
-    auto err = Impl()->PostEvent(&event);
+    auto err = Impl()->PostBackgroundEvent(&event);
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(DeviceLayer, "Failed to schedule background work: %" CHIP_ERROR_FORMAT, err.Format());
     }
     return err;
-}
+#else
+    // Use foreground event loop for background events
+    return _ScheduleWork(workFunct, arg);
 #endif
+}
 
 template <class ImplClass>
 void GenericPlatformManagerImpl<ImplClass>::_DispatchEvent(const ChipDeviceEvent * event)

src/include/platform/internal/GenericPlatformManagerImpl_FreeRTOS.h

@@ -91,12 +91,10 @@ class GenericPlatformManagerImpl_FreeRTOS : public GenericPlatformManagerImpl<Im
     CHIP_ERROR _StartEventLoopTask(void);
     CHIP_ERROR _StopEventLoopTask();
 
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     CHIP_ERROR _PostBackgroundEvent(const ChipDeviceEvent * event);
     void _RunBackgroundEventLoop(void);
     CHIP_ERROR _StartBackgroundEventLoopTask(void);
     CHIP_ERROR _StopBackgroundEventLoopTask();
-#endif
 
     // ===== Methods available to the implementation subclass.
 

src/include/platform/internal/GenericPlatformManagerImpl_FreeRTOS.ipp

@@ -294,11 +294,11 @@ void GenericPlatformManagerImpl_FreeRTOS<ImplClass>::EventLoopTaskMain(void * ar
     // Or somehow get our caller to do it once this thread is joined?
 }
 
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
 
 template <class ImplClass>
 CHIP_ERROR GenericPlatformManagerImpl_FreeRTOS<ImplClass>::_PostBackgroundEvent(const ChipDeviceEvent * event)
 {
+#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     if (mBackgroundEventQueue == NULL)
     {
         return CHIP_ERROR_INTERNAL;
@@ -314,11 +314,16 @@ CHIP_ERROR GenericPlatformManagerImpl_FreeRTOS<ImplClass>::_PostBackgroundEvent(
         return CHIP_ERROR(chip::ChipError::Range::kOS, status);
     }
     return CHIP_NO_ERROR;
+#else
+    // Use foreground event loop for background events
+    return _PostEvent(event);
+#endif
 }
 
 template <class ImplClass>
 void GenericPlatformManagerImpl_FreeRTOS<ImplClass>::_RunBackgroundEventLoop(void)
 {
+#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     bool oldShouldRunBackgroundEventLoop = false;
     if (!mShouldRunBackgroundEventLoop.compare_exchange_strong(oldShouldRunBackgroundEventLoop /* expected */, true /* desired */))
     {
@@ -336,11 +341,15 @@ void GenericPlatformManagerImpl_FreeRTOS<ImplClass>::_RunBackgroundEventLoop(voi
             eventReceived = xQueueReceive(mBackgroundEventQueue, &event, portMAX_DELAY) == pdTRUE;
         }
     }
+#else
+    // Use foreground event loop for background events
+#endif
 }
 
 template <class ImplClass>
 CHIP_ERROR GenericPlatformManagerImpl_FreeRTOS<ImplClass>::_StartBackgroundEventLoopTask(void)
 {
+#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
 #if defined(CHIP_CONFIG_FREERTOS_USE_STATIC_TASK) && CHIP_CONFIG_FREERTOS_USE_STATIC_TASK
     mBackgroundEventLoopTask = xTaskCreateStatic(BackgroundEventLoopTaskMain, CHIP_DEVICE_CONFIG_BG_TASK_NAME, ArraySize(mBackgroundEventLoopStack), this,
                                                  CHIP_DEVICE_CONFIG_BG_TASK_PRIORITY, mBackgroundEventLoopStack, &mBackgroundEventLoopTaskStruct);
@@ -349,27 +358,36 @@ CHIP_ERROR GenericPlatformManagerImpl_FreeRTOS<ImplClass>::_StartBackgroundEvent
                 this, CHIP_DEVICE_CONFIG_BG_TASK_PRIORITY, &mBackgroundEventLoopTask);
 #endif
     return (mBackgroundEventLoopTask != NULL) ? CHIP_NO_ERROR : CHIP_ERROR_NO_MEMORY;
+#else
+    // Use foreground event loop for background events
+    return CHIP_NO_ERROR;
+#endif
 }
 
 template <class ImplClass>
 CHIP_ERROR GenericPlatformManagerImpl_FreeRTOS<ImplClass>::_StopBackgroundEventLoopTask(void)
 {
+#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     bool oldShouldRunBackgroundEventLoop = true;
     if (mShouldRunBackgroundEventLoop.compare_exchange_strong(oldShouldRunBackgroundEventLoop /* expected */, false /* desired */))
     {
         ChipDeviceEvent noop {.Type = DeviceEventType::kNoOp };
         xQueueSendToBack(mBackgroundEventQueue, &noop, 0);
     }
     return CHIP_NO_ERROR;
+#else
+    // Use foreground event loop for background events
+    return CHIP_NO_ERROR;
+#endif
 }
 
+#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
 template <class ImplClass>
 void GenericPlatformManagerImpl_FreeRTOS<ImplClass>::BackgroundEventLoopTaskMain(void * arg)
 {
     ChipLogDetail(DeviceLayer, "CHIP background task running");
     static_cast<GenericPlatformManagerImpl_FreeRTOS<ImplClass> *>(arg)->Impl()->RunBackgroundEventLoop();
 }
-
 #endif
 
 template <class ImplClass>

src/protocols/secure_channel/CASESession.cpp

@@ -1317,16 +1317,10 @@ CHIP_ERROR CASESession::HandleSigma3a(System::PacketBufferHandle && msg)
 
     ChipLogProgress(SecureChannel, "Received Sigma3 msg");
 
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     auto * workPtr = new Sigma3Work();
     VerifyOrExit(workPtr != nullptr, err = CHIP_ERROR_NO_MEMORY);
     {
         auto & work = *workPtr;
-#else
-    Sigma3Work* workPtr = nullptr;
-    {
-        Sigma3Work work;
-#endif
 
         // Used to call back into the session after background event processing.
         // It happens that there's only one pairing session (in CASEServer)
@@ -1445,17 +1439,12 @@ CHIP_ERROR CASESession::HandleSigma3a(System::PacketBufferHandle && msg)
             }
         }
 
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
         SuccessOrExit(err = DeviceLayer::PlatformMgr().ScheduleBackgroundWork(
             [](intptr_t arg) { HandleSigma3b(*reinterpret_cast<Sigma3Work*>(arg)); },
             reinterpret_cast<intptr_t>(&work)));
         workPtr = nullptr; // scheduling succeeded, so don't delete
         mExchangeCtxt->WillSendMessage();
         mState = State::kBackgroundPending;
-#else
-        HandleSigma3b(work);
-        SuccessOrExit(HandleSigma3c(work));
-#endif
     }
 
 exit:
@@ -1503,7 +1492,6 @@ void CASESession::HandleSigma3b(Sigma3Work & work)
 exit:
     work.status = err;
 
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     auto err2 = DeviceLayer::PlatformMgr().ScheduleWork(
         [](intptr_t arg) {
             auto & work2 = *reinterpret_cast<Sigma3Work*>(arg);
@@ -1515,23 +1503,18 @@ void CASESession::HandleSigma3b(Sigma3Work & work)
     {
         delete &work; // scheduling failed, so delete
     }
-#endif
 }
 
 CHIP_ERROR CASESession::HandleSigma3c(Sigma3Work & work)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
     bool ignoreFailure = true;
 
-    ChipLogError(SecureChannel, "########## IN PART C");
-
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     // Special case: if for whatever reason not in expected state or sequence,
     // don't do anything, including sending a status report or aborting the
     // pending establish.
     VerifyOrExit(mState == State::kBackgroundPending, err = CHIP_ERROR_INCORRECT_STATE);
     VerifyOrExit(mSequence == work.sequence, err = CHIP_ERROR_INCORRECT_STATE);
-#endif
 
     ignoreFailure = false;
 
@@ -1564,19 +1547,15 @@ CHIP_ERROR CASESession::HandleSigma3c(Sigma3Work & work)
     Finish();
 
 exit:
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
     delete &work;
-#endif
 
     if (err != CHIP_NO_ERROR && !ignoreFailure)
     {
         SendStatusReport(mExchangeCtxt, kProtocolCodeInvalidParam);
-#if defined(CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING) && CHIP_DEVICE_CONFIG_ENABLE_BG_EVENT_PROCESSING
         // Abort the pending establish, which is normally done by the caller,
         // but in the background processing case must be done here.
         DiscardExchange();
         AbortPendingEstablish(err);
-#endif
     }
 
     return err;
@@ -1678,24 +1657,6 @@ CHIP_ERROR CASESession::ValidateSigmaResumeMIC(const ByteSpan & resumeMIC, const
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR CASESession::ValidatePeerIdentity(const ByteSpan & peerNOC, const ByteSpan & peerICAC, NodeId & peerNodeId,
-                                             Crypto::P256PublicKey & peerPublicKey)
-{
-    ReturnErrorCodeIf(mFabricsTable == nullptr, CHIP_ERROR_INCORRECT_STATE);
-    const auto * fabricInfo = mFabricsTable->FindFabricWithIndex(mFabricIndex);
-    ReturnErrorCodeIf(fabricInfo == nullptr, CHIP_ERROR_INCORRECT_STATE);
-
-    ReturnErrorOnFailure(SetEffectiveTime());
-
-    CompressedFabricId unused;
-    FabricId peerFabricId;
-    ReturnErrorOnFailure(mFabricsTable->VerifyCredentials(mFabricIndex, peerNOC, peerICAC, mValidContext, unused, peerFabricId,
-                                                          peerNodeId, peerPublicKey));
-    VerifyOrReturnError(fabricInfo->GetFabricId() == peerFabricId, CHIP_ERROR_INVALID_CASE_PARAMETER);
-
-    return CHIP_NO_ERROR;
-}
-
 CHIP_ERROR CASESession::ConstructTBSData(const ByteSpan & senderNOC, const ByteSpan & senderICAC, const ByteSpan & senderPubKey,
                                          const ByteSpan & receiverPubKey, uint8_t * tbsData, size_t & tbsDataLen)
 {

src/protocols/secure_channel/CASESession.h

@@ -233,8 +233,6 @@ class DLL_EXPORT CASESession : public Messaging::UnsolicitedMessageHandler,
 
     CHIP_ERROR ConstructSaltSigma2(const ByteSpan & rand, const Crypto::P256PublicKey & pubkey, const ByteSpan & ipk,
                                    MutableByteSpan & salt);
-    CHIP_ERROR ValidatePeerIdentity(const ByteSpan & peerNOC, const ByteSpan & peerICAC, NodeId & peerNodeId,
-                                    Crypto::P256PublicKey & peerPublicKey);
     CHIP_ERROR ConstructTBSData(const ByteSpan & senderNOC, const ByteSpan & senderICAC, const ByteSpan & senderPubKey,
                                 const ByteSpan & receiverPubKey, uint8_t * tbsData, size_t & tbsDataLen);
     CHIP_ERROR ConstructSaltSigma3(const ByteSpan & ipk, MutableByteSpan & salt);