Fix small behavioral differences I recently introduced.

These spots used to compare base::ranges::search(...) against an .end()
iterator. std::ranges::search() returns a subrange instead, so I was
checking if it was empty; however, this isn't the same result if the
input range is empty.

Note that we generally cannot use std::ranges::includes() to express
this, because it requires the input ranges be sorted.

All these changes were introduced in the past week or so by me, during
std::ranges conversions.

Bug: 386918226
Change-Id: I1948fda67466d855ce1a7d81fe394949a20dc1b9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6180717
Owners-Override: Lei Zhang <thestig@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Commit-Queue: Peter Kasting <pkasting@chromium.org>
Code-Coverage: findit-for-me@appspot.gserviceaccount.com <findit-for-me@appspot.gserviceaccount.com>
Cr-Commit-Position: refs/heads/main@{#1407561}

chrome/browser/browser_switcher/browser_switcher_sitelist.cc

@@ -177,7 +177,7 @@ class DefaultModeRule : public Rule {
 
     // Compare hosts and ports, case-insensitive.
     auto result = StringFindInsensitiveASCII(url.host_and_port(), pattern);
-    return !result.empty();
+    return result.begin() != url.host_and_port().end();
   }
 
   bool IsValid() const override { return true; }

components/autofill/core/browser/form_parsing/credit_card_field_parser.cc

@@ -349,9 +349,9 @@ bool CreditCardFieldParser::LikelyCardYearSelectField(
                            std::u16string_view year_needle) {
       return option.find(year_needle) != std::u16string_view::npos;
     };
-    return !std::ranges::search(field->options(), year_needles, is_substring,
-                                option_projection)
-                .empty();
+    return std::ranges::search(field->options(), year_needles, is_substring,
+                               option_projection)
+               .begin() != field->options().end();
   };
   return OptionsContain(years_to_check_2_digit, &SelectOption::value) ||
          OptionsContain(years_to_check_2_digit, &SelectOption::text);

components/web_package/web_bundle_parser_unittest.cc

@@ -248,8 +248,9 @@ void CheckIfSignatureStackEntryIsValid(
   EXPECT_EQ(entry->signature_info->get_ed25519()->public_key, public_key);
 
   // The attributes should contain the public key.
-  EXPECT_FALSE(
-      std::ranges::search(entry->attributes_cbor, public_key.bytes()).empty());
+  EXPECT_NE(
+      std::ranges::search(entry->attributes_cbor, public_key.bytes()).begin(),
+      entry->attributes_cbor.end());
 }
 
 }  // namespace

net/dns/dns_response_result_extractor_unittest.cc

@@ -353,7 +353,7 @@ TEST_F(DnsResponseResultExtractorTest, ExtractsMinATtl) {
 }
 
 MATCHER_P(ContainsContiguousElements, elements, "") {
-  return !std::ranges::search(arg, elements).empty();
+  return std::ranges::search(arg, elements).begin() != arg.end();
 }
 
 TEST_F(DnsResponseResultExtractorTest, ExtractsTxtResponses) {

net/dns/host_resolver_manager_unittest.cc

@@ -8983,8 +8983,8 @@ TEST_F(HostResolverManagerDnsTest, TxtQuery) {
                   "foo1", "foo2", "foo3", "bar1", "bar2")));
   const std::vector<std::string>* results =
       response.request()->GetTextResults();
-  EXPECT_FALSE(std::ranges::search(*results, foo_records).empty());
-  EXPECT_FALSE(std::ranges::search(*results, bar_records).empty());
+  EXPECT_NE(results->end(), std::ranges::search(*results, foo_records).begin());
+  EXPECT_NE(results->end(), std::ranges::search(*results, bar_records).begin());
 
   // Expect result to be cached.
   EXPECT_EQ(resolve_context_->host_cache()->size(), 1u);
@@ -8997,8 +8997,8 @@ TEST_F(HostResolverManagerDnsTest, TxtQuery) {
               testing::Pointee(testing::UnorderedElementsAre(
                   "foo1", "foo2", "foo3", "bar1", "bar2")));
   results = cached_response.request()->GetTextResults();
