nodiscard ChipError Batch project-chip#12: protocols (project-chip#41870)

gmarcosb · web-flow · commit c561ace16604 · 2025-11-12T20:58:01.000Z
* Batch project-chip#12 nodiscard errors: protocols * Review suggestions & fix CI * Address review suggestions * Fix clang tidy * Revert conversion from macro -> template as pw_unit_test does not support GoogleTest << and does not output template param
diff --git a/src/controller/ExamplePersistentStorage.cpp b/src/controller/ExamplePersistentStorage.cpp
@@ -308,19 +308,16 @@ CATValues PersistentStorage::GetCommissionerCATs()
     err           = SyncGetKeyValue(kCommissionerCATsKey, serializedCATs, size);
     if (err == CHIP_NO_ERROR && size == chip::CATValues::kSerializedLength)
     {
-        err = cats.Deserialize(serializedCATs);
-        if (err == CHIP_NO_ERROR)
-        {
-            return cats;
-        }
+        cats.Deserialize(serializedCATs);
+        return cats;
     }
     return chip::kUndefinedCATs;
 }
 
 CHIP_ERROR PersistentStorage::SetCommissionerCATs(const CATValues & cats)
 {
     chip::CATValues::Serialized serializedCATs;
-    ReturnErrorOnFailure(cats.Serialize(serializedCATs));
+    cats.Serialize(serializedCATs);
 
     return SyncSetKeyValue(kCommissionerCATsKey, serializedCATs, sizeof(serializedCATs));
 }
diff --git a/src/credentials/tests/TestChipCert.cpp b/src/credentials/tests/TestChipCert.cpp
@@ -344,13 +344,13 @@ TEST_F(TestChipCert, TestChipCert_ChipDN)
 
     CATValues noc_cats2;
     chip::CATValues::Serialized serializedCATs;
-    EXPECT_EQ(noc_cats.Serialize(serializedCATs), CHIP_NO_ERROR);
-    EXPECT_EQ(noc_cats2.Deserialize(serializedCATs), CHIP_NO_ERROR);
+    noc_cats.Serialize(serializedCATs);
+    noc_cats2.Deserialize(serializedCATs);
     EXPECT_EQ(memcmp(&noc_cats, &noc_cats2, chip::CATValues::kSerializedLength), 0);
 
     CATValues noc_cats3 = { { 0xABCD0001, 0xFFEEAA00, 0x0001F012 } };
-    EXPECT_EQ(noc_cats3.Serialize(serializedCATs), CHIP_NO_ERROR);
-    EXPECT_EQ(noc_cats2.Deserialize(serializedCATs), CHIP_NO_ERROR);
+    noc_cats3.Serialize(serializedCATs);
+    noc_cats2.Deserialize(serializedCATs);
     EXPECT_EQ(memcmp(&noc_cats3, &noc_cats2, chip::CATValues::kSerializedLength), 0);
 }
 
diff --git a/src/lib/core/CASEAuthTag.h b/src/lib/core/CASEAuthTag.h
@@ -221,24 +221,22 @@ struct CATValues
     static constexpr size_t kSerializedLength = kMaxSubjectCATAttributeCount * sizeof(CASEAuthTag);
     typedef uint8_t Serialized[kSerializedLength];
 
-    CHIP_ERROR Serialize(Serialized & outSerialized) const
+    void Serialize(Serialized & outSerialized) const
     {
         uint8_t * p = outSerialized;
         for (size_t i = 0; i < kMaxSubjectCATAttributeCount; i++)
         {
             Encoding::LittleEndian::Write32(p, values[i]);
         }
-        return CHIP_NO_ERROR;
     }
 
-    CHIP_ERROR Deserialize(const Serialized & inSerialized)
+    void Deserialize(const Serialized & inSerialized)
     {
         const uint8_t * p = inSerialized;
         for (size_t i = 0; i < kMaxSubjectCATAttributeCount; i++)
         {
             values[i] = Encoding::LittleEndian::Read32(p);
         }
-        return CHIP_NO_ERROR;
     }
 };
 
