[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 test1 {
 #include "net/base/registry_controlled_domains/effective_tld_names_unittest1-inc.cc"
 }
 namespace test3 {
@@ skipping 14 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());

[Ryan Sleevi, 2017/03/06 17:20:04]

Is it worth documenting why this is reversed?

+    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::vector<char>* sequence,
                                        std::vector<std::string>* language) {
   int result = lookup.GetResultForCurrentSequence();
   if (result != kDafsaNotFound) {
-    std::string line(sequence->begin(), sequence->end());
+    std::string line(sequence->rbegin(), sequence->rend());

[Ryan Sleevi, 2017/03/06 17:20:04]

Similarly

     line += base::StringPrintf(", %d", result);
     language->emplace_back(std::move(line));
   }
   // 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);
@@ skipping 155 matching lines @@
 
   std::vector<std::string> expected_language = {
       "ia, 0", "jb, 4", "kaa, 0", "lbb, 4", "maaaa, 0", "nbbbb, 0",
   };
 
   EXPECT_EQ(expected_language, language);
 }
 
 }  // namespace
 }  // namespace net