[base] Replace Contains{Key,Value} with Contains in //device/fido

This change replaces usages of base::ContainsKey() and base::ContainsValue()
with base::Contains() in //device/fido.

Reproduction:
 - sed -i 's/\bbase::ContainsKey\b/base::Contains/g'
 - sed -i 's/\bbase::ContainsValue\b/base::Contains/g'
 - git cl format

This CL was uploaded by git cl split.

R=engedy@chromium.org

Bug: 970209
Change-Id: I00e6c5235e4e4e53429eed3cf3c3ac7d7df62165
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1648171
Auto-Submit: Jan Wilken Dörrie <jdoerrie@chromium.org>
Reviewed-by: Balazs Engedy <engedy@chromium.org>
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#667269}

device/fido/ble/fido_ble_discovery.cc

@@ -39,7 +39,7 @@ void FidoBleDiscovery::OnSetPowered() {
 
   for (BluetoothDevice* device : adapter()->GetDevices()) {
     if (!CheckForExcludedDeviceAndCacheAddress(device) &&
-        base::ContainsKey(device->GetUUIDs(), FidoServiceUUID())) {
+        base::Contains(device->GetUUIDs(), FidoServiceUUID())) {
       const auto& device_address = device->GetAddress();
       VLOG(2) << "FIDO BLE device: " << device_address;
       AddDevice(std::make_unique<FidoBleDevice>(adapter(), device_address));
@@ -65,7 +65,7 @@ void FidoBleDiscovery::OnSetPowered() {
 void FidoBleDiscovery::DeviceAdded(BluetoothAdapter* adapter,
                                    BluetoothDevice* device) {
   if (!CheckForExcludedDeviceAndCacheAddress(device) &&
-      base::ContainsKey(device->GetUUIDs(), FidoServiceUUID())) {
+      base::Contains(device->GetUUIDs(), FidoServiceUUID())) {
     const auto& device_address = device->GetAddress();
     VLOG(2) << "Discovered FIDO BLE device: " << device_address;
     AddDevice(std::make_unique<FidoBleDevice>(adapter, device_address));
@@ -77,7 +77,7 @@ void FidoBleDiscovery::DeviceAdded(BluetoothAdapter* adapter,
 void FidoBleDiscovery::DeviceChanged(BluetoothAdapter* adapter,
                                      BluetoothDevice* device) {
   if (CheckForExcludedDeviceAndCacheAddress(device) ||
-      !base::ContainsKey(device->GetUUIDs(), FidoServiceUUID())) {
+      !base::Contains(device->GetUUIDs(), FidoServiceUUID())) {
     return;
   }
 
@@ -99,7 +99,7 @@ void FidoBleDiscovery::DeviceChanged(BluetoothAdapter* adapter,
 
 void FidoBleDiscovery::DeviceRemoved(BluetoothAdapter* adapter,
                                      BluetoothDevice* device) {
-  if (base::ContainsKey(device->GetUUIDs(), FidoServiceUUID())) {
+  if (base::Contains(device->GetUUIDs(), FidoServiceUUID())) {
     VLOG(2) << "FIDO BLE device removed: " << device->GetAddress();
     auto device_id = FidoBleDevice::GetId(device->GetAddress());
     RemoveDevice(device_id);

device/fido/ble/fido_ble_discovery_base.cc

@@ -60,8 +60,8 @@ void FidoBleDiscoveryBase::SetDiscoverySession(
 
 bool FidoBleDiscoveryBase::IsCableDevice(const BluetoothDevice* device) const {
   const auto& uuid = CableAdvertisementUUID();
-  return base::ContainsKey(device->GetServiceData(), uuid) ||
-         base::ContainsKey(device->GetUUIDs(), uuid);
+  return base::Contains(device->GetServiceData(), uuid) ||
+         base::Contains(device->GetUUIDs(), uuid);
 }
 
 void FidoBleDiscoveryBase::OnGetAdapter(

device/fido/ble/fido_ble_pairing_delegate_unittest.cc

@@ -100,16 +100,16 @@ TEST_F(FidoBlePairingDelegateTest, ChangeStoredDeviceAddress) {
   pairing_delegate()->StoreBlePinCodeForDevice(kTestFidoBleDeviceId,
                                                kTestPinCode);
   EXPECT_TRUE(
-      base::ContainsKey(pairing_delegate_pincode_map(), kTestFidoBleDeviceId));
-  EXPECT_FALSE(base::ContainsKey(pairing_delegate_pincode_map(),
-                                 kTestNewBleDeviceAddress));
+      base::Contains(pairing_delegate_pincode_map(), kTestFidoBleDeviceId));
+  EXPECT_FALSE(
+      base::Contains(pairing_delegate_pincode_map(), kTestNewBleDeviceAddress));
 
   pairing_delegate()->ChangeStoredDeviceAddress(kTestFidoBleDeviceId,
                                                 kTestNewBleDeviceAddress);
   EXPECT_FALSE(
-      base::ContainsKey(pairing_delegate_pincode_map(), kTestFidoBleDeviceId));
-  EXPECT_TRUE(base::ContainsKey(pairing_delegate_pincode_map(),
-                                kTestNewBleDeviceAddress));
+      base::Contains(pairing_delegate_pincode_map(), kTestFidoBleDeviceId));
+  EXPECT_TRUE(
+      base::Contains(pairing_delegate_pincode_map(), kTestNewBleDeviceAddress));
 }
 
 }  // namespace device

device/fido/ble_adapter_manager_unittest.cc

@@ -228,7 +228,7 @@ TEST_F(FidoBleAdapterManagerTest, SuccessfulPairing) {
   const auto& pin_code_map =
       device_pincode_map(ble_pairing_delegate(*adapter_manager));
   EXPECT_EQ(1u, pin_code_map.size());
-  ASSERT_TRUE(base::ContainsKey(pin_code_map, kTestFidoBleAuthenticatorId));
+  ASSERT_TRUE(base::Contains(pin_code_map, kTestFidoBleAuthenticatorId));
   EXPECT_EQ(kTestPinCode,
             pin_code_map.find(kTestFidoBleAuthenticatorId)->second);
 }
@@ -275,7 +275,7 @@ TEST_F(FidoBleAdapterManagerTest, PairingCancelledOnDestruction) {
   const auto& pin_code_map =
       device_pincode_map(ble_pairing_delegate(*adapter_manager));
   EXPECT_EQ(1u, pin_code_map.size());
-  ASSERT_TRUE(base::ContainsKey(pin_code_map, kTestFidoBleAuthenticatorId));
+  ASSERT_TRUE(base::Contains(pin_code_map, kTestFidoBleAuthenticatorId));
   EXPECT_EQ(kTestPinCode,
             pin_code_map.find(kTestFidoBleAuthenticatorId)->second);
 

device/fido/cable/fido_cable_discovery.cc

@@ -306,7 +306,7 @@ void FidoCableDiscovery::ConductEncryptionHandshake(
     base::span<const uint8_t, kSessionPreKeySize> session_pre_key,
     base::span<const uint8_t, 8> nonce) {
   // At most one handshake messages should be exchanged for each Cable device.
-  if (base::ContainsKey(cable_handshake_handlers_, cable_device->GetId())) {
+  if (base::Contains(cable_handshake_handlers_, cable_device->GetId())) {
     FIDO_LOG(DEBUG) << "We've already exchanged a handshake with this device.";
     return;
   }

device/fido/ctap_response_unittest.cc

@@ -580,9 +580,9 @@ TEST(CTAPResponseTest, TestReadGetInfoResponse) {
   ASSERT_TRUE(get_info_response->max_msg_size);
   EXPECT_EQ(*get_info_response->max_msg_size, 1200u);
   EXPECT_TRUE(
-      base::ContainsKey(get_info_response->versions, ProtocolVersion::kCtap2));
+      base::Contains(get_info_response->versions, ProtocolVersion::kCtap2));
   EXPECT_TRUE(
-      base::ContainsKey(get_info_response->versions, ProtocolVersion::kU2f));
+      base::Contains(get_info_response->versions, ProtocolVersion::kU2f));
   EXPECT_TRUE(get_info_response->options.is_platform_device);
   EXPECT_TRUE(get_info_response->options.supports_resident_key);
   EXPECT_TRUE(get_info_response->options.supports_user_presence);

device/fido/device_response_converter.cc

@@ -47,7 +47,7 @@ CtapDeviceResponseCode GetResponseCode(base::span<const uint8_t> buffer) {
     return CtapDeviceResponseCode::kCtap2ErrInvalidCBOR;
 
   auto code = static_cast<CtapDeviceResponseCode>(buffer[0]);
-  return base::ContainsValue(GetCtapResponseCodeList(), code)
+  return base::Contains(GetCtapResponseCodeList(), code)
              ? code
              : CtapDeviceResponseCode::kCtap2ErrInvalidCBOR;
 }

device/fido/fido_device.cc

@@ -59,8 +59,8 @@ void FidoDevice::OnDeviceInfoReceived(
   state_ = FidoDevice::State::kReady;
   base::Optional<AuthenticatorGetInfoResponse> get_info_response =
       response ? ReadCTAPGetInfoResponse(*response) : base::nullopt;
-  if (!get_info_response || !base::ContainsKey(get_info_response->versions,
-                                               ProtocolVersion::kCtap2)) {
+  if (!get_info_response ||
+      !base::Contains(get_info_response->versions, ProtocolVersion::kCtap2)) {
     supported_protocol_ = ProtocolVersion::kU2f;
     FIDO_LOG(DEBUG) << "The device only supports the U2F protocol.";
   } else {

device/fido/fido_request_handler_base.cc

@@ -117,11 +117,10 @@ void FidoRequestHandlerBase::InitDiscoveries(
     discoveries_.push_back(std::move(discovery));
   }
 
-  if (base::ContainsKey(
-          available_transports,
-          FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy) ||
-      base::ContainsKey(available_transports,
-                        FidoTransportProtocol::kBluetoothLowEnergy)) {
+  if (base::Contains(available_transports,
+                     FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy) ||
+      base::Contains(available_transports,
+                     FidoTransportProtocol::kBluetoothLowEnergy)) {
     ++transport_info_callback_count;
     base::SequencedTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
@@ -170,9 +169,8 @@ void FidoRequestHandlerBase::InitDiscoveriesWin(
   // device communication block (only GetAssertionRequestHandler uses
   // caBLE). Otherwise, do not instantiate any other transports.
   base::flat_set<FidoTransportProtocol> other_transports = {};
-  if (base::ContainsKey(
-          available_transports,
-          FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy))
+  if (base::Contains(available_transports,
+                     FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy))
     other_transports = {
         FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy};
 
@@ -266,7 +264,7 @@ void FidoRequestHandlerBase::Start() {
 void FidoRequestHandlerBase::AuthenticatorAdded(
     FidoDiscoveryBase* discovery,
     FidoAuthenticator* authenticator) {
-  DCHECK(!base::ContainsKey(active_authenticators(), authenticator->GetId()));
+  DCHECK(!base::Contains(active_authenticators(), authenticator->GetId()));
   AddAuthenticator(authenticator);
 }
 
@@ -318,7 +316,7 @@ void FidoRequestHandlerBase::AuthenticatorPairingModeChanged(
 void FidoRequestHandlerBase::AddAuthenticator(
     FidoAuthenticator* authenticator) {
   DCHECK(authenticator &&
-         !base::ContainsKey(active_authenticators(), authenticator->GetId()));
+         !base::Contains(active_authenticators(), authenticator->GetId()));
   active_authenticators_.emplace(authenticator->GetId(), authenticator);
 
   // If |observer_| exists, dispatching request to |authenticator| is
@@ -361,8 +359,8 @@ void FidoRequestHandlerBase::SetPlatformAuthenticatorOrMarkUnavailable(
     base::Optional<PlatformAuthenticatorInfo> platform_authenticator_info) {
   DCHECK(!platform_authenticator_);
   if (platform_authenticator_info &&
-      base::ContainsKey(transport_availability_info_.available_transports,
-                        FidoTransportProtocol::kInternal)) {
+      base::Contains(transport_availability_info_.available_transports,
+                     FidoTransportProtocol::kInternal)) {
     DCHECK(platform_authenticator_info->authenticator);
     DCHECK(
         platform_authenticator_info->authenticator->AuthenticatorTransport() &&
@@ -384,7 +382,7 @@ void FidoRequestHandlerBase::SetPlatformAuthenticatorOrMarkUnavailable(
 
 bool FidoRequestHandlerBase::HasAuthenticator(
     const std::string& authenticator_id) const {
-  return base::ContainsKey(active_authenticators_, authenticator_id);
+  return base::Contains(active_authenticators_, authenticator_id);
 }
 
 void FidoRequestHandlerBase::NotifyObserverTransportAvailability() {

device/fido/get_assertion_handler_unittest.cc

@@ -111,27 +111,26 @@ class FidoGetAssertionHandlerTest : public ::testing::Test {
       GetAssertionRequestHandler* request_handler,
       base::flat_set<FidoTransportProtocol> transports) {
     using Transport = FidoTransportProtocol;
-    if (base::ContainsKey(transports, Transport::kUsbHumanInterfaceDevice))
+    if (base::Contains(transports, Transport::kUsbHumanInterfaceDevice))
       discovery()->WaitForCallToStartAndSimulateSuccess();
-    if (base::ContainsKey(transports, Transport::kBluetoothLowEnergy))
+    if (base::Contains(transports, Transport::kBluetoothLowEnergy))
       ble_discovery()->WaitForCallToStartAndSimulateSuccess();
-    if (base::ContainsKey(transports,
-                          Transport::kCloudAssistedBluetoothLowEnergy))
+    if (base::Contains(transports, Transport::kCloudAssistedBluetoothLowEnergy))
       cable_discovery()->WaitForCallToStartAndSimulateSuccess();
-    if (base::ContainsKey(transports, Transport::kNearFieldCommunication))
+    if (base::Contains(transports, Transport::kNearFieldCommunication))
       nfc_discovery()->WaitForCallToStartAndSimulateSuccess();
 
     scoped_task_environment_.FastForwardUntilNoTasksRemain();
     EXPECT_FALSE(get_assertion_callback().was_called());
 
-    if (!base::ContainsKey(transports, Transport::kUsbHumanInterfaceDevice))
+    if (!base::Contains(transports, Transport::kUsbHumanInterfaceDevice))
       EXPECT_FALSE(discovery()->is_start_requested());
-    if (!base::ContainsKey(transports, Transport::kBluetoothLowEnergy))
+    if (!base::Contains(transports, Transport::kBluetoothLowEnergy))
       EXPECT_FALSE(ble_discovery()->is_start_requested());
-    if (!base::ContainsKey(transports,
-                           Transport::kCloudAssistedBluetoothLowEnergy))
+    if (!base::Contains(transports,
+                        Transport::kCloudAssistedBluetoothLowEnergy))
       EXPECT_FALSE(cable_discovery()->is_start_requested());
-    if (!base::ContainsKey(transports, Transport::kNearFieldCommunication))
+    if (!base::Contains(transports, Transport::kNearFieldCommunication))
       EXPECT_FALSE(nfc_discovery()->is_start_requested());
 
     // Even with FidoTransportProtocol::kInternal allowed, unless the platform

device/fido/get_assertion_request_handler.cc

@@ -90,8 +90,8 @@ bool ResponseValid(const FidoAuthenticator& authenticator,
                         return credential.id() ==
                                    response.raw_credential_id() &&
                                (!opt_transport_used ||
-                                base::ContainsKey(credential.transports(),
-                                                  *opt_transport_used));
+                                base::Contains(credential.transports(),
+                                               *opt_transport_used));
                       }))) {
       return false;
     }
@@ -212,9 +212,8 @@ GetAssertionRequestHandler::GetAssertionRequestHandler(
   transport_availability_info().has_empty_allow_list =
       request_.allow_list.empty();
 
-  if (base::ContainsKey(
-          transport_availability_info().available_transports,
-          FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy)) {
+  if (base::Contains(transport_availability_info().available_transports,
+                     FidoTransportProtocol::kCloudAssistedBluetoothLowEnergy)) {
     DCHECK(request_.cable_extension);
     auto discovery =
         fido_discovery_factory_->CreateCable(*request_.cable_extension);

device/fido/get_assertion_task.cc

@@ -22,7 +22,7 @@ bool MayFallbackToU2fWithAppIdExtension(
     const CtapGetAssertionRequest& request) {
   bool ctap2_device_supports_u2f =
       device.device_info() &&
-      base::ContainsKey(device.device_info()->versions, ProtocolVersion::kU2f);
+      base::Contains(device.device_info()->versions, ProtocolVersion::kU2f);
   return request.alternative_application_parameter &&
          ctap2_device_supports_u2f && !request.allow_list.empty();
 }

device/fido/hid/fido_hid_device.cc

@@ -512,8 +512,7 @@ void FidoHidDevice::DiscoverSupportedProtocolAndDeviceInfo(
       "20a0:4287",  // Nitrokey FIDO U2F
   });
 
-  if (base::ContainsKey(kForceU2fCompatibilitySet,
-                        VidPidToString(device_info_))) {
+  if (base::Contains(kForceU2fCompatibilitySet, VidPidToString(device_info_))) {
     supported_protocol_ = ProtocolVersion::kU2f;
     DCHECK(SupportedProtocolIsInitialized());
     std::move(done).Run();

device/fido/hid/fido_hid_packet.cc

@@ -34,7 +34,7 @@ std::unique_ptr<FidoHidInitPacket> FidoHidInitPacket::CreateFromSerializedData(
   channel_id |= serialized[index++] & 0xff;
 
   auto command = static_cast<FidoHidDeviceCommand>(serialized[index++] & 0x7f);
-  if (!base::ContainsValue(GetFidoHidDeviceCommandList(), command))
+  if (!base::Contains(GetFidoHidDeviceCommandList(), command))
     return nullptr;
 
   uint16_t payload_size = serialized[index++] << 8;

device/fido/mac/get_assertion_operation.mm

@@ -160,8 +160,8 @@ AuthenticatorGetAssertionResponse response(std::move(authenticator_data),
   for (const auto& credential_descriptor : request.allow_list) {
     if (credential_descriptor.credential_type() == CredentialType::kPublicKey &&
         (credential_descriptor.transports().empty() ||
-         base::ContainsKey(credential_descriptor.transports(),
-                           FidoTransportProtocol::kInternal))) {
+         base::Contains(credential_descriptor.transports(),
+                        FidoTransportProtocol::kInternal))) {
       allowed_credential_ids.insert(credential_descriptor.id());
     }
   }

device/fido/mac/keychain.mm

@@ -140,7 +140,7 @@ static API_AVAILABLE(macos(10.12.2)) Keychain* g_keychain_instance_override =
                                        CFDataGetBytePtr(application_label) +
                                            CFDataGetLength(application_label));
     if (!allowed_credential_ids.empty() &&
-        !base::ContainsKey(allowed_credential_ids, credential_id)) {
+        !base::Contains(allowed_credential_ids, credential_id)) {
       continue;
     }
     base::ScopedCFTypeRef<SecKeyRef> private_key(key,

device/fido/make_credential_handler_unittest.cc

@@ -95,21 +95,21 @@ class FidoMakeCredentialHandlerTest : public ::testing::Test {
       MakeCredentialRequestHandler* request_handler,
       base::flat_set<FidoTransportProtocol> transports) {
     using Transport = FidoTransportProtocol;
-    if (base::ContainsKey(transports, Transport::kUsbHumanInterfaceDevice))
+    if (base::Contains(transports, Transport::kUsbHumanInterfaceDevice))
       discovery()->WaitForCallToStartAndSimulateSuccess();
-    if (base::ContainsKey(transports, Transport::kBluetoothLowEnergy))
+    if (base::Contains(transports, Transport::kBluetoothLowEnergy))
       ble_discovery()->WaitForCallToStartAndSimulateSuccess();
-    if (base::ContainsKey(transports, Transport::kNearFieldCommunication))
+    if (base::Contains(transports, Transport::kNearFieldCommunication))
       nfc_discovery()->WaitForCallToStartAndSimulateSuccess();
 
     scoped_task_environment_.FastForwardUntilNoTasksRemain();
     EXPECT_FALSE(callback().was_called());
 
-    if (!base::ContainsKey(transports, Transport::kUsbHumanInterfaceDevice))
+    if (!base::Contains(transports, Transport::kUsbHumanInterfaceDevice))
       EXPECT_FALSE(discovery()->is_start_requested());
-    if (!base::ContainsKey(transports, Transport::kBluetoothLowEnergy))
+    if (!base::Contains(transports, Transport::kBluetoothLowEnergy))
       EXPECT_FALSE(ble_discovery()->is_start_requested());
-    if (!base::ContainsKey(transports, Transport::kNearFieldCommunication))
+    if (!base::Contains(transports, Transport::kNearFieldCommunication))
       EXPECT_FALSE(nfc_discovery()->is_start_requested());
 
     EXPECT_THAT(

device/fido/make_credential_task.cc

@@ -36,7 +36,7 @@ bool ShouldUseU2fBecauseCtapRequiresClientPin(
       device->device_info()->options.client_pin_availability ==
       AuthenticatorSupportedOptions::ClientPinAvailability::kSupportedAndPinSet;
   bool supports_u2f =
-      base::ContainsKey(device->device_info()->versions, ProtocolVersion::kU2f);
+      base::Contains(device->device_info()->versions, ProtocolVersion::kU2f);
   return client_pin_set && supports_u2f;
 }
 

device/fido/virtual_ctap2_device.cc

@@ -1301,7 +1301,7 @@ CtapDeviceResponseCode VirtualCtap2Device::OnCredentialManagement(
       }
       const std::vector<uint8_t>& credential_id =
           credential_id_it->second.GetBytestring();
-      if (!base::ContainsKey(mutable_state()->registrations, credential_id)) {
+      if (!base::Contains(mutable_state()->registrations, credential_id)) {
         return CtapDeviceResponseCode::kCtap2ErrNoCredentials;
       }
       mutable_state()->registrations.erase(credential_id);
@@ -1413,7 +1413,7 @@ void VirtualCtap2Device::InitPendingRPs() {
     DCHECK(!registration.second.is_u2f);
     DCHECK(registration.second.user);
     DCHECK(registration.second.rp);
-    if (!base::ContainsKey(rp_ids, registration.second.rp->id)) {
+    if (!base::Contains(rp_ids, registration.second.rp->id)) {
       mutable_state()->pending_rps.push_back(*registration.second.rp);
     }
   }

device/fido/win/type_conversions.cc

@@ -222,7 +222,7 @@ CtapDeviceResponseCode WinErrorNameToCtapDeviceResponseCode(
           {STRING16_LITERAL("UnknownError"),
            CtapDeviceResponseCode::kCtap2ErrOther},
       });
-  return base::ContainsKey(kResponseCodeMap, error_name)
+  return base::Contains(kResponseCodeMap, error_name)
              ? kResponseCodeMap[error_name]
              : CtapDeviceResponseCode::kCtap2ErrOther;
 }