Cleanup extra namespace prefix (#35664)

yufengwangca · web-flow · commit 884d9fa1e55d · 2024-09-19T07:43:33.000Z
diff --git a/examples/fabric-admin/commands/fabric-sync/FabricSyncCommand.cpp b/examples/fabric-admin/commands/fabric-sync/FabricSyncCommand.cpp
@@ -274,7 +274,7 @@ CHIP_ERROR FabricSyncRemoveLocalBridgeCommand::RunCommand()
     return CHIP_NO_ERROR;
 }
 
-void FabricSyncDeviceCommand::OnCommissioningWindowOpened(NodeId deviceId, CHIP_ERROR err, chip::SetupPayload payload)
+void FabricSyncDeviceCommand::OnCommissioningWindowOpened(NodeId deviceId, CHIP_ERROR err, SetupPayload payload)
 {
     ChipLogProgress(NotSpecified, "FabricSyncDeviceCommand::OnCommissioningWindowOpened");
 
diff --git a/examples/fabric-admin/commands/pairing/OpenCommissioningWindowCommand.cpp b/examples/fabric-admin/commands/pairing/OpenCommissioningWindowCommand.cpp
@@ -68,7 +68,7 @@ CHIP_ERROR OpenCommissioningWindowCommand::RunCommand()
 }
 
 void OpenCommissioningWindowCommand::OnOpenCommissioningWindowResponse(void * context, NodeId remoteId, CHIP_ERROR err,
-                                                                       chip::SetupPayload payload)
+                                                                       SetupPayload payload)
 {
     OnOpenBasicCommissioningWindowResponse(context, remoteId, err);
 }
diff --git a/examples/fabric-admin/commands/pairing/PairingCommand.cpp b/examples/fabric-admin/commands/pairing/PairingCommand.cpp
@@ -169,7 +169,7 @@ CommissioningParameters PairingCommand::GetCommissioningParameters()
 
         if (!mICDSymmetricKey.HasValue())
         {
-            chip::Crypto::DRBG_get_bytes(mRandomGeneratedICDSymmetricKey, sizeof(mRandomGeneratedICDSymmetricKey));
+            Crypto::DRBG_get_bytes(mRandomGeneratedICDSymmetricKey, sizeof(mRandomGeneratedICDSymmetricKey));
             mICDSymmetricKey.SetValue(ByteSpan(mRandomGeneratedICDSymmetricKey));
         }
         if (!mICDCheckInNodeId.HasValue())
