Drop |languages| from {Format,Elide}Url* and IDNToUnicode

components/omnibox/browser/scored_history_match_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 "components/omnibox/browser/scored_history_match.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 117 matching lines @@
   // to calculate last visit time when building a row.
   base::Time now = base::Time::NowFromSystemTime();
 
   history::URLRow row_a(MakeURLRow("http://fedcba", "abcd bcd", 3, 30, 1));
   RowWordStarts word_starts_a;
   PopulateWordStarts(row_a, &word_starts_a);
   WordStarts one_word_no_offset(1, 0u);
   VisitInfoVector visits_a = CreateVisitInfoVector(3, 30, now);
   // Mark one visit as typed.
   visits_a[0].second = ui::PAGE_TRANSITION_TYPED;
-  ScoredHistoryMatch scored_a(row_a, visits_a, std::string(),
-                              ASCIIToUTF16("abc"), Make1Term("abc"),
-                              one_word_no_offset, word_starts_a, false, nullptr,
-                              now);
+  ScoredHistoryMatch scored_a(row_a, visits_a, ASCIIToUTF16("abc"),
+                              Make1Term("abc"), one_word_no_offset,
+                              word_starts_a, false, nullptr, now);
 
   // Test scores based on visit_count.
   history::URLRow row_b(MakeURLRow("http://abcdef", "abcd bcd", 10, 30, 1));
   RowWordStarts word_starts_b;
   PopulateWordStarts(row_b, &word_starts_b);
   VisitInfoVector visits_b = CreateVisitInfoVector(10, 30, now);
   visits_b[0].second = ui::PAGE_TRANSITION_TYPED;
-  ScoredHistoryMatch scored_b(row_b, visits_b, std::string(),
-                              ASCIIToUTF16("abc"), Make1Term("abc"),
-                              one_word_no_offset, word_starts_b, false, nullptr,
-                              now);
+  ScoredHistoryMatch scored_b(row_b, visits_b, ASCIIToUTF16("abc"),
+                              Make1Term("abc"), one_word_no_offset,
+                              word_starts_b, false, nullptr, now);
   EXPECT_GT(scored_b.raw_score, scored_a.raw_score);
 
   // Test scores based on last_visit.
   history::URLRow row_c(MakeURLRow("http://abcdef", "abcd bcd", 3, 10, 1));
   RowWordStarts word_starts_c;
   PopulateWordStarts(row_c, &word_starts_c);
   VisitInfoVector visits_c = CreateVisitInfoVector(3, 10, now);
   visits_c[0].second = ui::PAGE_TRANSITION_TYPED;
-  ScoredHistoryMatch scored_c(row_c, visits_c, std::string(),
-                              ASCIIToUTF16("abc"), Make1Term("abc"),
-                              one_word_no_offset, word_starts_c, false, nullptr,
-                              now);
+  ScoredHistoryMatch scored_c(row_c, visits_c, ASCIIToUTF16("abc"),
+                              Make1Term("abc"), one_word_no_offset,
+                              word_starts_c, false, nullptr, now);
   EXPECT_GT(scored_c.raw_score, scored_a.raw_score);
 
   // Test scores based on typed_count.
   history::URLRow row_d(MakeURLRow("http://abcdef", "abcd bcd", 3, 30, 3));
   RowWordStarts word_starts_d;
   PopulateWordStarts(row_d, &word_starts_d);
   VisitInfoVector visits_d = CreateVisitInfoVector(3, 30, now);
   visits_d[0].second = ui::PAGE_TRANSITION_TYPED;
   visits_d[1].second = ui::PAGE_TRANSITION_TYPED;
   visits_d[2].second = ui::PAGE_TRANSITION_TYPED;
