Cleanup extra namespace prefix (project-chip#35911)

Author: yufengwangca

examples/chip-tool/commands/pairing/OpenCommissioningWindowCommand.cpp

@@ -49,7 +49,7 @@ CHIP_ERROR OpenCommissioningWindowCommand::RunCommand()
 }
 
 void OpenCommissioningWindowCommand::OnOpenCommissioningWindowResponse(void * context, NodeId remoteId, CHIP_ERROR err,
-                                                                       chip::SetupPayload payload)
+                                                                       SetupPayload payload)
 {
     LogErrorOnFailure(err);
 

examples/chip-tool/commands/pairing/PairingCommand.cpp

@@ -151,7 +151,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())
@@ -289,7 +289,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)
         {
@@ -329,21 +329,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;
@@ -463,13 +463,13 @@ 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.check_in_node     = chip::ScopedNodeId(mICDCheckInNodeId.Value(), nodeId.GetFabricIndex());
+    clientInfo.check_in_node     = ScopedNodeId(mICDCheckInNodeId.Value(), nodeId.GetFabricIndex());
     clientInfo.peer_node         = nodeId;
     clientInfo.monitored_subject = mICDMonitoredSubject.Value();
     clientInfo.start_icd_counter = icdCounter;
@@ -505,15 +505,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(chipTool, "Discovered Device: %s:%u", buf, port);
 
@@ -556,20 +556,19 @@ 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
 {
     // We don't need to set additional failsafe timeout as we don't ask the final user if he wants to continue
-    return chip::Optional<uint16_t>();
+    return Optional<uint16_t>();
 }
 
-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)
 {
     // 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);

examples/chip-tool/commands/pairing/PairingCommand.h

@@ -244,7 +244,7 @@ class PairingCommand : public CHIPCommand,
     const PairingNetworkType mNetworkType;
     const chip::Dnssd::DiscoveryFilterType mFilterType;
     Command::AddressWithInterface mRemoteAddr;
-    NodeId mNodeId;
+    NodeId mNodeId = chip::kUndefinedNodeId;
     chip::Optional<uint16_t> mTimeout;
     chip::Optional<bool> mDiscoverOnce;
     chip::Optional<bool> mUseOnlyOnNetworkDiscovery;
@@ -266,7 +266,7 @@ class PairingCommand : public CHIPCommand,
     TypedComplexArgument<chip::app::DataModel::List<chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::Type>>
         mComplex_DSTOffsets;
 
-    uint16_t mRemotePort;
+    uint16_t mRemotePort = 0;
     // mDiscriminator is only used for some situations, but in those situations
     // it's mandatory.  Track whether we're actually using it; the cases that do
     // will emplace this optional.
@@ -275,15 +275,15 @@ class PairingCommand : public CHIPCommand,
     // it's mandatory.  Track whether we're actually using it; the cases that do
     // will emplace this optional.
     std::optional<uint32_t> mSetupPINCode;
-    uint16_t mIndex;
+    uint16_t mIndex = 0;
     chip::ByteSpan mOperationalDataset;
     chip::ByteSpan mSSID;
     chip::ByteSpan mPassword;
-    char * mOnboardingPayload;
-    uint64_t mDiscoveryFilterCode;
-    char * mDiscoveryFilterInstanceName;
+    char * mOnboardingPayload           = nullptr;
+    uint64_t mDiscoveryFilterCode       = 0;
+    char * mDiscoveryFilterInstanceName = nullptr;
 
-    bool mDeviceIsICD;
+    bool mDeviceIsICD = false;
     uint8_t mRandomGeneratedICDSymmetricKey[chip::Crypto::kAES_CCM128_Key_Length];
 
     // For unpair