diff --git a/src/protocols/bdx/AsyncTransferFacilitator.cpp b/src/protocols/bdx/AsyncTransferFacilitator.cpp
@@ -149,7 +149,7 @@ CHIP_ERROR AsyncTransferFacilitator::OnMessageReceived(Messaging::ExchangeContex
 
         // This should notify the transfer object to abort transfer so it can send a status report across the exchange
         // when we call ProcessOutputEvents below.
-        mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(err));
+        TEMPORARY_RETURN_IGNORED mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(err));
     }
     else if (!payloadHeader.HasMessageType(MessageType::BlockAckEOF))
     {
@@ -199,7 +199,7 @@ void AsyncResponder::NotifyEventHandled(const TransferSession::OutputEventType e
     {
         // If there was an error handling the output event, this should notify the transfer object to abort transfer
         // so it can send a status report across the exchange when we call ProcessOutputEvents below.
-        mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(status));
+        TEMPORARY_RETURN_IGNORED mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(status));
     }
 
     ProcessOutputEvents();
diff --git a/src/protocols/bdx/BdxTransferDiagnosticLog.cpp b/src/protocols/bdx/BdxTransferDiagnosticLog.cpp
@@ -136,7 +136,7 @@ CHIP_ERROR BdxTransferDiagnosticLog::OnMessageToSend(TransferSession::OutputEven
 
     // If there's an error sending the message, close the exchange by calling Reset.
     auto err = mExchangeCtx->SendMessage(msgTypeData.ProtocolId, msgTypeData.MessageType, std::move(event.MsgData), sendFlags);
-    VerifyOrDo(CHIP_NO_ERROR == err, OnTransferSessionEnd(err));
+    VerifyOrDo(CHIP_NO_ERROR == err, TEMPORARY_RETURN_IGNORED OnTransferSessionEnd(err));
 
     return err;
 }
@@ -197,7 +197,7 @@ void BdxTransferDiagnosticLog::OnExchangeClosing(Messaging::ExchangeContext * ec
 {
     // The exchange can be closing while TransferFacilitator is still accessing us, so
     // the BdxTransferDiagnosticLog can not be released "right now".
-    mSystemLayer->ScheduleWork(
+    TEMPORARY_RETURN_IGNORED mSystemLayer->ScheduleWork(
         [](auto * systemLayer, auto * appState) -> void {
             auto * _this = static_cast<BdxTransferDiagnosticLog *>(appState);
             _this->mPoolDelegate->Release(_this);
diff --git a/src/protocols/bdx/TransferFacilitator.cpp b/src/protocols/bdx/TransferFacilitator.cpp
@@ -93,13 +93,13 @@ void TransferFacilitator::PollForOutput()
     HandleTransferSessionOutput(outEvent);
 
     VerifyOrReturn(mSystemLayer != nullptr, ChipLogError(BDX, "%s mSystemLayer is null", __FUNCTION__));
-    mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);
+    TEMPORARY_RETURN_IGNORED mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);
 }
 
 void TransferFacilitator::ScheduleImmediatePoll()
 {
     VerifyOrReturn(mSystemLayer != nullptr, ChipLogError(BDX, "%s mSystemLayer is null", __FUNCTION__));
-    mSystemLayer->StartTimer(System::Clock::Milliseconds32(kImmediatePollDelay), PollTimerHandler, this);
+    TEMPORARY_RETURN_IGNORED mSystemLayer->StartTimer(System::Clock::Milliseconds32(kImmediatePollDelay), PollTimerHandler, this);
 }
 
 CHIP_ERROR Responder::PrepareForTransfer(System::Layer * layer, TransferRole role, BitFlags<TransferControlFlags> xferControlOpts,
@@ -113,8 +113,7 @@ CHIP_ERROR Responder::PrepareForTransfer(System::Layer * layer, TransferRole rol
     ReturnErrorOnFailure(mTransfer.WaitForTransfer(role, xferControlOpts, maxBlockSize, timeout));
 
     ChipLogProgress(BDX, "Start polling for messages");
-    mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);
-    return CHIP_NO_ERROR;
+    return mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);
 }
 
 CHIP_ERROR Initiator::InitiateTransfer(System::Layer * layer, TransferRole role, const TransferSession::TransferInitData & initData,
@@ -127,8 +126,7 @@ CHIP_ERROR Initiator::InitiateTransfer(System::Layer * layer, TransferRole role,
 
     ReturnErrorOnFailure(mTransfer.StartTransfer(role, initData, timeout));
 
-    mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);
-    return CHIP_NO_ERROR;
+    return mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);
 }
 
 } // namespace bdx