-  ScoredHistoryMatch scored_d(row_d, visits_d, std::string(),
-                              ASCIIToUTF16("abc"), Make1Term("abc"),
-                              one_word_no_offset, word_starts_d, false, nullptr,
-                              now);
+  ScoredHistoryMatch scored_d(row_d, visits_d, ASCIIToUTF16("abc"),
+                              Make1Term("abc"), one_word_no_offset,
+                              word_starts_d, false, nullptr, now);
   EXPECT_GT(scored_d.raw_score, scored_a.raw_score);
 
   // Test scores based on a terms appearing multiple times.
   history::URLRow row_e(MakeURLRow(
       "http://csi.csi.csi/csi_csi",
       "CSI Guide to CSI Las Vegas, CSI New York, CSI Provo", 3, 30, 3));
   RowWordStarts word_starts_e;
   PopulateWordStarts(row_e, &word_starts_e);
   const VisitInfoVector visits_e = visits_d;
-  ScoredHistoryMatch scored_e(row_e, visits_e, std::string(),
-                              ASCIIToUTF16("csi"), Make1Term("csi"),
-                              one_word_no_offset, word_starts_e, false, nullptr,
-                              now);
+  ScoredHistoryMatch scored_e(row_e, visits_e, ASCIIToUTF16("csi"),
+                              Make1Term("csi"), one_word_no_offset,
+                              word_starts_e, false, nullptr, now);
   EXPECT_LT(scored_e.raw_score, 1400);
 
   // Test that a result with only a mid-term match (i.e., not at a word
   // boundary) scores 0.
