[subresource_filter] Replace KMP by std::search.

components/subresource_filter/core/common/test_ruleset_creator.cc

 // Copyright 2016 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 "components/subresource_filter/core/common/test_ruleset_creator.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
@@ skipping 27 matching lines @@
   google::protobuf::io::StringOutputStream output(&ruleset_contents);
   UnindexedRulesetWriter ruleset_writer(&output);
   for (const auto& rule : rules)
     ruleset_writer.AddUrlRule(rule);
   ruleset_writer.Finish();
 
   auto* data = reinterpret_cast<const uint8_t*>(ruleset_contents.data());
   return std::vector<uint8_t>(data, data + ruleset_contents.size());
 }
 
-std::vector<uint8_t> SerializeUnindexedRulesetWithSingleRule(
-    const proto::UrlRule& rule) {
-  return SerializeUnindexedRulesetWithMultipleRules({rule});
-}
-
 std::vector<uint8_t> SerializeIndexedRulesetWithMultipleRules(
     const std::vector<proto::UrlRule>& rules) {
   RulesetIndexer indexer;
   for (const auto& rule : rules)
     EXPECT_TRUE(indexer.AddUrlRule(rule));
   indexer.Finish();
   return std::vector<uint8_t>(indexer.data(), indexer.data() + indexer.size());
 }
 
 }  // namespace
@@ skipping 56 matching lines @@
   DCHECK(test_ruleset_pair);
   proto::UrlRule suffix_rule = CreateSuffixRule(suffix);
   CreateRulesetWithRules({suffix_rule}, test_ruleset_pair);
 }
 
 void TestRulesetCreator::CreateUnindexedRulesetToDisallowURLsWithPathSuffix(
     base::StringPiece suffix,
     TestRuleset* test_unindexed_ruleset) {
   DCHECK(test_unindexed_ruleset);
   proto::UrlRule suffix_rule = CreateSuffixRule(suffix);
-  ASSERT_NO_FATAL_FAILURE(CreateTestRulesetFromContents(
-      SerializeUnindexedRulesetWithSingleRule(suffix_rule),
-      test_unindexed_ruleset));
+  ASSERT_NO_FATAL_FAILURE(
+      CreateUnindexedRulesetWithRules({suffix_rule}, test_unindexed_ruleset));
 }
 
 void TestRulesetCreator::CreateRulesetToDisallowURLsWithManySuffixes(
     base::StringPiece suffix,
     int num_of_suffixes,
     TestRulesetPair* test_ruleset_pair) {
   DCHECK(test_ruleset_pair);
 
   std::vector<proto::UrlRule> rules;
   for (int i = 0; i < num_of_suffixes; ++i) {
     std::string current_suffix =
         suffix.as_string() + '_' + base::IntToString(i);
     rules.push_back(CreateSuffixRule(current_suffix));
   }
   CreateRulesetWithRules(rules, test_ruleset_pair);
 }
 
 void TestRulesetCreator::CreateRulesetWithRules(
     const std::vector<proto::UrlRule>& rules,
     TestRulesetPair* test_ruleset_pair) {
   ASSERT_NO_FATAL_FAILURE(CreateTestRulesetFromContents(
       SerializeUnindexedRulesetWithMultipleRules(rules),
       &test_ruleset_pair->unindexed));
   ASSERT_NO_FATAL_FAILURE(CreateTestRulesetFromContents(
       SerializeIndexedRulesetWithMultipleRules(rules),
       &test_ruleset_pair->indexed));
 }
 
+void TestRulesetCreator::CreateUnindexedRulesetWithRules(
+    const std::vector<proto::UrlRule>& rules,
+    TestRuleset* test_unindexed_ruleset) {
+  ASSERT_NO_FATAL_FAILURE(CreateTestRulesetFromContents(
+      SerializeUnindexedRulesetWithMultipleRules(rules),
+      test_unindexed_ruleset));
+}
+
 void TestRulesetCreator::GetUniqueTemporaryPath(base::FilePath* path) {
   DCHECK(path);
   ASSERT_TRUE(scoped_temp_dir_.IsValid() ||
               scoped_temp_dir_.CreateUniqueTempDir());
   *path = scoped_temp_dir_.GetPath().AppendASCII(
       base::IntToString(next_unique_file_suffix++));
 }
 
 void TestRulesetCreator::CreateTestRulesetFromContents(
     std::vector<uint8_t> ruleset_contents,
     TestRuleset* ruleset) {
   DCHECK(ruleset);
 
   ruleset->contents = std::move(ruleset_contents);
   ASSERT_NO_FATAL_FAILURE(GetUniqueTemporaryPath(&ruleset->path));
   WriteRulesetContents(ruleset->contents, ruleset->path);
 }
 
 }  // namespace testing
 }  // namespace subresource_filter