diff --git a/src/protocols/echo/EchoServer.cpp b/src/protocols/echo/EchoServer.cpp
@@ -38,16 +38,14 @@ CHIP_ERROR EchoServer::Init(Messaging::ExchangeManager * exchangeMgr)
     OnEchoRequestReceived = nullptr;
 
     // Register to receive unsolicited Echo Request messages from the exchange manager.
-    mExchangeMgr->RegisterUnsolicitedMessageHandlerForType(MsgType::EchoRequest, this);
-
-    return CHIP_NO_ERROR;
+    return mExchangeMgr->RegisterUnsolicitedMessageHandlerForType(MsgType::EchoRequest, this);
 }
 
 void EchoServer::Shutdown()
 {
     if (mExchangeMgr != nullptr)
     {
-        mExchangeMgr->UnregisterUnsolicitedMessageHandlerForType(MsgType::EchoRequest);
+        TEMPORARY_RETURN_IGNORED mExchangeMgr->UnregisterUnsolicitedMessageHandlerForType(MsgType::EchoRequest);
         mExchangeMgr = nullptr;
     }
 }
diff --git a/src/protocols/secure_channel/CASEServer.cpp b/src/protocols/secure_channel/CASEServer.cpp
@@ -51,7 +51,8 @@ CHIP_ERROR CASEServer::ListenForSessionEstablishment(Messaging::ExchangeManager
     GetSession().SetGroupDataProvider(mGroupDataProvider);
 
     ChipLogProgress(Inet, "CASE Server enabling CASE session setups");
-    mExchangeManager->RegisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::MsgType::CASE_Sigma1, this);
+    TEMPORARY_RETURN_IGNORED mExchangeManager->RegisterUnsolicitedMessageHandlerForType(
+        Protocols::SecureChannel::MsgType::CASE_Sigma1, this);
 
     PrepareForSessionEstablishment();
 
diff --git a/src/protocols/secure_channel/CASEServer.h b/src/protocols/secure_channel/CASEServer.h
@@ -44,7 +44,8 @@ class CASEServer : public SessionEstablishmentDelegate,
     {
         if (mExchangeManager != nullptr)
         {
-            mExchangeManager->UnregisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::MsgType::CASE_Sigma1);
+            TEMPORARY_RETURN_IGNORED mExchangeManager->UnregisterUnsolicitedMessageHandlerForType(
+                Protocols::SecureChannel::MsgType::CASE_Sigma1);
             mExchangeManager = nullptr;
         }
 
diff --git a/src/protocols/secure_channel/CASESession.cpp b/src/protocols/secure_channel/CASESession.cpp
@@ -317,7 +317,7 @@ class CASESession::WorkHelper
         if (auto * session = helper->mSession.load())
         {
             // Execute callback in Matter thread; session should be OK with this
-            (session->*(helper->mAfterWorkCallback))(helper->mData, helper->mStatus);
+            TEMPORARY_RETURN_IGNORED(session->*(helper->mAfterWorkCallback))(helper->mData, helper->mStatus);
         }
     }
 