-  ScoredHistoryMatch scored_f(row_a, visits_a, std::string(),
-                              ASCIIToUTF16("cd"), Make1Term("cd"),
-                              one_word_no_offset, word_starts_a, false, nullptr,
-                              now);
+  ScoredHistoryMatch scored_f(row_a, visits_a, ASCIIToUTF16("cd"),
+                              Make1Term("cd"), one_word_no_offset,
+                              word_starts_a, false, nullptr, now);
   EXPECT_EQ(scored_f.raw_score, 0);
 }
 
 TEST_F(ScoredHistoryMatchTest, ScoringBookmarks) {
   // We use NowFromSystemTime() because MakeURLRow uses the same function
   // to calculate last visit time when building a row.
   base::Time now = base::Time::NowFromSystemTime();
 
   std::string url_string("http://fedcba");
   const GURL url(url_string);
   history::URLRow row(MakeURLRow(url_string.c_str(), "abcd bcd", 8, 3, 1));
   RowWordStarts word_starts;
   PopulateWordStarts(row, &word_starts);
   WordStarts one_word_no_offset(1, 0u);
   VisitInfoVector visits = CreateVisitInfoVector(8, 3, now);
-  ScoredHistoryMatch scored(row, visits, std::string(), ASCIIToUTF16("abc"),
+  ScoredHistoryMatch scored(row, visits, ASCIIToUTF16("abc"),
                             Make1Term("abc"), one_word_no_offset, word_starts,
                             false, nullptr, now);
   // Now check that if URL is bookmarked then its score increases.
   base::AutoReset<int> reset(&ScoredHistoryMatch::bookmark_value_, 5);
   ScoredHistoryMatch scored_with_bookmark(
-      row, visits, std::string(), ASCIIToUTF16("abc"), Make1Term("abc"),
+      row, visits, ASCIIToUTF16("abc"), Make1Term("abc"),
       one_word_no_offset, word_starts, true, nullptr, now);
   EXPECT_GT(scored_with_bookmark.raw_score, scored.raw_score);
 }
 
 TEST_F(ScoredHistoryMatchTest, ScoringTLD) {
   // We use NowFromSystemTime() because MakeURLRow uses the same function
   // to calculate last visit time when building a row.
   base::Time now = base::Time::NowFromSystemTime();
 
   // By default the URL should not be returned for a query that includes "com".
   std::string url_string("http://fedcba.com/");
   const GURL url(url_string);
   history::URLRow row(MakeURLRow(url_string.c_str(), "", 8, 3, 1));
   RowWordStarts word_starts;
   PopulateWordStarts(row, &word_starts);
   WordStarts two_words_no_offsets(2, 0u);
   VisitInfoVector visits = CreateVisitInfoVector(8, 3, now);
-  ScoredHistoryMatch scored(row, visits, std::string(), ASCIIToUTF16("fed com"),
+  ScoredHistoryMatch scored(row, visits, ASCIIToUTF16("fed com"),
                             Make2Terms("fed", "com"), two_words_no_offsets,
                             word_starts, false, nullptr, now);
   EXPECT_EQ(0, scored.raw_score);
 
   // Now allow credit for the match in the TLD.
   base::AutoReset<bool> reset(&ScoredHistoryMatch::allow_tld_matches_, true);
-  ScoredHistoryMatch scored_with_tld(
-      row, visits, std::string(), ASCIIToUTF16("fed com"),
+  ScoredHistoryMatch scored_with_tld(row, visits, ASCIIToUTF16("fed com"),
       Make2Terms("fed", "com"), two_words_no_offsets, word_starts, false,
       nullptr, now);
   EXPECT_GT(scored_with_tld.raw_score, 0);
 }
 
 TEST_F(ScoredHistoryMatchTest, ScoringScheme) {
   // We use NowFromSystemTime() because MakeURLRow uses the same function
   // to calculate last visit time when building a row.
   base::Time now = base::Time::NowFromSystemTime();
 
   // By default the URL should not be returned for a query that includes "http".
   std::string url_string("http://fedcba/");
   const GURL url(url_string);
   history::URLRow row(MakeURLRow(url_string.c_str(), "", 8, 3, 1));
   RowWordStarts word_starts;
   PopulateWordStarts(row, &word_starts);
   WordStarts two_words_no_offsets(2, 0u);
   VisitInfoVector visits = CreateVisitInfoVector(8, 3, now);
-  ScoredHistoryMatch scored(row, visits, std::string(),
-                            ASCIIToUTF16("fed http"), Make2Terms("fed", "http"),
-                            two_words_no_offsets, word_starts, false, nullptr,
-                            now);
+  ScoredHistoryMatch scored(row, visits, ASCIIToUTF16("fed http"),
+                            Make2Terms("fed", "http"), two_words_no_offsets,
+                            word_starts, false, nullptr, now);
   EXPECT_EQ(0, scored.raw_score);
 
   // Now allow credit for the match in the scheme.
   base::AutoReset<bool> reset(&ScoredHistoryMatch::allow_scheme_matches_, true);
-  ScoredHistoryMatch scored_with_scheme(
-      row, visits, std::string(), ASCIIToUTF16("fed http"),
+  ScoredHistoryMatch scored_with_scheme(row, visits, ASCIIToUTF16("fed http"),
       Make2Terms("fed", "http"), two_words_no_offsets, word_starts, false,
       nullptr, now);
   EXPECT_GT(scored_with_scheme.raw_score, 0);
 }
 
 TEST_F(ScoredHistoryMatchTest, CullSearchResults) {
   scoped_ptr<TemplateURLService> template_url_service =
       make_scoped_ptr(new TemplateURLService(
           nullptr, make_scoped_ptr(new SearchTermsData), nullptr,
           scoped_ptr<TemplateURLServiceClient>(), nullptr, nullptr,
           base::Closure()));
 
   // We use NowFromSystemTime() because MakeURLRow uses the same function
   // to calculate last visit time when building a row.
   base::Time now = base::Time::NowFromSystemTime();
 
   // Pretend we've visited a search engine query URL, but that it's not
   // associated with the default search engine.
   history::URLRow row(MakeURLRow(
       "http://testsearch.com/thequery", "Test Search Engine", 3, 30, 1));
   RowWordStarts word_starts;
   PopulateWordStarts(row, &word_starts);
   WordStarts one_word_no_offset(1, 0u);
   VisitInfoVector visits = CreateVisitInfoVector(3, 30, now);
   // Mark one visit as typed.
   visits[0].second = ui::PAGE_TRANSITION_TYPED;
 
   // This page should be returned if it's associated with the default search
   // engine.
-  ScoredHistoryMatch scored_a(row, visits, std::string(),
-                              ASCIIToUTF16("thequery"), Make1Term("thequery"),
-                              one_word_no_offset, word_starts, false,
-                              template_url_service.get(), now);
+  ScoredHistoryMatch scored_a(row, visits, ASCIIToUTF16("thequery"),
+                              Make1Term("thequery"), one_word_no_offset,
+                              word_starts, false, template_url_service.get(),
+                              now);
   EXPECT_GT(scored_a.raw_score, 0);
 
   // Likewise, it should be returned when typing the engine URL.
-  ScoredHistoryMatch scored_b(row, visits, std::string(),
-                              ASCIIToUTF16("testsearch"),
+  ScoredHistoryMatch scored_b(row, visits, ASCIIToUTF16("testsearch"),
                               Make1Term("testsearch"), one_word_no_offset,
                               word_starts, false, template_url_service.get(),
                               now);
   EXPECT_GT(scored_b.raw_score, 0);
 
   // Set up a default search engine associated with this URL.
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("TestEngine"));
   data.SetKeyword(ASCIIToUTF16("TestEngine"));
   data.SetURL("http://testsearch.com/{searchTerms}");
   TemplateURL* template_url = new TemplateURL(data);
   template_url_service->Add(template_url);
   template_url_service->SetUserSelectedDefaultSearchProvider(template_url);
   template_url_service->Load();
 
   // The search results page should not be returned when typing a query.
-  ScoredHistoryMatch scored_c(row, visits, std::string(),
-                              ASCIIToUTF16("thequery"), Make1Term("thequery"),
-                              one_word_no_offset, word_starts, false,
-                              template_url_service.get(), now);
+  ScoredHistoryMatch scored_c(row, visits, ASCIIToUTF16("thequery"),
+                              Make1Term("thequery"), one_word_no_offset,
+                              word_starts, false, template_url_service.get(),
+                              now);
   EXPECT_EQ(0, scored_c.raw_score);
 
   // Likewise, it shouldn't be returned when typing the engine URL.
-  ScoredHistoryMatch scored_d(row, visits, std::string(),
-                              ASCIIToUTF16("testsearch"),
+  ScoredHistoryMatch scored_d(row, visits, ASCIIToUTF16("testsearch"),
                               Make1Term("testsearch"), one_word_no_offset,
                               word_starts, false, template_url_service.get(),
                               now);
   EXPECT_EQ(0, scored_d.raw_score);
 }
 
 TEST_F(ScoredHistoryMatchTest, Inlining) {
   // We use NowFromSystemTime() because MakeURLRow uses the same function
   // to calculate last visit time when building a row.
   base::Time now = base::Time::NowFromSystemTime();
   RowWordStarts word_starts;
   WordStarts one_word_no_offset(1, 0u);
   VisitInfoVector visits;
 
   {
     history::URLRow row(
         MakeURLRow("http://www.google.com", "abcdef", 3, 30, 1));
     PopulateWordStarts(row, &word_starts);
-    ScoredHistoryMatch scored_a(row, visits, std::string(), ASCIIToUTF16("g"),
+    ScoredHistoryMatch scored_a(row, visits, ASCIIToUTF16("g"),
                                 Make1Term("g"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_a.match_in_scheme);
-    ScoredHistoryMatch scored_b(row, visits, std::string(), ASCIIToUTF16("w"),
+    ScoredHistoryMatch scored_b(row, visits, ASCIIToUTF16("w"),
                                 Make1Term("w"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_b.match_in_scheme);
-    ScoredHistoryMatch scored_c(row, visits, std::string(), ASCIIToUTF16("h"),
+    ScoredHistoryMatch scored_c(row, visits, ASCIIToUTF16("h"),
                                 Make1Term("h"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_TRUE(scored_c.match_in_scheme);
-    ScoredHistoryMatch scored_d(row, visits, std::string(), ASCIIToUTF16("o"),
+    ScoredHistoryMatch scored_d(row, visits, ASCIIToUTF16("o"),
                                 Make1Term("o"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_d.match_in_scheme);
   }
 
   {
     history::URLRow row(MakeURLRow("http://teams.foo.com", "abcdef", 3, 30, 1));
     PopulateWordStarts(row, &word_starts);
-    ScoredHistoryMatch scored_a(row, visits, std::string(), ASCIIToUTF16("t"),
+    ScoredHistoryMatch scored_a(row, visits, ASCIIToUTF16("t"),
                                 Make1Term("t"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_a.match_in_scheme);
-    ScoredHistoryMatch scored_b(row, visits, std::string(), ASCIIToUTF16("f"),
+    ScoredHistoryMatch scored_b(row, visits, ASCIIToUTF16("f"),
                                 Make1Term("f"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_b.match_in_scheme);
-    ScoredHistoryMatch scored_c(row, visits, std::string(), ASCIIToUTF16("o"),
+    ScoredHistoryMatch scored_c(row, visits, ASCIIToUTF16("o"),
                                 Make1Term("o"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_c.match_in_scheme);
   }
 
   {
     history::URLRow row(
         MakeURLRow("https://www.testing.com", "abcdef", 3, 30, 1));
     PopulateWordStarts(row, &word_starts);
-    ScoredHistoryMatch scored_a(row, visits, std::string(), ASCIIToUTF16("t"),
+    ScoredHistoryMatch scored_a(row, visits, ASCIIToUTF16("t"),
                                 Make1Term("t"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_a.match_in_scheme);
-    ScoredHistoryMatch scored_b(row, visits, std::string(), ASCIIToUTF16("h"),
+    ScoredHistoryMatch scored_b(row, visits, ASCIIToUTF16("h"),
                                 Make1Term("h"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_TRUE(scored_b.match_in_scheme);
-    ScoredHistoryMatch scored_c(row, visits, std::string(), ASCIIToUTF16("w"),
+    ScoredHistoryMatch scored_c(row, visits, ASCIIToUTF16("w"),
                                 Make1Term("w"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_c.match_in_scheme);
   }
 
   {
     history::URLRow row(
         MakeURLRow("http://www.xn--1lq90ic7f1rc.cn/xnblah", "abcd", 3, 30, 1));
     PopulateWordStarts(row, &word_starts);
-    ScoredHistoryMatch scored_a(row, visits, "zh-CN", ASCIIToUTF16("x"),
+    ScoredHistoryMatch scored_a(row, visits, ASCIIToUTF16("x"),
                                 Make1Term("x"), one_word_no_offset, word_starts,
                                 false, nullptr, now);
     EXPECT_FALSE(scored_a.match_in_scheme);
-    ScoredHistoryMatch scored_b(row, visits, "zh-CN", ASCIIToUTF16("xn"),
+    ScoredHistoryMatch scored_b(row, visits, ASCIIToUTF16("xn"),
                                 Make1Term("xn"), one_word_no_offset,
                                 word_starts, false, nullptr, now);
     EXPECT_FALSE(scored_b.match_in_scheme);
-    ScoredHistoryMatch scored_c(row, visits, "zh-CN", ASCIIToUTF16("w"),
+    ScoredHistoryMatch scored_c(row, visits, ASCIIToUTF16("w"),
                                 Make1Term("w"), one_word_no_offset,
                                 word_starts, false, nullptr, now);
     EXPECT_FALSE(scored_c.match_in_scheme);
   }
 }
 
 TEST_F(ScoredHistoryMatchTest, GetTopicalityScoreTrailingSlash) {
   const float hostname = GetTopicalityScoreOfTermAgainstURLAndTitle(
       ASCIIToUTF16("def"), ASCIIToUTF16("http://abc.def.com/"),
       ASCIIToUTF16("Non-Matching Title"));
@@ skipping 231 matching lines @@
 
   EXPECT_TRUE(
       ScoredHistoryMatch::GetHQPBucketsFromString(buckets_str, &hqp_buckets));
   EXPECT_THAT(hqp_buckets, ElementsAre(Pair(0.0, 400), Pair(1.5, 600),
                                        Pair(12.0, 1300), Pair(20.0, 1399)));
   // invalid string.
   buckets_str = "0.0,400,1.5,600";
   EXPECT_FALSE(
       ScoredHistoryMatch::GetHQPBucketsFromString(buckets_str, &hqp_buckets));
 }