-  EXPECT_FALSE(std::ranges::search(*results, foo_records).empty());
-  EXPECT_FALSE(std::ranges::search(*results, bar_records).empty());
+  EXPECT_NE(results->end(), std::ranges::search(*results, foo_records).begin());
+  EXPECT_NE(results->end(), std::ranges::search(*results, bar_records).begin());
 }
 
 TEST_F(HostResolverManagerDnsTest, TxtQueryRejectsIpLiteral) {
@@ -9451,8 +9451,8 @@ TEST_F(HostResolverManagerDnsTest, TxtDnsQuery) {
                   "foo1", "foo2", "foo3", "bar1", "bar2")));
   const std::vector<std::string>* results =
       response.request()->GetTextResults();
-  EXPECT_FALSE(std::ranges::search(*results, foo_records).empty());
-  EXPECT_FALSE(std::ranges::search(*results, bar_records).empty());
+  EXPECT_NE(results->end(), std::ranges::search(*results, foo_records).begin());
+  EXPECT_NE(results->end(), std::ranges::search(*results, bar_records).begin());
 
   // Expect result to be cached.
   EXPECT_EQ(resolve_context_->host_cache()->size(), 1u);
@@ -9465,8 +9465,8 @@ TEST_F(HostResolverManagerDnsTest, TxtDnsQuery) {
               testing::Pointee(testing::UnorderedElementsAre(
                   "foo1", "foo2", "foo3", "bar1", "bar2")));
   results = cached_response.request()->GetTextResults();
-  EXPECT_FALSE(std::ranges::search(*results, foo_records).empty());
-  EXPECT_FALSE(std::ranges::search(*results, bar_records).empty());
+  EXPECT_NE(results->end(), std::ranges::search(*results, foo_records).begin());
+  EXPECT_NE(results->end(), std::ranges::search(*results, bar_records).begin());
 }
 
 TEST_F(HostResolverManagerDnsTest, PtrQuery) {

net/url_request/url_request_unittest.cc

@@ -340,9 +340,9 @@ class PriorityMonitoringURLRequestJob : public URLRequestTestJob {
 
 // Do a case-insensitive search through |haystack| for |needle|.
 bool ContainsString(const std::string& haystack, const char* needle) {
-  return !std::ranges::search(haystack, std::string_view(needle),
-                              base::CaseInsensitiveCompareASCII<char>())
-              .empty();
+  return std::ranges::search(haystack, std::string_view(needle),
+                             base::CaseInsensitiveCompareASCII<char>())
+             .begin() != haystack.end();
 }
 
 std::unique_ptr<UploadDataStream> CreateSimpleUploadData(

third_party/blink/renderer/core/loader/resource/multipart_image_resource_parser.cc

@@ -168,7 +168,7 @@ bool MultipartImageResourceParser::ParseHeaders() {
 wtf_size_t MultipartImageResourceParser::FindBoundary(const Vector<char>& data,
                                                       Vector<char>* boundary) {
   auto found_boundary = std::ranges::search(data, *boundary);
-  if (found_boundary.empty()) {
+  if (found_boundary.begin() == data.end()) {
     return kNotFound;
   }
 

ui/gfx/codec/png_codec_unittest.cc

@@ -1057,9 +1057,12 @@ TEST_P(PNGCodecTest, EncodeWithComment) {
   const uint8_t kExpected3[] =
       "\x00\x00\x00\x18tEXthave some\x00spaces in both\x8d\x69\x34\x2d";
 
-  EXPECT_FALSE(std::ranges::search(encoded.value(), kExpected1).empty());
-  EXPECT_FALSE(std::ranges::search(encoded.value(), kExpected2).empty());
-  EXPECT_FALSE(std::ranges::search(encoded.value(), kExpected3).empty());
+  EXPECT_NE(std::ranges::search(encoded.value(), kExpected1).begin(),
+            encoded.value().end());
+  EXPECT_NE(std::ranges::search(encoded.value(), kExpected2).begin(),
+            encoded.value().end());
+  EXPECT_NE(std::ranges::search(encoded.value(), kExpected3).begin(),
+            encoded.value().end());
 }
 
 TEST_P(PNGCodecTest, EncodeDecodeWithVaryingCompressionLevels) {