@@ -973,7 +973,7 @@ CHIP_ERROR CASESession::FindLocalNodeFromDestinationId(const ByteSpan & destinat
                 // Found a match, stop working, cache IPK, update local fabric context
                 found = true;
                 MutableByteSpan ipkSpan(mIPK);
-                CopySpanToMutableSpan(candidateIpkSpan, ipkSpan);
+                TEMPORARY_RETURN_IGNORED CopySpanToMutableSpan(candidateIpkSpan, ipkSpan);
                 mFabricIndex = fabricInfo.GetFabricIndex();
                 mLocalNodeId = nodeId;
                 break;
@@ -1658,7 +1658,8 @@ CHIP_ERROR CASESession::ParseSigma2TBEData(ContiguousBufferTLVReader & decrypted
     // tbsData2Signature's length should equal kMax_ECDSA_Signature_Length as per the Specification
     size_t signatureLen = decryptedDataTlvReader.GetLength();
     VerifyOrReturnError(outParsedSigma2TBE.tbsData2Signature.Capacity() == signatureLen, CHIP_ERROR_INVALID_TLV_ELEMENT);
-    outParsedSigma2TBE.tbsData2Signature.SetLength(signatureLen);
+    // Size checked above
+    RETURN_SAFELY_IGNORED outParsedSigma2TBE.tbsData2Signature.SetLength(signatureLen);
     ReturnErrorOnFailure(decryptedDataTlvReader.GetBytes(outParsedSigma2TBE.tbsData2Signature.Bytes(),
                                                          outParsedSigma2TBE.tbsData2Signature.Length()));
 
@@ -2073,7 +2074,8 @@ CHIP_ERROR CASESession::ParseSigma3TBEData(ContiguousBufferTLVReader & decrypted
     VerifyOrReturnError(decryptedDataTlvReader.GetTag() == AsTlvContextTag(TBEDataTags::kSignature), CHIP_ERROR_INVALID_TLV_TAG);
     size_t signatureLen = decryptedDataTlvReader.GetLength();
     VerifyOrReturnError(outHandleSigma3TBEData.tbsData3Signature.Capacity() == signatureLen, CHIP_ERROR_INVALID_TLV_ELEMENT);
-    outHandleSigma3TBEData.tbsData3Signature.SetLength(signatureLen);
+    // Size checked above
+    RETURN_SAFELY_IGNORED outHandleSigma3TBEData.tbsData3Signature.SetLength(signatureLen);
     ReturnErrorOnFailure(decryptedDataTlvReader.GetBytes(outHandleSigma3TBEData.tbsData3Signature.Bytes(),
                                                          outHandleSigma3TBEData.tbsData3Signature.Length()));
 
diff --git a/src/protocols/secure_channel/MessageCounterManager.cpp b/src/protocols/secure_channel/MessageCounterManager.cpp
@@ -55,7 +55,8 @@ void MessageCounterManager::Shutdown()
 {
     if (mExchangeMgr != nullptr)
     {
-        mExchangeMgr->UnregisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::MsgType::MsgCounterSyncReq);
+        TEMPORARY_RETURN_IGNORED mExchangeMgr->UnregisterUnsolicitedMessageHandlerForType(
+            Protocols::SecureChannel::MsgType::MsgCounterSyncReq);
         mExchangeMgr->CloseAllContextsForDelegate(this);
         mExchangeMgr = nullptr;
     }
diff --git a/src/protocols/secure_channel/PairingSession.cpp b/src/protocols/secure_channel/PairingSession.cpp
@@ -301,7 +301,7 @@ void PairingSession::OnSessionReleased()
         return;
     }
 
-    mSessionManager->SystemLayer()->ScheduleWork(
+    TEMPORARY_RETURN_IGNORED mSessionManager->SystemLayer()->ScheduleWork(
         [](auto * systemLayer, auto * appState) -> void {
             ChipLogError(Inet, "ASYNC CASE Session establishment failed");
             auto * _this = static_cast<PairingSession *>(appState);
diff --git a/src/protocols/secure_channel/SimpleSessionResumptionStorage.cpp b/src/protocols/secure_channel/SimpleSessionResumptionStorage.cpp
@@ -241,9 +241,8 @@ CHIP_ERROR SimpleSessionResumptionStorage::LoadState(const ScopedNodeId & node,
     ByteSpan sharedSecretSpan;
     ReturnErrorOnFailure(reader.Next(kSharedSecretTag));
     ReturnErrorOnFailure(reader.Get(sharedSecretSpan));
-    VerifyOrReturnError(sharedSecretSpan.size() <= sharedSecret.Capacity(), CHIP_ERROR_BUFFER_TOO_SMALL);
+    ReturnValueOnFailure(sharedSecret.SetLength(sharedSecretSpan.size()), CHIP_ERROR_BUFFER_TOO_SMALL);
     ::memcpy(sharedSecret.Bytes(), sharedSecretSpan.data(), sharedSecretSpan.size());
-    sharedSecret.SetLength(sharedSecretSpan.size());
 
     ByteSpan catSpan;
     ReturnErrorOnFailure(reader.Next(kCATTag));
@@ -254,15 +253,12 @@ CHIP_ERROR SimpleSessionResumptionStorage::LoadState(const ScopedNodeId & node,
     peerCATs.Deserialize(cat);
 
     ReturnErrorOnFailure(reader.ExitContainer(containerType));
-    ReturnErrorOnFailure(reader.VerifyEndOfContainer());
-
-    return CHIP_NO_ERROR;
+    return reader.VerifyEndOfContainer();
 }
 
 CHIP_ERROR SimpleSessionResumptionStorage::DeleteState(const ScopedNodeId & node)
 {
-    ReturnErrorOnFailure(mStorage->SyncDeleteKeyValue(GetStorageKey(node).KeyName()));
-    return CHIP_NO_ERROR;
+    return mStorage->SyncDeleteKeyValue(GetStorageKey(node).KeyName());
 }
 
 } // namespace chip
diff --git a/src/protocols/user_directed_commissioning/UserDirectedCommissioning.h b/src/protocols/user_directed_commissioning/UserDirectedCommissioning.h
@@ -193,6 +193,7 @@ class DLL_EXPORT IdentificationDeclaration
 
     void DebugLog()
     {
+#if CHIP_DETAIL_LOGGING
         ChipLogDetail(AppServer, "---- Identification Declaration Start ----");
 
         ChipLogDetail(AppServer, "\tinstance: %s", mInstanceName);
@@ -215,8 +216,13 @@ class DLL_EXPORT IdentificationDeclaration
         if (mRotatingIdLen > 0)
         {
             char rotatingIdString[chip::Dnssd::kMaxRotatingIdLen * 2 + 1] = "";
-            Encoding::BytesToUppercaseHexString(mRotatingId, mRotatingIdLen, rotatingIdString, sizeof(rotatingIdString));
-            ChipLogDetail(AppServer, "\trotating id: %s", rotatingIdString);
+            const char * rotatingIdStringPtr                              = rotatingIdString;
+            if (Encoding::BytesToUppercaseHexString(mRotatingId, mRotatingIdLen, rotatingIdString, sizeof(rotatingIdString)) !=
+                CHIP_NO_ERROR)
+            {
+                rotatingIdStringPtr = "<invalid id>";
+            }
+            ChipLogDetail(AppServer, "\trotating id: %s", rotatingIdStringPtr);
         }
         for (uint8_t i = 0; i < mNumTargetAppInfos; i++)
         {
@@ -256,6 +262,7 @@ class DLL_EXPORT IdentificationDeclaration
             ChipLogDetail(AppServer, "\tpasscode length: %d", static_cast<uint16_t>(mPasscodeLength));
         }
         ChipLogDetail(AppServer, "---- Identification Declaration End ----");
+#endif
     }
 
 private:
diff --git a/src/protocols/user_directed_commissioning/UserDirectedCommissioningClient.cpp b/src/protocols/user_directed_commissioning/UserDirectedCommissioningClient.cpp
@@ -271,10 +271,10 @@ void UserDirectedCommissioningClient::OnMessageReceived(const Transport::PeerAdd
 
     uint8_t udcPayload[IdentificationDeclaration::kUdcTLVDataMaxBytes];
     size_t udcPayloadLength = std::min<size_t>(msg->DataLength(), sizeof(udcPayload));
-    msg->Read(udcPayload, udcPayloadLength);
+    TEMPORARY_RETURN_IGNORED msg->Read(udcPayload, udcPayloadLength);
 
     CommissionerDeclaration cd;
-    cd.ReadPayload(udcPayload, sizeof(udcPayload));
+    TEMPORARY_RETURN_IGNORED cd.ReadPayload(udcPayload, sizeof(udcPayload));
     cd.DebugLog();
 
     // Call the registered mCommissionerDeclarationHandler, if any.
diff --git a/src/protocols/user_directed_commissioning/UserDirectedCommissioningServer.cpp b/src/protocols/user_directed_commissioning/UserDirectedCommissioningServer.cpp
@@ -58,10 +58,10 @@ void UserDirectedCommissioningServer::OnMessageReceived(const Transport::PeerAdd
 
     uint8_t udcPayload[IdentificationDeclaration::kUdcTLVDataMaxBytes];
     size_t udcPayloadLength = std::min<size_t>(msg->DataLength(), sizeof(udcPayload));
-    msg->Read(udcPayload, udcPayloadLength);
+    TEMPORARY_RETURN_IGNORED msg->Read(udcPayload, udcPayloadLength);
 
     IdentificationDeclaration id;
-    id.ReadPayload(udcPayload, sizeof(udcPayload));
+    TEMPORARY_RETURN_IGNORED id.ReadPayload(udcPayload, sizeof(udcPayload));
 
     if (id.GetCancelPasscode())
     {
@@ -313,7 +313,7 @@ CHIP_ERROR IdentificationDeclaration::ReadPayload(uint8_t * udcPayload, size_t p
                 chip::TLV::TLVType listContainerType = chip::TLV::kTLVType_List;
                 ReturnErrorOnFailure(reader.EnterContainer(listContainerType));
 
-                while ((err = reader.Next()) == CHIP_NO_ERROR && mNumTargetAppInfos < sizeof(mTargetAppInfos))
+                while ((err = reader.Next()) == CHIP_NO_ERROR && mNumTargetAppInfos < kMaxTargetAppInfos)
                 {
                     containerTag = reader.GetTag();
                     if (!TLV::IsContextTag(containerTag))
@@ -555,6 +555,7 @@ void UserDirectedCommissioningServer::OnCommissionableNodeFound(const Dnssd::Dis
 
 void UserDirectedCommissioningServer::PrintUDCClients()
 {
+#if CHIP_PROGRESS_LOGGING
     for (uint8_t i = 0; i < kMaxUDCClients; i++)
     {
         UDCClientState * state = GetUDCClients().GetUDCClientState(i);
@@ -568,15 +569,20 @@ void UserDirectedCommissioningServer::PrintUDCClients()
             state->GetPeerAddress().ToString(addrBuffer);
 
             char rotatingIdString[chip::Dnssd::kMaxRotatingIdLen * 2 + 1] = "";
-            Encoding::BytesToUppercaseHexString(state->GetRotatingId(), chip::Dnssd::kMaxRotatingIdLen, rotatingIdString,
-                                                sizeof(rotatingIdString));
+            const char * rotatingIdStringPtr                              = rotatingIdString;
+            if (Encoding::BytesToUppercaseHexString(state->GetRotatingId(), chip::Dnssd::kMaxRotatingIdLen, rotatingIdString,
+                                                    sizeof(rotatingIdString)) != CHIP_NO_ERROR)
+            {
+                rotatingIdStringPtr = "<invalid id>";
+            }
 
             ChipLogProgress(AppServer,
                             "PrintUDCClients() UDC Client[%d] instance=%s deviceName=%s address=%s, vid/pid=%d/%d disc=%d rid=%s",
                             i, state->GetInstanceName(), state->GetDeviceName(), addrBuffer, state->GetVendorId(),
-                            state->GetProductId(), state->GetLongDiscriminator(), rotatingIdString);
+                            state->GetProductId(), state->GetLongDiscriminator(), rotatingIdStringPtr);
         }
     }
+#endif
 }
 
 } // namespace UserDirectedCommissioning

Original file line number	Diff line number	Diff line change
`@@ -308,19 +308,16 @@ CATValues PersistentStorage::GetCommissionerCATs()`
`308`	`308`	`err = SyncGetKeyValue(kCommissionerCATsKey, serializedCATs, size);`
`309`	`309`	`if (err == CHIP_NO_ERROR && size == chip::CATValues::kSerializedLength)`
`310`	`310`	`{`
`311`		`- err = cats.Deserialize(serializedCATs);`
`312`		`- if (err == CHIP_NO_ERROR)`
`313`		`- {`
`314`		`- return cats;`
`315`		`- }`
	`311`	`+ cats.Deserialize(serializedCATs);`
	`312`	`+ return cats;`
`316`	`313`	`}`
`317`	`314`	`return chip::kUndefinedCATs;`
`318`	`315`	`}`
`319`	`316`
`320`	`317`	`CHIP_ERROR PersistentStorage::SetCommissionerCATs(const CATValues & cats)`
`321`	`318`	`{`
`322`	`319`	`chip::CATValues::Serialized serializedCATs;`
`323`		`- ReturnErrorOnFailure(cats.Serialize(serializedCATs));`
	`320`	`+ cats.Serialize(serializedCATs);`
`324`	`321`
`325`	`322`	`return SyncSetKeyValue(kCommissionerCATsKey, serializedCATs, sizeof(serializedCATs));`
`326`	`323`	`}`
Original file line number	Diff line number	Diff line change
`@@ -221,24 +221,22 @@ struct CATValues`
`221`	`221`	`static constexpr size_t kSerializedLength = kMaxSubjectCATAttributeCount * sizeof(CASEAuthTag);`
`222`	`222`	`typedef uint8_t Serialized[kSerializedLength];`
`223`	`223`
`224`		`- CHIP_ERROR Serialize(Serialized & outSerialized) const`
	`224`	`+ void Serialize(Serialized & outSerialized) const`
`225`	`225`	`{`
`226`	`226`	`uint8_t * p = outSerialized;`
`227`	`227`	`for (size_t i = 0; i < kMaxSubjectCATAttributeCount; i++)`
`228`	`228`	`{`
`229`	`229`	`Encoding::LittleEndian::Write32(p, values[i]);`
`230`	`230`	`}`
`231`		`- return CHIP_NO_ERROR;`
`232`	`231`	`}`
`233`	`232`
`234`		`- CHIP_ERROR Deserialize(const Serialized & inSerialized)`
	`233`	`+ void Deserialize(const Serialized & inSerialized)`
`235`	`234`	`{`
`236`	`235`	`const uint8_t * p = inSerialized;`
`237`	`236`	`for (size_t i = 0; i < kMaxSubjectCATAttributeCount; i++)`
`238`	`237`	`{`
`239`	`238`	`values[i] = Encoding::LittleEndian::Read32(p);`
`240`	`239`	`}`
`241`		`- return CHIP_NO_ERROR;`
`242`	`240`	`}`
`243`	`241`	`};`
`244`	`242`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ CHIP_ERROR AsyncTransferFacilitator::OnMessageReceived(Messaging::ExchangeContex`
`149`	`149`
`150`	`150`	`// This should notify the transfer object to abort transfer so it can send a status report across the exchange`
`151`	`151`	`// when we call ProcessOutputEvents below.`
`152`		`- mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(err));`
	`152`	`+ TEMPORARY_RETURN_IGNORED mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(err));`
`153`	`153`	`}`
`154`	`154`	`else if (!payloadHeader.HasMessageType(MessageType::BlockAckEOF))`
`155`	`155`	`{`
`@@ -199,7 +199,7 @@ void AsyncResponder::NotifyEventHandled(const TransferSession::OutputEventType e`
`199`	`199`	`{`
`200`	`200`	`// If there was an error handling the output event, this should notify the transfer object to abort transfer`
`201`	`201`	`// so it can send a status report across the exchange when we call ProcessOutputEvents below.`
`202`		`- mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(status));`
	`202`	`+ TEMPORARY_RETURN_IGNORED mTransfer.AbortTransfer(GetBdxStatusCodeFromChipError(status));`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`ProcessOutputEvents();`
Original file line number	Diff line number	Diff line change
`@@ -93,13 +93,13 @@ void TransferFacilitator::PollForOutput()`
`93`	`93`	`HandleTransferSessionOutput(outEvent);`
`94`	`94`
`95`	`95`	`VerifyOrReturn(mSystemLayer != nullptr, ChipLogError(BDX, "%s mSystemLayer is null", __FUNCTION__));`
`96`		`- mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);`
	`96`	`+ TEMPORARY_RETURN_IGNORED mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`void TransferFacilitator::ScheduleImmediatePoll()`
`100`	`100`	`{`
`101`	`101`	`VerifyOrReturn(mSystemLayer != nullptr, ChipLogError(BDX, "%s mSystemLayer is null", __FUNCTION__));`
`102`		`- mSystemLayer->StartTimer(System::Clock::Milliseconds32(kImmediatePollDelay), PollTimerHandler, this);`
	`102`	`+ TEMPORARY_RETURN_IGNORED mSystemLayer->StartTimer(System::Clock::Milliseconds32(kImmediatePollDelay), PollTimerHandler, this);`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`CHIP_ERROR Responder::PrepareForTransfer(System::Layer * layer, TransferRole role, BitFlags<TransferControlFlags> xferControlOpts,`
`@@ -113,8 +113,7 @@ CHIP_ERROR Responder::PrepareForTransfer(System::Layer * layer, TransferRole rol`
`113`	`113`	`ReturnErrorOnFailure(mTransfer.WaitForTransfer(role, xferControlOpts, maxBlockSize, timeout));`
`114`	`114`
`115`	`115`	`ChipLogProgress(BDX, "Start polling for messages");`
`116`		`- mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);`
`117`		`- return CHIP_NO_ERROR;`
	`116`	`+ return mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);`
`118`	`117`	`}`
`119`	`118`
`120`	`119`	`CHIP_ERROR Initiator::InitiateTransfer(System::Layer * layer, TransferRole role, const TransferSession::TransferInitData & initData,`
`@@ -127,8 +126,7 @@ CHIP_ERROR Initiator::InitiateTransfer(System::Layer * layer, TransferRole role,`
`127`	`126`
`128`	`127`	`ReturnErrorOnFailure(mTransfer.StartTransfer(role, initData, timeout));`
`129`	`128`
`130`		`- mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);`
`131`		`- return CHIP_NO_ERROR;`
	`129`	`+ return mSystemLayer->StartTimer(mPollFreq, PollTimerHandler, this);`
`132`	`130`	`}`
`133`	`131`
`134`	`132`	`} // namespace bdx`
Original file line number	Diff line number	Diff line change
`@@ -38,16 +38,14 @@ CHIP_ERROR EchoServer::Init(Messaging::ExchangeManager * exchangeMgr)`
`38`	`38`	`OnEchoRequestReceived = nullptr;`
`39`	`39`
`40`	`40`	`// Register to receive unsolicited Echo Request messages from the exchange manager.`
`41`		`- mExchangeMgr->RegisterUnsolicitedMessageHandlerForType(MsgType::EchoRequest, this);`
`42`		`-`
`43`		`- return CHIP_NO_ERROR;`
	`41`	`+ return mExchangeMgr->RegisterUnsolicitedMessageHandlerForType(MsgType::EchoRequest, this);`
`44`	`42`	`}`
`45`	`43`
`46`	`44`	`void EchoServer::Shutdown()`
`47`	`45`	`{`
`48`	`46`	`if (mExchangeMgr != nullptr)`
`49`	`47`	`{`
`50`		`- mExchangeMgr->UnregisterUnsolicitedMessageHandlerForType(MsgType::EchoRequest);`
	`48`	`+ TEMPORARY_RETURN_IGNORED mExchangeMgr->UnregisterUnsolicitedMessageHandlerForType(MsgType::EchoRequest);`
`51`	`49`	`mExchangeMgr = nullptr;`
`52`	`50`	`}`
`53`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,8 @@ class CASEServer : public SessionEstablishmentDelegate,`
`44`	`44`	`{`
`45`	`45`	`if (mExchangeManager != nullptr)`
`46`	`46`	`{`
`47`		`- mExchangeManager->UnregisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::MsgType::CASE_Sigma1);`
	`47`	`+ TEMPORARY_RETURN_IGNORED mExchangeManager->UnregisterUnsolicitedMessageHandlerForType(`
	`48`	`+ Protocols::SecureChannel::MsgType::CASE_Sigma1);`
`48`	`49`	`mExchangeManager = nullptr;`
`49`	`50`	`}`
`50`	`51`