Change std::find() to use base:: functions: remoting/

Simplifies code slightly.

Bug: 1368812
Change-Id: I695709fd2cdb516ed59f58473c8083fc6593d9e9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3929570
Reviewed-by: Yuwei Huang <yuweih@chromium.org>
Commit-Queue: Yuwei Huang <yuweih@chromium.org>
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1053624}

remoting/base/capabilities.cc

@@ -4,9 +4,9 @@
 
 #include "remoting/base/capabilities.h"
 
-#include <algorithm>
 #include <vector>
 
+#include "base/containers/contains.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
@@ -17,8 +17,7 @@ namespace remoting {
 bool HasCapability(const std::string& capabilities, const std::string& key) {
   std::vector<base::StringPiece> caps = base::SplitStringPiece(
       capabilities, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  return std::find(caps.begin(), caps.end(), base::StringPiece(key)) !=
-         caps.end();
+  return base::Contains(caps, base::StringPiece(key));
 }
 
 std::string IntersectCapabilities(const std::string& client_capabilities,

remoting/host/client_session_unittest.cc

@@ -6,13 +6,13 @@
 
 #include <stdint.h>
 
-#include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/containers/contains.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/raw_ptr.h"
 #include "base/run_loop.h"
@@ -78,8 +78,7 @@ MATCHER_P(IncludesCapabilities, expected_capabilities, "") {
                         base::SPLIT_WANT_NONEMPTY);
 
   for (const auto& word : words_expected) {
-    if (std::find(words_args.begin(), words_args.end(), word) ==
-        words_args.end()) {
+    if (!base::Contains(words_args, word)) {
       return false;
     }
   }

remoting/host/linux/unicode_to_keysym_unittest.cc

@@ -7,8 +7,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <algorithm>
-
+#include "base/ranges/algorithm.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
@@ -40,8 +39,7 @@ TEST(GetKeySymsForUnicode, Map) {
 
     std::vector<uint32_t> expected(
         kTests[i].expected_keysyms,
-        std::find(
-            kTests[i].expected_keysyms, kTests[i].expected_keysyms + 4, 0));
+        base::ranges::find(kTests[i].expected_keysyms, 0u));
     EXPECT_EQ(expected, keysyms);
   }
 }

remoting/protocol/negotiating_authenticator_unittest.cc

@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/memory/raw_ptr.h"
+#include "base/ranges/algorithm.h"
 #include "base/run_loop.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/rsa_key_pair.h"
@@ -88,14 +89,14 @@ class NegotiatingAuthenticatorTest : public AuthenticatorTestBase {
 
   void DisableMethodOnClient(NegotiatingAuthenticatorBase::Method method) {
     auto* methods = &(client_as_negotiating_authenticator_->methods_);
-    auto iter = std::find(methods->begin(), methods->end(), method);
+    auto iter = base::ranges::find(*methods, method);
     ASSERT_TRUE(iter != methods->end());
     methods->erase(iter);
   }
 
   void DisableMethodOnHost(NegotiatingAuthenticatorBase::Method method) {
     auto* methods = &(host_as_negotiating_authenticator_->methods_);
-    auto iter = std::find(methods->begin(), methods->end(), method);
+    auto iter = base::ranges::find(*methods, method);
     ASSERT_TRUE(iter != methods->end());
     methods->erase(iter);
   }

remoting/protocol/negotiating_client_authenticator.cc

@@ -4,14 +4,14 @@
 
 #include "remoting/protocol/negotiating_client_authenticator.h"
 
-#include <algorithm>
 #include <memory>
 #include <sstream>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/check_op.h"
+#include "base/containers/contains.h"
 #include "base/memory/ptr_util.h"
 #include "base/notreached.h"
 #include "base/strings/string_split.h"
@@ -62,7 +62,7 @@ void NegotiatingClientAuthenticator::ProcessMessage(
     // The host must pick a method that is valid and supported by the client,
     // and it must not change methods after it has picked one.
     if (method_set_by_host_ || method == Method::INVALID ||
-        std::find(methods_.begin(), methods_.end(), method) == methods_.end()) {
+        !base::Contains(methods_, method)) {
       state_ = REJECTED;
       rejection_reason_ = RejectionReason::PROTOCOL_ERROR;
       std::move(resume_callback).Run();
@@ -184,9 +184,7 @@ void NegotiatingClientAuthenticator::CreateAuthenticatorForCurrentMethod(
 }
 
 void NegotiatingClientAuthenticator::CreatePreferredAuthenticator() {
-  if (is_paired() &&
-      std::find(methods_.begin(), methods_.end(), Method::PAIRED_SPAKE2_P224) !=
-          methods_.end()) {
+  if (is_paired() && base::Contains(methods_, Method::PAIRED_SPAKE2_P224)) {
     PairingClientAuthenticator* pairing_authenticator =
         new PairingClientAuthenticator(
             config_, base::BindRepeating(&V2Authenticator::CreateForClient));

remoting/protocol/negotiating_host_authenticator.cc

@@ -4,14 +4,14 @@
 
 #include "remoting/protocol/negotiating_host_authenticator.h"
 
-#include <algorithm>
 #include <memory>
 #include <sstream>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/check_op.h"
+#include "base/containers/contains.h"
 #include "base/notreached.h"
 #include "base/strings/string_split.h"
 #include "remoting/base/rsa_key_pair.h"
@@ -103,8 +103,7 @@ void NegotiatingHostAuthenticator::ProcessMessage(
   // If the client did not specify a preferred auth method, or specified an
   // unknown or unsupported method, then select the first known method from
   // the supported-methods attribute.
-  if (method == Method::INVALID ||
-      std::find(methods_.begin(), methods_.end(), method) == methods_.end()) {
+  if (method == Method::INVALID || !base::Contains(methods_, method)) {
     method = Method::INVALID;
 
     std::string supported_methods_attr =
@@ -125,8 +124,7 @@ void NegotiatingHostAuthenticator::ProcessMessage(
                            base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
       Method list_value = ParseMethodString(method_str);
       if (list_value != Method::INVALID &&
-          std::find(methods_.begin(), methods_.end(), list_value) !=
-              methods_.end()) {
+          base::Contains(methods_, list_value)) {
         // Found common method.
         method = list_value;
         break;

remoting/protocol/session_config.cc

@@ -4,10 +4,10 @@
 
 #include "remoting/protocol/session_config.h"
 
-#include <algorithm>
 #include <vector>
 
 #include "base/check.h"
+#include "base/containers/contains.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/notreached.h"
@@ -16,19 +16,14 @@ namespace remoting::protocol {
 
 namespace {
 
-bool IsChannelConfigSupported(const std::list<ChannelConfig>& list,
-                              const ChannelConfig& value) {
-  return std::find(list.begin(), list.end(), value) != list.end();
-}
-
 bool SelectCommonChannelConfig(const std::list<ChannelConfig>& host_configs,
                                const std::list<ChannelConfig>& client_configs,
                                ChannelConfig* config) {
   // Usually each of these lists will contain just a few elements, so iterating
   // over all of them is not a problem.
   std::list<ChannelConfig>::const_iterator it;
   for (it = client_configs.begin(); it != client_configs.end(); ++it) {
-    if (IsChannelConfigSupported(host_configs, *it)) {
+    if (base::Contains(host_configs, *it)) {
       *config = *it;
       return true;
     }
@@ -207,11 +202,10 @@ bool CandidateSessionConfig::IsSupported(const SessionConfig& config) const {
   switch (config.protocol()) {
     case SessionConfig::Protocol::ICE:
       return ice_supported() &&
-             IsChannelConfigSupported(control_configs_,
-                                      config.control_config()) &&
-             IsChannelConfigSupported(event_configs_, config.event_config()) &&
-             IsChannelConfigSupported(video_configs_, config.video_config()) &&
-             IsChannelConfigSupported(audio_configs_, config.audio_config());
+             base::Contains(control_configs_, config.control_config()) &&
+             base::Contains(event_configs_, config.event_config()) &&
+             base::Contains(video_configs_, config.video_config()) &&
+             base::Contains(audio_configs_, config.audio_config());
 
     case SessionConfig::Protocol::WEBRTC:
       return webrtc_supported();