Use ContainsValue() instead of std::find() in net/

net/http/http_security_headers_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
-#include <algorithm>
 
 #include "base/base64.h"
+#include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "crypto/sha2.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_security_headers.h"
 #include "net/http/http_util.h"
 #include "net/http/transport_security_state.h"
 #include "net/ssl/ssl_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 667 matching lines @@
   EXPECT_TRUE(state.GetStaticDomainState(domain, &new_static_sts_state,
                                          &new_static_pkp_state));
   EXPECT_EQ(saved_hashes, new_static_pkp_state.spki_hashes);
 
   // Expect the dynamic state to reflect the header.
   TransportSecurityState::PKPState dynamic_pkp_state;
   EXPECT_TRUE(state.GetDynamicPKPState(domain, &dynamic_pkp_state));
   EXPECT_EQ(2UL, dynamic_pkp_state.spki_hashes.size());
   EXPECT_EQ(report_uri, dynamic_pkp_state.report_uri);
 
-  HashValueVector::const_iterator hash =
-      std::find(dynamic_pkp_state.spki_hashes.begin(),
-                dynamic_pkp_state.spki_hashes.end(), good_hash);
-  EXPECT_NE(dynamic_pkp_state.spki_hashes.end(), hash);
+  EXPECT_TRUE(base::ContainsValue(dynamic_pkp_state.spki_hashes, good_hash));
 
-  hash = std::find(dynamic_pkp_state.spki_hashes.begin(),
-                   dynamic_pkp_state.spki_hashes.end(), backup_hash);
-  EXPECT_NE(dynamic_pkp_state.spki_hashes.end(), hash);
+  EXPECT_TRUE(base::ContainsValue(dynamic_pkp_state.spki_hashes, backup_hash));
 
   // Expect the overall state to reflect the header, too.
   EXPECT_TRUE(state.HasPublicKeyPins(domain));
   HashValueVector hashes;
   hashes.push_back(good_hash);
   std::string failure_log;
   const bool is_issued_by_known_root = true;
   HostPortPair domain_port(domain, 443);
   EXPECT_EQ(TransportSecurityState::PKPStatus::OK,
             state.CheckPublicKeyPins(
                 domain_port, is_issued_by_known_root, hashes, nullptr, nullptr,
                 TransportSecurityState::DISABLE_PIN_REPORTS, &failure_log));
 
   TransportSecurityState::PKPState new_dynamic_pkp_state;
   EXPECT_TRUE(state.GetDynamicPKPState(domain, &new_dynamic_pkp_state));
   EXPECT_EQ(2UL, new_dynamic_pkp_state.spki_hashes.size());
   EXPECT_EQ(report_uri, new_dynamic_pkp_state.report_uri);
 
-  hash = std::find(new_dynamic_pkp_state.spki_hashes.begin(),
-                   new_dynamic_pkp_state.spki_hashes.end(), good_hash);
-  EXPECT_NE(new_dynamic_pkp_state.spki_hashes.end(), hash);
+  EXPECT_TRUE(
+      base::ContainsValue(new_dynamic_pkp_state.spki_hashes, good_hash));
 
-  hash = std::find(new_dynamic_pkp_state.spki_hashes.begin(),
-                   new_dynamic_pkp_state.spki_hashes.end(), backup_hash);
-  EXPECT_NE(new_dynamic_pkp_state.spki_hashes.end(), hash);
+  EXPECT_TRUE(
+      base::ContainsValue(new_dynamic_pkp_state.spki_hashes, backup_hash));
 }
 
 TEST_F(HttpSecurityHeadersTest, UpdateDynamicPKPMaxAge0) {
   TransportSecurityState state;
   TransportSecurityState::STSState static_sts_state;
   TransportSecurityState::PKPState static_pkp_state;
 
   // docs.google.com has preloaded pins.
   std::string domain = "docs.google.com";
   state.enable_static_pins_ = true;
@@ skipping 454 matching lines @@
   EXPECT_TRUE(ParseExpectCTHeader(
       "  max-age=999999999999999999999999999999999999999999999  ,"
       "  enforce   ",
       &max_age, &enforce, &report_uri));
   EXPECT_EQ(base::TimeDelta::FromSeconds(kMaxExpectCTAgeSecs), max_age);
   EXPECT_TRUE(enforce);
   EXPECT_TRUE(report_uri.is_empty());
 }
 
 }  // namespace net