[3 of 4] Speedup GetRegistryLengthImpl() by seeding the DAFSA in reverse

net/base/lookup_string_in_fixed_set_unittest.cc

 // Copyright 2015 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 "net/base/lookup_string_in_fixed_set.h"
 
-#include <string.h>
-
 #include <algorithm>
 #include <limits>
 #include <ostream>
 #include <utility>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 namespace effective_tld_names {
 #include "net/base/registry_controlled_domains/effective_tld_names-inc.cc"
 }
 namespace test1 {
@@ skipping 17 matching lines @@
   int value;
 };
 
 void PrintTo(const Expectation& expectation, std::ostream* os) {
   *os << "{\"" << expectation.key << "\", " << expectation.value << "}";
 }
 
 class LookupStringInFixedSetTest : public testing::TestWithParam<Expectation> {
  protected:
   template <size_t N>
-  int LookupInGraph(const unsigned char(&graph)[N], const char* key) {
-    return LookupStringInFixedSet(graph, N, key, strlen(key));
+  int LookupInGraph(const unsigned char (&graph)[N], base::StringPiece key) {
+    std::string rev_key(key.rbegin(), key.rend());
+    return LookupStringInFixedSet(graph, N, rev_key.data(), rev_key.length());
   }
 };
 
 class Dafsa1Test : public LookupStringInFixedSetTest {};
 
 TEST_P(Dafsa1Test, BasicTest) {
   const Expectation& param = GetParam();
   EXPECT_EQ(param.value, LookupInGraph(test1::kDafsa, param.key));
 }
 
 const Expectation kBasicTestCases[] = {
     {"", -1},      {"j", -1},          {"jp", 0}, {"jjp", -1}, {"jpp", -1},
     {"bar.jp", 2}, {"pref.bar.jp", 1}, {"c", 2},  {"b.c", 1},  {"priv.no", 4},
 };
 
 // Helper function for EnumerateDafsaLanaguage.
 void RecursivelyEnumerateDafsaLanguage(
     const FixedSetIncrementalLookup& lookup,
     std::string* sequence,
     std::vector<std::pair<std::string, int>>* language) {
   int result = lookup.GetResultForCurrentSequence();
   if (result != kDafsaNotFound) {
-    language->emplace_back(std::string(sequence->begin(), sequence->end()),
+    language->emplace_back(std::string(sequence->rbegin(), sequence->rend()),
                            result);
   }
   // Try appending each char value.
   for (char c = std::numeric_limits<char>::min();; ++c) {
     FixedSetIncrementalLookup continued_lookup = lookup;
     if (continued_lookup.Advance(c)) {
       sequence->push_back(c);
       size_t saved_language_size = language->size();
       RecursivelyEnumerateDafsaLanguage(continued_lookup, sequence, language);
       CHECK_LT(saved_language_size, language->size())
@@ skipping 155 matching lines @@
 
   // |regenerated_gperf_text| should match the body of the .gperf file exactly.
   EXPECT_EQ(actual_gperf_text, regenerated_gperf_text);
 
   // Sanity check to prevent trivial success.
   EXPECT_GT(actual_gperf_text.length(), 30000U);
 }
 
 }  // namespace
 }  // namespace net