nodiscard ChipError Batch project-chip#28: platform-specific src: tizen, zephyr, system (project-chip#42091)

* Batch project-chip#28 nodiscard errors: platform-specific src: tizen, zephyr, system

* Fix CI failure

* Apply review suggestion

Author: gmarcosb

src/platform/Tizen/BLEManagerImpl.cpp

@@ -167,7 +167,7 @@ void BLEManagerImpl::HandleAdvertisingTimeout(chip::System::Layer *, void * appS
     VerifyOrReturn(self->mFlags.Has(Flags::kFastAdvertisingEnabled));
 
     ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start slow advertisement");
-    self->_SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising);
+    TEMPORARY_RETURN_IGNORED self->_SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising);
 }
 
 BLEManagerImpl::AdvertisingIntervals BLEManagerImpl::GetAdvertisingIntervals() const
@@ -300,23 +300,23 @@ void BLEManagerImpl::AdvertisingStateChangedCb(int result, bt_advertiser_h adver
     {
         mFlags.Set(Flags::kAdvertising);
         NotifyBLEPeripheralAdvStartComplete(CHIP_NO_ERROR);
-        DeviceLayer::SystemLayer().ScheduleLambda([this] {
+        TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().ScheduleLambda([this] {
             // Start a timer to make sure that the fast advertising is stopped after specified timeout.
-            DeviceLayer::SystemLayer().StartTimer(kFastAdvertiseTimeout, HandleAdvertisingTimeout, this);
+            TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().StartTimer(kFastAdvertiseTimeout, HandleAdvertisingTimeout, this);
         });
     }
     else
     {
         mFlags.Clear(Flags::kAdvertising);
         NotifyBLEPeripheralAdvStopComplete(CHIP_NO_ERROR);
-        DeviceLayer::SystemLayer().ScheduleLambda(
+        TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().ScheduleLambda(
             [this] { DeviceLayer::SystemLayer().CancelTimer(HandleAdvertisingTimeout, this); });
     }
 
     if (mFlags.Has(Flags::kAdvertisingRefreshNeeded))
     {
         mFlags.Clear(Flags::kAdvertisingRefreshNeeded);
-        DeviceLayer::SystemLayer().ScheduleLambda([this] { DriveBLEState(); });
+        TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().ScheduleLambda([this] { DriveBLEState(); });
     }
 
     mAdvReqInProgress = false;
@@ -480,14 +480,14 @@ void BLEManagerImpl::OnDeviceScanned(const bt_adapter_le_device_scan_result_info
     // StopScan should also be performed in the ChipStack thread.
     // At the same time, the scan timer also needs to be canceled in the ChipStack thread.
     DeviceLayer::SystemLayer().CancelTimer(HandleScanTimeout, this);
-    mDeviceScanner.StopScan();
+    TEMPORARY_RETURN_IGNORED mDeviceScanner.StopScan();
     // Stop scanning and then start connecting timer
-    DeviceLayer::SystemLayer().StartTimer(kConnectTimeout, HandleConnectionTimeout, this);
+    TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().StartTimer(kConnectTimeout, HandleConnectionTimeout, this);
     chip::DeviceLayer::PlatformMgr().UnlockChipStack();
 
     /* Initiate Connect */
     auto params = std::make_pair(this, scanInfo.remote_address);
-    PlatformMgrImpl().GLibMatterContextInvokeSync(
+    TEMPORARY_RETURN_IGNORED PlatformMgrImpl().GLibMatterContextInvokeSync(
         +[](decltype(params) * aParams) { return aParams->first->ConnectChipThing(aParams->second); }, &params);
 }
 
@@ -843,7 +843,7 @@ void BLEManagerImpl::RemoveConnection(const char * remoteAddr)
     // immediately, because the BLE layer might still use it. Instead, we will also
     // schedule the deletion of the connection object, so it will happen after the
     // BLE layer has processed the disconnection event.
-    DeviceLayer::SystemLayer().ScheduleLambda([conn] {
+    TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().ScheduleLambda([conn] {
         ChipLogDetail(DeviceLayer, "Freeing BLE connection");
         chip::Platform::Delete(conn);
     });
@@ -1271,7 +1271,8 @@ void BLEManagerImpl::NewConnection(BleLayer * bleLayer, void * appState, const S
     }
 
     // Scan initiation performed async, to ensure that the BLE subsystem is initialized.
-    DeviceLayer::SystemLayer().ScheduleLambda([this] { InitiateScan(BleScanState::kScanForDiscriminator); });
+    TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().ScheduleLambda(
+        [this] { InitiateScan(BleScanState::kScanForDiscriminator); });
 }
 
 void BLEManagerImpl::InitiateScan(BleScanState scanType)
@@ -1288,11 +1289,11 @@ void BLEManagerImpl::InitiateScan(BleScanState scanType)
     /* Send StartScan Request to Scanner Class */
     strcpy(data.service_uuid, Ble::CHIP_BLE_SERVICE_SHORT_UUID_STR);
     err = mDeviceScanner.StartScan(ScanFilterType::kServiceData, data);
-    VerifyOrExit(err == CHIP_NO_ERROR, ChipLogError(Ble, "Failed to start BLE scan: %" CHIP_ERROR_FORMAT, err.Format()));
+    SuccessOrExitAction(err, ChipLogFailure(err, Ble, "Failed to start BLE scan"));
 
     err = DeviceLayer::SystemLayer().StartTimer(kNewConnectionScanTimeout, HandleScanTimeout, this);
-    VerifyOrExit(err == CHIP_NO_ERROR, mDeviceScanner.StopScan();
-                 ChipLogError(Ble, "Failed to start BLE scan timeout: %" CHIP_ERROR_FORMAT, err.Format()));
+    SuccessOrExitAction(err, TEMPORARY_RETURN_IGNORED mDeviceScanner.StopScan();
+                        ChipLogFailure(err, Ble, "Failed to start BLE scan timeout"));
 
     mBLEScanConfig.mBleScanState = scanType;
     return;
@@ -1306,7 +1307,7 @@ void BLEManagerImpl::HandleScanTimeout(chip::System::Layer *, void * appState)
 {
     auto * manager = static_cast<BLEManagerImpl *>(appState);
     manager->OnScanError(CHIP_ERROR_TIMEOUT);
-    manager->mDeviceScanner.StopScan();
+    TEMPORARY_RETURN_IGNORED manager->mDeviceScanner.StopScan();
 }
 
 CHIP_ERROR BLEManagerImpl::CancelConnection()
@@ -1315,7 +1316,7 @@ CHIP_ERROR BLEManagerImpl::CancelConnection()
     if (mBLEScanConfig.mBleScanState != BleScanState::kNotScanning)
     {
         DeviceLayer::SystemLayer().CancelTimer(HandleScanTimeout, this);
-        mDeviceScanner.StopScan();
+        TEMPORARY_RETURN_IGNORED mDeviceScanner.StopScan();
     }
     return CHIP_NO_ERROR;
 }

src/platform/Tizen/ChipDeviceScanner.cpp

@@ -156,7 +156,7 @@ CHIP_ERROR ChipDeviceScanner::StartScan(ScanFilterType filterType, const ScanFil
 
 exit:
     ChipLogError(DeviceLayer, "Start CHIP Scan could not succeed fully! Stop Scan...");
-    StopScan();
+    TEMPORARY_RETURN_IGNORED StopScan();
     UnRegisterScanFilter();
     return err;
 }

src/platform/Tizen/ChipDeviceScanner.h

@@ -80,7 +80,7 @@ class ChipDeviceScanner
 {
 public:
     ChipDeviceScanner(ChipDeviceScannerDelegate * delegate) : mDelegate(delegate){};
-    ~ChipDeviceScanner() { StopScan(); }
+    ~ChipDeviceScanner() { TEMPORARY_RETURN_IGNORED StopScan(); }
 
     /// Initiate a scan for devices, with the given scan filter data
     CHIP_ERROR StartScan(ScanFilterType filterType, const ScanFilterData & filterData);

src/platform/Tizen/ConnectivityManagerImpl.cpp

@@ -167,7 +167,7 @@ bool ConnectivityManagerImpl::_IsWiFiStationEnabled()
 {
     bool isWiFiStationEnabled = false;
 
-    Internal::WiFiMgr().IsActivated(&isWiFiStationEnabled);
+    TEMPORARY_RETURN_IGNORED Internal::WiFiMgr().IsActivated(&isWiFiStationEnabled);
 
     return isWiFiStationEnabled;
 }
@@ -204,7 +204,7 @@ bool ConnectivityManagerImpl::_IsWiFiStationProvisioned()
 
 void ConnectivityManagerImpl::_ClearWiFiStationProvision()
 {
-    Internal::WiFiMgr().RemoveAllConfigs();
+    TEMPORARY_RETURN_IGNORED Internal::WiFiMgr().RemoveAllConfigs();
 }
 
 ConnectivityManager::WiFiAPMode ConnectivityManagerImpl::_GetWiFiAPMode()
@@ -232,18 +232,18 @@ void ConnectivityManagerImpl::_SetWiFiAPIdleTimeout(System::Clock::Timeout val)
 
 void ConnectivityManagerImpl::StartWiFiManagement()
 {
-    Internal::WiFiMgr().Activate();
+    TEMPORARY_RETURN_IGNORED Internal::WiFiMgr().Activate();
 }
 
 void ConnectivityManagerImpl::StopWiFiManagement()
 {
-    Internal::WiFiMgr().Deactivate();
+    TEMPORARY_RETURN_IGNORED Internal::WiFiMgr().Deactivate();
 }
 
 bool ConnectivityManagerImpl::IsWiFiManagementStarted()
 {
     bool isActivated = false;
-    Internal::WiFiMgr().IsActivated(&isActivated);
+    TEMPORARY_RETURN_IGNORED Internal::WiFiMgr().IsActivated(&isActivated);
     return isActivated;
 }
 

src/platform/Tizen/DnssdImpl.cpp

@@ -92,7 +92,7 @@ void OnRegister(dnssd_error_e result, dnssd_service_h service, void * data)
         ChipLogError(DeviceLayer, "DNSsd %s: Error: %s", __func__, get_error_message(result));
         rCtx->mCallback(rCtx->mCbContext, nullptr, nullptr, TizenToChipError(result));
         // After this point, the context might be no longer valid
-        rCtx->mInstance->RemoveContext(rCtx);
+        TEMPORARY_RETURN_IGNORED rCtx->mInstance->RemoveContext(rCtx);
         return;
     }
 
@@ -120,7 +120,7 @@ gboolean OnBrowseTimeout(void * userData)
     bCtx->mCallback(bCtx->mCbContext, bCtx->mServices.data(), bCtx->mServices.size(), true, CHIP_NO_ERROR);
 
     // After this point the context might be no longer valid
-    bCtx->mInstance->RemoveContext(bCtx);
+    TEMPORARY_RETURN_IGNORED bCtx->mInstance->RemoveContext(bCtx);
 
     // This is a one-shot timer
     return G_SOURCE_REMOVE;
@@ -213,7 +213,7 @@ void OnBrowse(dnssd_service_state_e state, dnssd_service_h service, void * data)
     {
         bCtx->mCallback(bCtx->mCbContext, nullptr, 0, true, TizenToChipError(ret));
         // After this point the context might be no longer valid
-        bCtx->mInstance->RemoveContext(bCtx);
+        TEMPORARY_RETURN_IGNORED bCtx->mInstance->RemoveContext(bCtx);
     }
 }
 
@@ -347,7 +347,7 @@ void OnResolve(dnssd_error_e result, dnssd_service_h service, void * userData)
         ChipLogProgress(DeviceLayer, "DNSsd Handle resolve task on schedule lambda");
 
         rCtx->Finalize(CHIP_NO_ERROR);
-        rCtx->mInstance->RemoveContext(rCtx);
+        TEMPORARY_RETURN_IGNORED rCtx->mInstance->RemoveContext(rCtx);
     });
     VerifyOrExit(err == CHIP_NO_ERROR,
                  ChipLogError(DeviceLayer, "Failed to schedule resolve task: %" CHIP_ERROR_FORMAT, err.Format()));
@@ -356,7 +356,7 @@ void OnResolve(dnssd_error_e result, dnssd_service_h service, void * userData)
 
 exit:
     rCtx->Finalize(ret != DNSSD_ERROR_NONE ? TizenToChipError(ret) : err);
-    rCtx->mInstance->RemoveContext(rCtx);
+    TEMPORARY_RETURN_IGNORED rCtx->mInstance->RemoveContext(rCtx);
 }
 
 CHIP_ERROR ResolveAsync(chip::Dnssd::ResolveContext * rCtx)
@@ -585,7 +585,7 @@ CHIP_ERROR DnssdTizen::RegisterService(const DnssdService & service, DnssdPublis
     if (err != CHIP_NO_ERROR)
     { // Notify caller about error
         callback(context, nullptr, nullptr, err);
-        RemoveContext(serviceCtx);
+        TEMPORARY_RETURN_IGNORED RemoveContext(serviceCtx);
     }
     return err;
 }
@@ -624,7 +624,7 @@ CHIP_ERROR DnssdTizen::Browse(const char * type, Dnssd::DnssdServiceProtocol pro
     if (err != CHIP_NO_ERROR)
     { // Notify caller about error
         callback(context, nullptr, 0, true, err);
-        RemoveContext(browseCtx);
+        TEMPORARY_RETURN_IGNORED RemoveContext(browseCtx);
     }
     return err;
 }
@@ -646,7 +646,7 @@ CHIP_ERROR DnssdTizen::Resolve(const DnssdService & browseResult, chip::Inet::In
 
 exit:
     if (err != CHIP_NO_ERROR)
-        RemoveContext(resolveCtx);
+        TEMPORARY_RETURN_IGNORED RemoveContext(resolveCtx);
     return err;
 }
 
@@ -741,7 +741,7 @@ CHIP_ERROR ChipDnssdRemoveServices()
 #if CHIP_DEVICE_CONFIG_ENABLE_THREAD_SRP_CLIENT
     if (DeviceLayer::ThreadStackMgr().IsThreadEnabled())
     {
-        DeviceLayer::ThreadStackMgr().InvalidateAllSrpServices();
+        TEMPORARY_RETURN_IGNORED DeviceLayer::ThreadStackMgr().InvalidateAllSrpServices();
         return DeviceLayer::ThreadStackMgr().RemoveInvalidSrpServices();
     }
 #endif // CHIP_DEVICE_CONFIG_ENABLE_THREAD_SRP_CLIENT

src/platform/Tizen/NetworkCommissioningThreadDriver.cpp

@@ -40,7 +40,7 @@ CHIP_ERROR TizenThreadDriver::Init(BaseDriver::NetworkStatusChangeCallback * net
     VerifyOrReturnError(ConnectivityMgr().IsThreadAttached(), CHIP_NO_ERROR);
     VerifyOrReturnError(ThreadStackMgr().GetThreadProvision(mStagingNetwork) == CHIP_NO_ERROR, CHIP_NO_ERROR);
 
-    mSavedNetwork.Init(mStagingNetwork.AsByteSpan());
+    TEMPORARY_RETURN_IGNORED mSavedNetwork.Init(mStagingNetwork.AsByteSpan());
 
     return CHIP_NO_ERROR;
 }
@@ -64,7 +64,7 @@ Status TizenThreadDriver::AddOrUpdateNetwork(ByteSpan operationalDataset, Mutabl
     Thread::OperationalDataset newDataset;
     outDebugText.reduce_size(0);
     outNetworkIndex = 0;
-    newDataset.Init(operationalDataset);
+    TEMPORARY_RETURN_IGNORED newDataset.Init(operationalDataset);
     VerifyOrReturnError(newDataset.IsCommissioned(), Status::kOutOfRange);
 
     VerifyOrReturnError(!mStagingNetwork.IsCommissioned() || memcmp(extpanid, newExtpanid, Thread::kSizeExtendedPanId) == 0,
@@ -179,7 +179,7 @@ ThreadCapabilities TizenThreadDriver::GetSupportedThreadFeatures()
 uint16_t TizenThreadDriver::GetThreadVersion()
 {
     uint16_t version = 0;
-    DeviceLayer::ThreadStackMgr().GetThreadVersion(version);
+    TEMPORARY_RETURN_IGNORED DeviceLayer::ThreadStackMgr().GetThreadVersion(version);
     return version;
 }
 

src/platform/Tizen/ThreadStackManagerImpl.cpp

@@ -305,8 +305,8 @@ CHIP_ERROR ThreadStackManagerImpl::_GetThreadProvision(Thread::OperationalDatase
                  ChipLogError(DeviceLayer, "FAIL: Thread get active dataset TLVs: %s", get_error_message(threadErr)));
 
     ChipLogProgress(DeviceLayer, "Thread get active dataset TLVs size [%u]", tlvsLen);
-    mDataset.Init(ByteSpan(tlvsData, tlvsLen));
-    dataset.Init(mDataset.AsByteSpan());
+    TEMPORARY_RETURN_IGNORED mDataset.Init(ByteSpan(tlvsData, tlvsLen));
+    TEMPORARY_RETURN_IGNORED dataset.Init(mDataset.AsByteSpan());
 
     return CHIP_NO_ERROR;
 
@@ -354,7 +354,7 @@ CHIP_ERROR ThreadStackManagerImpl::_SetThreadEnabled(bool val)
     if (val && !isEnabled)
     {
         threadErr = thread_network_attach(mThreadInstance);
-        DeviceLayer::SystemLayer().ScheduleLambda([&, threadErr]() {
+        TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().ScheduleLambda([&, threadErr]() {
             if (this->mpConnectCallback != nullptr && threadErr != THREAD_ERROR_NONE)
             {
                 this->mpConnectCallback->OnResult(NetworkCommissioning::Status::kUnknownError, CharSpan(), 0);
@@ -365,7 +365,7 @@ CHIP_ERROR ThreadStackManagerImpl::_SetThreadEnabled(bool val)
                      ChipLogError(DeviceLayer, "FAIL: Attach Thread network: %s", get_error_message(threadErr)));
 
         threadErr = thread_start(mThreadInstance);
-        DeviceLayer::SystemLayer().ScheduleLambda([&, threadErr]() {
+        TEMPORARY_RETURN_IGNORED DeviceLayer::SystemLayer().ScheduleLambda([&, threadErr]() {
             if (this->mpConnectCallback != nullptr)
             {
                 this->mpConnectCallback->OnResult(threadErr == THREAD_ERROR_NONE ? NetworkCommissioning::Status::kSuccess

src/platform/Tizen/WiFiManager.cpp

@@ -340,7 +340,7 @@ void WiFiManager::_ScanToConnectFinishedCb(wifi_manager_error_e wifiErr, void *
         foundAp = sInstance._WiFiGetFoundAP();
         if (foundAp != nullptr)
         {
-            PlatformMgrImpl().GLibMatterContextInvokeSync(_WiFiConnect, foundAp);
+            TEMPORARY_RETURN_IGNORED PlatformMgrImpl().GLibMatterContextInvokeSync(_WiFiConnect, foundAp);
         }
     }
     else
@@ -818,7 +818,7 @@ void WiFiManager::Init()
     sInstance.mModuleState     = WIFI_MANAGER_MODULE_STATE_DETACHED;
     sInstance.mConnectionState = WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED;
 
-    PlatformMgrImpl().GLibMatterContextInvokeSync(_WiFiInitialize, static_cast<void *>(nullptr));
+    TEMPORARY_RETURN_IGNORED PlatformMgrImpl().GLibMatterContextInvokeSync(_WiFiInitialize, static_cast<void *>(nullptr));
 }
 
 void WiFiManager::Deinit()

src/platform/Zephyr/BLEAdvertisingArbiter.cpp

@@ -142,7 +142,7 @@ void CancelRequest(Request & request)
     // If cancelled request was top-priority, restart the advertising.
     if (isTopPriority)
     {
-        RestartAdvertising();
+        TEMPORARY_RETURN_IGNORED RestartAdvertising();
     }
 }