@@ -296,7 +296,7 @@ CHIP_ERROR PairingCommand::PairWithMdnsOrBleByIndexWithCode(NodeId remoteId, uin
         // There is no device with this index that has some resolution data. This could simply
         // be because the device is a ble device. In this case let's fall back to looking for
         // a device with this index and some RendezvousParameters.
-        chip::SetupPayload payload;
+        SetupPayload payload;
         bool isQRCode = strncmp(mOnboardingPayload, kQRCodePrefix, strlen(kQRCodePrefix)) == 0;
         if (isQRCode)
         {
@@ -336,21 +336,21 @@ CHIP_ERROR PairingCommand::PairWithMdns(NodeId remoteId)
     Dnssd::DiscoveryFilter filter(mFilterType);
     switch (mFilterType)
     {
-    case chip::Dnssd::DiscoveryFilterType::kNone:
+    case Dnssd::DiscoveryFilterType::kNone:
         break;
-    case chip::Dnssd::DiscoveryFilterType::kShortDiscriminator:
-    case chip::Dnssd::DiscoveryFilterType::kLongDiscriminator:
-    case chip::Dnssd::DiscoveryFilterType::kCompressedFabricId:
-    case chip::Dnssd::DiscoveryFilterType::kVendorId:
-    case chip::Dnssd::DiscoveryFilterType::kDeviceType:
+    case Dnssd::DiscoveryFilterType::kShortDiscriminator:
+    case Dnssd::DiscoveryFilterType::kLongDiscriminator:
+    case Dnssd::DiscoveryFilterType::kCompressedFabricId:
+    case Dnssd::DiscoveryFilterType::kVendorId:
+    case Dnssd::DiscoveryFilterType::kDeviceType:
         filter.code = mDiscoveryFilterCode;
         break;
-    case chip::Dnssd::DiscoveryFilterType::kCommissioningMode:
+    case Dnssd::DiscoveryFilterType::kCommissioningMode:
         break;
-    case chip::Dnssd::DiscoveryFilterType::kCommissioner:
+    case Dnssd::DiscoveryFilterType::kCommissioner:
         filter.code = 1;
         break;
-    case chip::Dnssd::DiscoveryFilterType::kInstanceName:
+    case Dnssd::DiscoveryFilterType::kInstanceName:
         filter.code         = 0;
         filter.instanceName = mDiscoveryFilterInstanceName;
         break;
@@ -480,10 +480,10 @@ void PairingCommand::OnReadCommissioningInfo(const Controller::ReadCommissioning
 
 void PairingCommand::OnICDRegistrationComplete(ScopedNodeId nodeId, uint32_t icdCounter)
 {
-    char icdSymmetricKeyHex[chip::Crypto::kAES_CCM128_Key_Length * 2 + 1];
+    char icdSymmetricKeyHex[Crypto::kAES_CCM128_Key_Length * 2 + 1];
 
-    chip::Encoding::BytesToHex(mICDSymmetricKey.Value().data(), mICDSymmetricKey.Value().size(), icdSymmetricKeyHex,
-                               sizeof(icdSymmetricKeyHex), chip::Encoding::HexFlags::kNullTerminate);
+    Encoding::BytesToHex(mICDSymmetricKey.Value().data(), mICDSymmetricKey.Value().size(), icdSymmetricKeyHex,
+                         sizeof(icdSymmetricKeyHex), Encoding::HexFlags::kNullTerminate);
 
     app::ICDClientInfo clientInfo;
     clientInfo.peer_node         = nodeId;
@@ -521,15 +521,15 @@ void PairingCommand::OnICDStayActiveComplete(ScopedNodeId deviceId, uint32_t pro
                     ChipLogValueX64(deviceId.GetNodeId()), promisedActiveDuration);
 }
 
-void PairingCommand::OnDiscoveredDevice(const chip::Dnssd::CommissionNodeData & nodeData)
+void PairingCommand::OnDiscoveredDevice(const Dnssd::CommissionNodeData & nodeData)
 {
     // Ignore nodes with closed commissioning window
     VerifyOrReturn(nodeData.commissioningMode != 0);
 
     auto & resolutionData = nodeData;
 
     const uint16_t port = resolutionData.port;
-    char buf[chip::Inet::IPAddress::kMaxStringLength];
+    char buf[Inet::IPAddress::kMaxStringLength];
     resolutionData.ipAddress[0].ToString(buf);
     ChipLogProgress(NotSpecified, "Discovered Device: %s:%u", buf, port);
 
@@ -566,8 +566,7 @@ void PairingCommand::OnCurrentFabricRemove(void * context, NodeId nodeId, CHIP_E
         fprintf(stderr, "Device with Node ID: 0x%lx has been successfully removed.\n", nodeId);
 
 #if defined(PW_RPC_ENABLED)
-        chip::app::InteractionModelEngine::GetInstance()->ShutdownSubscriptions(command->CurrentCommissioner().GetFabricIndex(),
-                                                                                nodeId);
+        app::InteractionModelEngine::GetInstance()->ShutdownSubscriptions(command->CurrentCommissioner().GetFabricIndex(), nodeId);
         RemoveSynchronizedDevice(nodeId);
 #endif
     }
@@ -586,10 +585,10 @@ void PairingCommand::OnCurrentFabricRemove(void * context, NodeId nodeId, CHIP_E
     command->SetCommandExitStatus(err);
 }
 
-chip::Optional<uint16_t> PairingCommand::FailSafeExpiryTimeoutSecs() const
+Optional<uint16_t> PairingCommand::FailSafeExpiryTimeoutSecs() const
 {
     // No manual input, so do not need to extend.
-    return chip::Optional<uint16_t>();
+    return Optional<uint16_t>();
 }
 
 bool PairingCommand::ShouldWaitAfterDeviceAttestation()
@@ -603,10 +602,9 @@ bool PairingCommand::ShouldWaitAfterDeviceAttestation()
     return err == CHIP_NO_ERROR && (payload.vendorID != 0 || payload.productID != 0);
 }
 
-void PairingCommand::OnDeviceAttestationCompleted(chip::Controller::DeviceCommissioner * deviceCommissioner,
-                                                  chip::DeviceProxy * device,
-                                                  const chip::Credentials::DeviceAttestationVerifier::AttestationDeviceInfo & info,
-                                                  chip::Credentials::AttestationVerificationResult attestationResult)
+void PairingCommand::OnDeviceAttestationCompleted(Controller::DeviceCommissioner * deviceCommissioner, DeviceProxy * device,
+                                                  const Credentials::DeviceAttestationVerifier::AttestationDeviceInfo & info,
+                                                  Credentials::AttestationVerificationResult attestationResult)
 {
     SetupPayload payload;
     CHIP_ERROR parse_error = GetPayload(mOnboardingPayload, payload);
@@ -619,7 +617,7 @@ void PairingCommand::OnDeviceAttestationCompleted(chip::Controller::DeviceCommis
                             "Requested VID: %u, Requested PID: %u.",
                             payload.vendorID, payload.productID);
             deviceCommissioner->ContinueCommissioningAfterDeviceAttestation(
-                device, chip::Credentials::AttestationVerificationResult::kInvalidArgument);
+                device, Credentials::AttestationVerificationResult::kInvalidArgument);
             return;
         }
 
@@ -633,8 +631,8 @@ void PairingCommand::OnDeviceAttestationCompleted(chip::Controller::DeviceCommis
             deviceCommissioner->ContinueCommissioningAfterDeviceAttestation(
                 device,
                 payload.vendorID == info.BasicInformationVendorId()
-                    ? chip::Credentials::AttestationVerificationResult::kDacProductIdMismatch
-                    : chip::Credentials::AttestationVerificationResult::kDacVendorIdMismatch);
+                    ? Credentials::AttestationVerificationResult::kDacProductIdMismatch
+                    : Credentials::AttestationVerificationResult::kDacVendorIdMismatch);
             return;
         }
 
@@ -654,7 +652,7 @@ void PairingCommand::OnDeviceAttestationCompleted(chip::Controller::DeviceCommis
     {
         // Bypass attestation verification, continue with success
         auto err = deviceCommissioner->ContinueCommissioningAfterDeviceAttestation(
-            device, chip::Credentials::AttestationVerificationResult::kSuccess);
+            device, Credentials::AttestationVerificationResult::kSuccess);
         if (CHIP_NO_ERROR != err)
         {
             SetCommandExitStatus(err);
diff --git a/examples/fabric-admin/device_manager/DeviceManager.cpp b/examples/fabric-admin/device_manager/DeviceManager.cpp
@@ -150,7 +150,7 @@ void DeviceManager::OpenRemoteDeviceCommissioningWindow(EndpointId remoteEndpoin
     }
 }
 
-void DeviceManager::PairRemoteFabricBridge(chip::NodeId nodeId, uint32_t setupPINCode, const char * deviceRemoteIp,
+void DeviceManager::PairRemoteFabricBridge(NodeId nodeId, uint32_t setupPINCode, const char * deviceRemoteIp,
                                            uint16_t deviceRemotePort)
 {
     StringBuilder<kMaxCommandSize> commandBuilder;
@@ -240,7 +240,7 @@ void DeviceManager::ReadSupportedDeviceCategories()
     PushCommand(commandBuilder.c_str());
 }
 
-void DeviceManager::HandleReadSupportedDeviceCategories(chip::TLV::TLVReader & data)
+void DeviceManager::HandleReadSupportedDeviceCategories(TLV::TLVReader & data)
 {
     ChipLogProgress(NotSpecified, "Attribute SupportedDeviceCategories detected.");
 
@@ -305,7 +305,7 @@ void DeviceManager::HandleCommissioningRequestResult(TLV::TLVReader & data)
     SendCommissionNodeRequest(value.requestID, kResponseTimeoutSeconds);
 }
 
-void DeviceManager::HandleAttributePartsListUpdate(chip::TLV::TLVReader & data)
+void DeviceManager::HandleAttributePartsListUpdate(TLV::TLVReader & data)
 {
     ChipLogProgress(NotSpecified, "Attribute PartsList change detected:");
 
diff --git a/examples/fabric-admin/device_manager/DeviceSubscription.cpp b/examples/fabric-admin/device_manager/DeviceSubscription.cpp
@@ -85,7 +85,7 @@ void DeviceSubscription::OnAttributeData(const ConcreteDataAttributePath & path,
     }
     case Clusters::AdministratorCommissioning::Attributes::AdminVendorId::Id: {
 #if defined(PW_RPC_ENABLED)
-        chip::VendorId vendorId;
+        VendorId vendorId;
         CHIP_ERROR err                                                    = data->Get(vendorId);
         mCurrentAdministratorCommissioningAttributes.has_opener_vendor_id = err == CHIP_NO_ERROR;
         if (mCurrentAdministratorCommissioningAttributes.has_opener_vendor_id)
diff --git a/examples/fabric-admin/device_manager/DeviceSubscriptionManager.cpp b/examples/fabric-admin/device_manager/DeviceSubscriptionManager.cpp
@@ -53,7 +53,7 @@ CHIP_ERROR DeviceSubscriptionManager::StartSubscription(Controller::DeviceContro
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR DeviceSubscriptionManager::RemoveSubscription(chip::NodeId nodeId)
+CHIP_ERROR DeviceSubscriptionManager::RemoveSubscription(NodeId nodeId)
 {
     assertChipStackLockedByCurrentThread();
     auto it = mDeviceSubscriptionMap.find(nodeId);
diff --git a/examples/fabric-admin/device_manager/DeviceSynchronization.cpp b/examples/fabric-admin/device_manager/DeviceSynchronization.cpp
@@ -138,7 +138,7 @@ void DeviceSynchronizer::OnReportEnd()
     MoveToState(State::ReceivedResponse);
 }
 
-void DeviceSynchronizer::OnDone(chip::app::ReadClient * apReadClient)
+void DeviceSynchronizer::OnDone(app::ReadClient * apReadClient)
 {
 #if defined(PW_RPC_ENABLED)
     if (mState == State::ReceivedResponse && !DeviceMgr().IsCurrentBridgeDevice(mNodeId))
@@ -163,8 +163,7 @@ void DeviceSynchronizer::OnError(CHIP_ERROR error)
     ChipLogProgress(NotSpecified, "Error fetching device data: %" CHIP_ERROR_FORMAT, error.Format());
 }
 
-void DeviceSynchronizer::OnDeviceConnected(chip::Messaging::ExchangeManager & exchangeMgr,
-                                           const chip::SessionHandle & sessionHandle)
+void DeviceSynchronizer::OnDeviceConnected(Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle)
 {
     mClient = std::make_unique<ReadClient>(app::InteractionModelEngine::GetInstance(), &exchangeMgr /* echangeMgr */,
                                            *this /* callback */, ReadClient::InteractionType::Read);
@@ -188,14 +187,13 @@ void DeviceSynchronizer::OnDeviceConnected(chip::Messaging::ExchangeManager & ex
     MoveToState(State::AwaitingResponse);
 }
 
-void DeviceSynchronizer::OnDeviceConnectionFailure(const chip::ScopedNodeId & peerId, CHIP_ERROR error)
+void DeviceSynchronizer::OnDeviceConnectionFailure(const ScopedNodeId & peerId, CHIP_ERROR error)
 {
     ChipLogError(NotSpecified, "Device Sync failed to connect to " ChipLogFormatX64, ChipLogValueX64(peerId.GetNodeId()));
     MoveToState(State::Idle);
 }
 
-void DeviceSynchronizer::StartDeviceSynchronization(chip::Controller::DeviceController * controller, chip::NodeId nodeId,
-                                                    bool deviceIsIcd)
+void DeviceSynchronizer::StartDeviceSynchronization(Controller::DeviceController * controller, NodeId nodeId, bool deviceIsIcd)
 {
     VerifyOrDie(controller);
     if (mState != State::Idle)
diff --git a/examples/fabric-admin/device_manager/UniqueIdGetter.cpp b/examples/fabric-admin/device_manager/UniqueIdGetter.cpp
@@ -53,8 +53,8 @@ UniqueIdGetter::UniqueIdGetter() :
     mOnDeviceConnectionFailureCallback(OnDeviceConnectionFailureWrapper, this)
 {}
 
-CHIP_ERROR UniqueIdGetter::GetUniqueId(OnDoneCallback onDoneCallback, chip::Controller::DeviceController & controller,
-                                       chip::NodeId nodeId, chip::EndpointId endpointId)
+CHIP_ERROR UniqueIdGetter::GetUniqueId(OnDoneCallback onDoneCallback, Controller::DeviceController & controller, NodeId nodeId,
+                                       EndpointId endpointId)
 {
     assertChipStackLockedByCurrentThread();
     VerifyOrDie(!mCurrentlyGettingUid);
diff --git a/examples/fabric-admin/rpc/RpcClient.cpp b/examples/fabric-admin/rpc/RpcClient.cpp
@@ -144,7 +144,7 @@ CHIP_ERROR AddSynchronizedDevice(const chip_rpc_SynchronizedDevice & data)
     return WaitForResponse(call);
 }
 
-CHIP_ERROR RemoveSynchronizedDevice(chip::NodeId nodeId)
+CHIP_ERROR RemoveSynchronizedDevice(NodeId nodeId)
 {
     ChipLogProgress(NotSpecified, "RemoveSynchronizedDevice");
 
@@ -164,7 +164,7 @@ CHIP_ERROR RemoveSynchronizedDevice(chip::NodeId nodeId)
     return WaitForResponse(call);
 }
 
-CHIP_ERROR ActiveChanged(chip::NodeId nodeId, uint32_t promisedActiveDurationMs)
+CHIP_ERROR ActiveChanged(NodeId nodeId, uint32_t promisedActiveDurationMs)
 {
     ChipLogProgress(NotSpecified, "ActiveChanged");
 
diff --git a/examples/fabric-admin/rpc/RpcServer.cpp b/examples/fabric-admin/rpc/RpcServer.cpp
@@ -45,7 +45,7 @@ namespace {
 class FabricAdmin final : public rpc::FabricAdmin, public IcdManager::Delegate
 {
 public:
-    void OnCheckInCompleted(const chip::app::ICDClientInfo & clientInfo) override
+    void OnCheckInCompleted(const app::ICDClientInfo & clientInfo) override
     {
         // Accessing mPendingCheckIn should only be done while holding ChipStackLock
         assertChipStackLockedByCurrentThread();
@@ -76,7 +76,7 @@ class FabricAdmin final : public rpc::FabricAdmin, public IcdManager::Delegate
         // addressed, we can implement what spec defines here.
         auto onDone    = [=](uint32_t promisedActiveDuration) { ActiveChanged(nodeId, promisedActiveDuration); };
         CHIP_ERROR err = StayActiveSender::SendStayActiveCommand(checkInData.mStayActiveDurationMs, clientInfo.peer_node,
-                                                                 chip::app::InteractionModelEngine::GetInstance(), onDone);
+                                                                 app::InteractionModelEngine::GetInstance(), onDone);
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(NotSpecified, "Failed to send StayActive command %s", err.AsString());
@@ -156,7 +156,7 @@ class FabricAdmin final : public rpc::FabricAdmin, public IcdManager::Delegate
         KeepActiveWorkData * data =
             Platform::New<KeepActiveWorkData>(this, request.node_id, request.stay_active_duration_ms, request.timeout_ms);
         VerifyOrReturnValue(data, pw::Status::Internal());
-        chip::DeviceLayer::PlatformMgr().ScheduleWork(KeepActiveWork, reinterpret_cast<intptr_t>(data));
+        DeviceLayer::PlatformMgr().ScheduleWork(KeepActiveWork, reinterpret_cast<intptr_t>(data));
         return pw::OkStatus();
     }
 
@@ -194,7 +194,7 @@ class FabricAdmin final : public rpc::FabricAdmin, public IcdManager::Delegate
         {}
 
         FabricAdmin * mFabricAdmin;
-        chip::NodeId mNodeId;
+        NodeId mNodeId;
         uint32_t mStayActiveDurationMs;
         uint32_t mTimeoutMs;
     };
@@ -203,7 +203,7 @@ class FabricAdmin final : public rpc::FabricAdmin, public IcdManager::Delegate
     {
         KeepActiveWorkData * data = reinterpret_cast<KeepActiveWorkData *>(arg);
         data->mFabricAdmin->ScheduleSendingKeepActiveOnCheckIn(data->mNodeId, data->mStayActiveDurationMs, data->mTimeoutMs);
-        chip::Platform::Delete(data);
+        Platform::Delete(data);
     }
 
     // Modifications to mPendingCheckIn should be done on the MatterEventLoop thread

Original file line number	Diff line number	Diff line change
`@@ -274,7 +274,7 @@ CHIP_ERROR FabricSyncRemoveLocalBridgeCommand::RunCommand()`
`274`	`274`	`return CHIP_NO_ERROR;`
`275`	`275`	`}`
`276`	`276`
`277`		`-void FabricSyncDeviceCommand::OnCommissioningWindowOpened(NodeId deviceId, CHIP_ERROR err, chip::SetupPayload payload)`
	`277`	`+void FabricSyncDeviceCommand::OnCommissioningWindowOpened(NodeId deviceId, CHIP_ERROR err, SetupPayload payload)`
`278`	`278`	`{`
`279`	`279`	`ChipLogProgress(NotSpecified, "FabricSyncDeviceCommand::OnCommissioningWindowOpened");`
`280`	`280`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ CHIP_ERROR OpenCommissioningWindowCommand::RunCommand()`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`void OpenCommissioningWindowCommand::OnOpenCommissioningWindowResponse(void * context, NodeId remoteId, CHIP_ERROR err,`
`71`		`- chip::SetupPayload payload)`
	`71`	`+ SetupPayload payload)`
`72`	`72`	`{`
`73`	`73`	`OnOpenBasicCommissioningWindowResponse(context, remoteId, err);`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ void DeviceManager::OpenRemoteDeviceCommissioningWindow(EndpointId remoteEndpoin`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`
`153`		`-void DeviceManager::PairRemoteFabricBridge(chip::NodeId nodeId, uint32_t setupPINCode, const char * deviceRemoteIp,`
	`153`	`+void DeviceManager::PairRemoteFabricBridge(NodeId nodeId, uint32_t setupPINCode, const char * deviceRemoteIp,`
`154`	`154`	`uint16_t deviceRemotePort)`
`155`	`155`	`{`
`156`	`156`	`StringBuilder<kMaxCommandSize> commandBuilder;`
`@@ -240,7 +240,7 @@ void DeviceManager::ReadSupportedDeviceCategories()`
`240`	`240`	`PushCommand(commandBuilder.c_str());`
`241`	`241`	`}`
`242`	`242`
`243`		`-void DeviceManager::HandleReadSupportedDeviceCategories(chip::TLV::TLVReader & data)`
	`243`	`+void DeviceManager::HandleReadSupportedDeviceCategories(TLV::TLVReader & data)`
`244`	`244`	`{`
`245`	`245`	`ChipLogProgress(NotSpecified, "Attribute SupportedDeviceCategories detected.");`
`246`	`246`
`@@ -305,7 +305,7 @@ void DeviceManager::HandleCommissioningRequestResult(TLV::TLVReader & data)`
`305`	`305`	`SendCommissionNodeRequest(value.requestID, kResponseTimeoutSeconds);`
`306`	`306`	`}`
`307`	`307`
`308`		`-void DeviceManager::HandleAttributePartsListUpdate(chip::TLV::TLVReader & data)`
	`308`	`+void DeviceManager::HandleAttributePartsListUpdate(TLV::TLVReader & data)`
`309`	`309`	`{`
`310`	`310`	`ChipLogProgress(NotSpecified, "Attribute PartsList change detected:");`
`311`	`311`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ void DeviceSubscription::OnAttributeData(const ConcreteDataAttributePath & path,`
`85`	`85`	`}`
`86`	`86`	`case Clusters::AdministratorCommissioning::Attributes::AdminVendorId::Id: {`
`87`	`87`	`#if defined(PW_RPC_ENABLED)`
`88`		`- chip::VendorId vendorId;`
	`88`	`+ VendorId vendorId;`
`89`	`89`	`CHIP_ERROR err = data->Get(vendorId);`
`90`	`90`	`mCurrentAdministratorCommissioningAttributes.has_opener_vendor_id = err == CHIP_NO_ERROR;`
`91`	`91`	`if (mCurrentAdministratorCommissioningAttributes.has_opener_vendor_id)`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ CHIP_ERROR DeviceSubscriptionManager::StartSubscription(Controller::DeviceContro`
`53`	`53`	`return CHIP_NO_ERROR;`
`54`	`54`	`}`
`55`	`55`
`56`		`-CHIP_ERROR DeviceSubscriptionManager::RemoveSubscription(chip::NodeId nodeId)`
	`56`	`+CHIP_ERROR DeviceSubscriptionManager::RemoveSubscription(NodeId nodeId)`
`57`	`57`	`{`
`58`	`58`	`assertChipStackLockedByCurrentThread();`
`59`	`59`	`auto it = mDeviceSubscriptionMap.find(nodeId);`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ void DeviceSynchronizer::OnReportEnd()`
`138`	`138`	`MoveToState(State::ReceivedResponse);`
`139`	`139`	`}`
`140`	`140`
`141`		`-void DeviceSynchronizer::OnDone(chip::app::ReadClient * apReadClient)`
	`141`	`+void DeviceSynchronizer::OnDone(app::ReadClient * apReadClient)`
`142`	`142`	`{`
`143`	`143`	`#if defined(PW_RPC_ENABLED)`
`144`	`144`	`if (mState == State::ReceivedResponse && !DeviceMgr().IsCurrentBridgeDevice(mNodeId))`
`@@ -163,8 +163,7 @@ void DeviceSynchronizer::OnError(CHIP_ERROR error)`
`163`	`163`	`ChipLogProgress(NotSpecified, "Error fetching device data: %" CHIP_ERROR_FORMAT, error.Format());`
`164`	`164`	`}`
`165`	`165`
`166`		`-void DeviceSynchronizer::OnDeviceConnected(chip::Messaging::ExchangeManager & exchangeMgr,`
`167`		`- const chip::SessionHandle & sessionHandle)`
	`166`	`+void DeviceSynchronizer::OnDeviceConnected(Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle)`
`168`	`167`	`{`
`169`	`168`	`mClient = std::make_unique<ReadClient>(app::InteractionModelEngine::GetInstance(), &exchangeMgr /* echangeMgr */,`
`170`	`169`	`this / callback */, ReadClient::InteractionType::Read);`
`@@ -188,14 +187,13 @@ void DeviceSynchronizer::OnDeviceConnected(chip::Messaging::ExchangeManager & ex`
`188`	`187`	`MoveToState(State::AwaitingResponse);`
`189`	`188`	`}`
`190`	`189`
`191`		`-void DeviceSynchronizer::OnDeviceConnectionFailure(const chip::ScopedNodeId & peerId, CHIP_ERROR error)`
	`190`	`+void DeviceSynchronizer::OnDeviceConnectionFailure(const ScopedNodeId & peerId, CHIP_ERROR error)`
`192`	`191`	`{`
`193`	`192`	`ChipLogError(NotSpecified, "Device Sync failed to connect to " ChipLogFormatX64, ChipLogValueX64(peerId.GetNodeId()));`
`194`	`193`	`MoveToState(State::Idle);`
`195`	`194`	`}`
`196`	`195`
`197`		`-void DeviceSynchronizer::StartDeviceSynchronization(chip::Controller::DeviceController * controller, chip::NodeId nodeId,`
`198`		`- bool deviceIsIcd)`
	`196`	`+void DeviceSynchronizer::StartDeviceSynchronization(Controller::DeviceController * controller, NodeId nodeId, bool deviceIsIcd)`
`199`	`197`	`{`
`200`	`198`	`VerifyOrDie(controller);`
`201`	`199`	`if (mState != State::Idle)`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ CHIP_ERROR AddSynchronizedDevice(const chip_rpc_SynchronizedDevice & data)`
`144`	`144`	`return WaitForResponse(call);`
`145`	`145`	`}`
`146`	`146`
`147`		`-CHIP_ERROR RemoveSynchronizedDevice(chip::NodeId nodeId)`
	`147`	`+CHIP_ERROR RemoveSynchronizedDevice(NodeId nodeId)`
`148`	`148`	`{`
`149`	`149`	`ChipLogProgress(NotSpecified, "RemoveSynchronizedDevice");`
`150`	`150`
`@@ -164,7 +164,7 @@ CHIP_ERROR RemoveSynchronizedDevice(chip::NodeId nodeId)`
`164`	`164`	`return WaitForResponse(call);`
`165`	`165`	`}`
`166`	`166`
`167`		`-CHIP_ERROR ActiveChanged(chip::NodeId nodeId, uint32_t promisedActiveDurationMs)`
	`167`	`+CHIP_ERROR ActiveChanged(NodeId nodeId, uint32_t promisedActiveDurationMs)`
`168`	`168`	`{`
`169`	`169`	`ChipLogProgress(NotSpecified, "ActiveChanged");`
`170`	`170`