Omnibox: Make the Controller Reorder Matches for Inlining

chrome/browser/autocomplete/history_url_provider_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 "chrome/browser/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 114 matching lines @@
   {"http://typedhost/untypedpath", "Intranet untyped", 1, 0},
 
   {"http://x.com/one", "Internet", 2, 2},
   {"http://x.com/two", "Internet two", 1, 1},
   {"http://x.com/three", "Internet three", 2, 2},
 };
 
 class HistoryURLProviderTest : public testing::Test,
                                public AutocompleteProviderListener {
  public:
+  struct UrlAndLegalDefault {
+    std::string url;
+    bool allowed_to_be_default_match;
+  };
+
   HistoryURLProviderTest()
       : sort_matches_(false) {
     HistoryQuickProvider::set_disabled(true);
   }
 
   virtual ~HistoryURLProviderTest() {
     HistoryQuickProvider::set_disabled(false);
   }
 
   // AutocompleteProviderListener:
@@ skipping 16 matching lines @@
 
   // Fills test data into the history system.
   void FillData();
 
   // Runs an autocomplete query on |text| and checks to see that the returned
   // results' destination URLs match those provided.  Also allows checking
   // that the input type was identified correctly.
   void RunTest(const string16 text,
                const string16& desired_tld,
                bool prevent_inline_autocomplete,
-               const std::string* expected_urls,
+               const UrlAndLegalDefault* expected_urls,
                size_t num_results,
                AutocompleteInput::Type* identified_input_type);
 
   // A version of the above without the final |type| output parameter.
   void RunTest(const string16 text,
                const string16& desired_tld,
                bool prevent_inline_autocomplete,
-               const std::string* expected_urls,
+               const UrlAndLegalDefault* expected_urls,
                size_t num_results) {
     AutocompleteInput::Type type;
     return RunTest(text, desired_tld, prevent_inline_autocomplete,
                    expected_urls, num_results, &type);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   ACMatches matches_;
   scoped_ptr<TestingProfile> profile_;
   HistoryService* history_service_;
@@ skipping 60 matching lines @@
       GURL("http://p/"), UTF8ToUTF16("p"), 0, 0,
       Time::Now() -
       TimeDelta::FromDays(history::kLowQualityMatchAgeLimitInDays - 1),
       false, history::SOURCE_BROWSED);
 }
 
 void HistoryURLProviderTest::RunTest(
     const string16 text,
     const string16& desired_tld,
     bool prevent_inline_autocomplete,
-    const std::string* expected_urls,
+    const UrlAndLegalDefault* expected_urls,
     size_t num_results,
     AutocompleteInput::Type* identified_input_type) {
   AutocompleteInput input(text, string16::npos, desired_tld, GURL(),
                           AutocompleteInput::INVALID_SPEC,
                           prevent_inline_autocomplete, false, true,
                           AutocompleteInput::ALL_MATCHES);
   *identified_input_type = input.type();
   autocomplete_->Start(input, false);
   if (!autocomplete_->done())
     base::MessageLoop::current()->Run();
 
   matches_ = autocomplete_->matches();
   if (sort_matches_) {
     for (ACMatches::iterator i = matches_.begin(); i != matches_.end(); ++i)
       i->ComputeStrippedDestinationURL(profile_.get());
     std::sort(matches_.begin(), matches_.end(),
               &AutocompleteMatch::DestinationSortFunc);
     matches_.erase(std::unique(matches_.begin(), matches_.end(),
                                &AutocompleteMatch::DestinationsEqual),
                    matches_.end());
     std::sort(matches_.begin(), matches_.end(),
               &AutocompleteMatch::MoreRelevant);
   }
   ASSERT_EQ(num_results, matches_.size()) << "Input text: " << text
                                           << "\nTLD: \"" << desired_tld << "\"";
-  for (size_t i = 0; i < num_results; ++i)
-    EXPECT_EQ(expected_urls[i], matches_[i].destination_url.spec());
+  for (size_t i = 0; i < num_results; ++i) {
+    EXPECT_EQ(expected_urls[i].url, matches_[i].destination_url.spec());
+    EXPECT_EQ(expected_urls[i].allowed_to_be_default_match,
+              matches_[i].allowed_to_be_default_match);
+  }
 }
 
 TEST_F(HistoryURLProviderTest, PromoteShorterURLs) {
   // Test that hosts get synthesized below popular pages.
-  const std::string expected_nonsynth[] = {
-    "http://slashdot.org/favorite_page.html",
-    "http://slashdot.org/",
+  const UrlAndLegalDefault expected_nonsynth[] = {
+    { "http://slashdot.org/favorite_page.html", false },
+    { "http://slashdot.org/", false }
   };
   RunTest(ASCIIToUTF16("slash"), string16(), true, expected_nonsynth,
           arraysize(expected_nonsynth));
 
   // Test that hosts get synthesized above less popular pages.
-  const std::string expected_synth[] = {
-    "http://kerneltrap.org/",
-    "http://kerneltrap.org/not_very_popular.html",
+  const UrlAndLegalDefault expected_synth[] = {
+    { "http://kerneltrap.org/", false },
+    { "http://kerneltrap.org/not_very_popular.html", false }
   };
   RunTest(ASCIIToUTF16("kernel"), string16(), true, expected_synth,
           arraysize(expected_synth));
 
   // Test that unpopular pages are ignored completely.
   RunTest(ASCIIToUTF16("fresh"), string16(), true, NULL, 0);
 
   // Test that if we create or promote shorter suggestions that would not
   // normally be inline autocompletable, we make them inline autocompletable if
   // the original suggestion (that we replaced as "top") was inline
   // autocompletable.
-  const std::string expected_synthesisa[] = {
-    "http://synthesisatest.com/",
-    "http://synthesisatest.com/foo/",
+  const UrlAndLegalDefault expected_synthesisa[] = {
+    { "http://synthesisatest.com/", true },
+    { "http://synthesisatest.com/foo/", true }
   };
   RunTest(ASCIIToUTF16("synthesisa"), string16(), false, expected_synthesisa,
           arraysize(expected_synthesisa));
   EXPECT_LT(matches_.front().relevance, 1200);
-  const std::string expected_synthesisb[] = {
-    "http://synthesisbtest.com/foo/",
-    "http://synthesisbtest.com/foo/bar.html",
+  const UrlAndLegalDefault expected_synthesisb[] = {
+    { "http://synthesisbtest.com/foo/", true },
+    { "http://synthesisbtest.com/foo/bar.html", true }
   };
   RunTest(ASCIIToUTF16("synthesisb"), string16(), false, expected_synthesisb,
           arraysize(expected_synthesisb));
   EXPECT_GE(matches_.front().relevance, 1410);
 
   // Test that if we have a synthesized host that matches a suggestion, they
   // get combined into one.
-  const std::string expected_combine[] = {
-    "http://news.google.com/",
-    "http://news.google.com/?ned=us&topic=n",
+  const UrlAndLegalDefault expected_combine[] = {
+    { "http://news.google.com/", false },
+    { "http://news.google.com/?ned=us&topic=n", false },
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("news"), string16(), true,
       expected_combine, arraysize(expected_combine)));
   // The title should also have gotten set properly on the host for the
   // synthesized one, since it was also in the results.
   EXPECT_EQ(ASCIIToUTF16("Google News"), matches_.front().description);
 
   // Test that short URL matching works correctly as the user types more
   // (several tests):
   // The entry for foo.com is the best of all five foo.com* entries.
-  const std::string short_1[] = {
-    "http://foo.com/",
-    "http://foo.com/dir/another/again/myfile.html",
-    "http://foo.com/dir/",
+  const UrlAndLegalDefault short_1[] = {
+    { "http://foo.com/", false },
+    { "http://foo.com/dir/another/again/myfile.html", false },
+    { "http://foo.com/dir/", false }
   };
   RunTest(ASCIIToUTF16("foo"), string16(), true, short_1, arraysize(short_1));
 
   // When the user types the whole host, make sure we don't get two results for
   // it.
-  const std::string short_2[] = {
-    "http://foo.com/",
-    "http://foo.com/dir/another/again/myfile.html",
-    "http://foo.com/dir/",
-    "http://foo.com/dir/another/",
+  const UrlAndLegalDefault short_2[] = {
+    { "http://foo.com/", true },
+    { "http://foo.com/dir/another/again/myfile.html", false },
+    { "http://foo.com/dir/", false },
+    { "http://foo.com/dir/another/", false }
   };
   RunTest(ASCIIToUTF16("foo.com"), string16(), true, short_2,
           arraysize(short_2));
   RunTest(ASCIIToUTF16("foo.com/"), string16(), true, short_2,
           arraysize(short_2));
 
   // The filename is the second best of the foo.com* entries, but there is a
   // shorter URL that's "good enough".  The host doesn't match the user input
   // and so should not appear.
-  const std::string short_3[] = {
-    "http://foo.com/d",
-    "http://foo.com/dir/another/",
-    "http://foo.com/dir/another/again/myfile.html",
-    "http://foo.com/dir/",
+  const UrlAndLegalDefault short_3[] = {
+    { "http://foo.com/d", true },
+    { "http://foo.com/dir/another/", false },
+    { "http://foo.com/dir/another/again/myfile.html", false },
+    { "http://foo.com/dir/", false }
   };
   RunTest(ASCIIToUTF16("foo.com/d"), string16(), true, short_3,
           arraysize(short_3));
 
   // We shouldn't promote shorter URLs than the best if they're not good
   // enough.
-  const std::string short_4[] = {
-    "http://foo.com/dir/another/a",
-    "http://foo.com/dir/another/again/myfile.html",
-    "http://foo.com/dir/another/again/",
+  const UrlAndLegalDefault short_4[] = {
+    { "http://foo.com/dir/another/a", true },
+    { "http://foo.com/dir/another/again/myfile.html", false },
+    { "http://foo.com/dir/another/again/", false }
   };
   RunTest(ASCIIToUTF16("foo.com/dir/another/a"), string16(), true, short_4,
           arraysize(short_4));
 
   // Exact matches should always be best no matter how much more another match
   // has been typed.
-  const std::string short_5a[] = {
-    "http://gooey/",
-    "http://www.google.com/",
-    "http://go/",
+  const UrlAndLegalDefault short_5a[] = {
+    { "http://gooey/", true },
+    { "http://www.google.com/", true },
+    { "http://go/", true }
   };
-  const std::string short_5b[] = {
-    "http://go/",
-    "http://gooey/",
-    "http://www.google.com/",
+  const UrlAndLegalDefault short_5b[] = {
+    { "http://go/", true },
+    { "http://gooey/", true },
+    { "http://www.google.com/", true }
   };
   RunTest(ASCIIToUTF16("g"), string16(), false, short_5a, arraysize(short_5a));
   RunTest(ASCIIToUTF16("go"), string16(), false, short_5b, arraysize(short_5b));
 }
 
 TEST_F(HistoryURLProviderTest, CullRedirects) {
   // URLs we will be using, plus the visit counts they will initially get
   // (the redirect set below will also increment the visit counts). We want
   // the results to be in A,B,C order. Note also that our visit counts are
   // all high enough so that domain synthesizing won't get triggered.
@@ skipping 20 matching lines @@
   redirects_to_a.push_back(GURL(test_cases[2].url));
   redirects_to_a.push_back(GURL(test_cases[0].url));
   history_service_->AddPage(GURL(test_cases[0].url), base::Time::Now(),
       NULL, 0, GURL(), redirects_to_a, content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, true);
 
   // Because all the results are part of a redirect chain with other results,
   // all but the first one (A) should be culled. We should get the default
   // "what you typed" result, plus this one.
   const string16 typing(ASCIIToUTF16("http://redirects/"));
-  const std::string expected_results[] = {
-    UTF16ToUTF8(typing),
-    test_cases[0].url,
+  const UrlAndLegalDefault expected_results[] = {
+    { UTF16ToUTF8(typing), true },
+    { test_cases[0].url, false }
   };
   RunTest(typing, string16(), true, expected_results,
           arraysize(expected_results));
 }
 
 TEST_F(HistoryURLProviderTest, WhatYouTyped) {
   // Make sure we suggest a What You Typed match at the right times.
   RunTest(ASCIIToUTF16("wytmatch"), string16(), false, NULL, 0);
   RunTest(ASCIIToUTF16("wytmatch foo bar"), string16(), false, NULL, 0);
   RunTest(ASCIIToUTF16("wytmatch+foo+bar"), string16(), false, NULL, 0);
   RunTest(ASCIIToUTF16("wytmatch+foo+bar.com"), string16(), false, NULL, 0);
 
-  const std::string results_1[] = {"http://www.wytmatch.com/"};
+  const UrlAndLegalDefault results_1[] = {
+    { "http://www.wytmatch.com/", true }
+  };
   RunTest(ASCIIToUTF16("wytmatch"), ASCIIToUTF16("com"), false, results_1,
           arraysize(results_1));
 
-  const std::string results_2[] = {"http://wytmatch%20foo%20bar/"};
+  const UrlAndLegalDefault results_2[] = {
+    { "http://wytmatch%20foo%20bar/", true }
+  };
   RunTest(ASCIIToUTF16("http://wytmatch foo bar"), string16(), false, results_2,
           arraysize(results_2));
 
-  const std::string results_3[] = {"https://wytmatch%20foo%20bar/"};
+  const UrlAndLegalDefault results_3[] = {
+    { "https://wytmatch%20foo%20bar/", true }
+  };
   RunTest(ASCIIToUTF16("https://wytmatch foo bar"), string16(), false,
           results_3, arraysize(results_3));
 }
 
 TEST_F(HistoryURLProviderTest, Fixup) {
   // Test for various past crashes we've had.
   RunTest(ASCIIToUTF16("\\"), string16(), false, NULL, 0);
   RunTest(ASCIIToUTF16("#"), string16(), false, NULL, 0);
   RunTest(ASCIIToUTF16("%20"), string16(), false, NULL, 0);
-  const std::string fixup_crash[] = {"http://%EF%BD%A5@s/"};
+  const UrlAndLegalDefault fixup_crash[] = {
+    { "http://%EF%BD%A5@s/", true }
+  };
   RunTest(WideToUTF16(L"\uff65@s"), string16(), false, fixup_crash,
           arraysize(fixup_crash));
   RunTest(WideToUTF16(L"\u2015\u2015@ \uff7c"), string16(), false, NULL, 0);
 
   // Fixing up "file:" should result in an inline autocomplete offset of just
   // after "file:", not just after "file://".
   const string16 input_1(ASCIIToUTF16("file:"));
-  const std::string fixup_1[] = {"file:///C:/foo.txt"};
+  const UrlAndLegalDefault fixup_1[] = {
+    { "file:///C:/foo.txt", true }
+  };
   ASSERT_NO_FATAL_FAILURE(RunTest(input_1, string16(), false, fixup_1,
                                   arraysize(fixup_1)));
   EXPECT_EQ(ASCIIToUTF16("///C:/foo.txt"),
             matches_.front().inline_autocompletion);
 
   // Fixing up "http:/" should result in an inline autocomplete offset of just
   // after "http:/", not just after "http:".
   const string16 input_2(ASCIIToUTF16("http:/"));
-  const std::string fixup_2[] = {
-    "http://bogussite.com/a",
-    "http://bogussite.com/b",
-    "http://bogussite.com/c",
+  const UrlAndLegalDefault fixup_2[] = {
+    { "http://bogussite.com/a", true },
+    { "http://bogussite.com/b", true },
+    { "http://bogussite.com/c", true }
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(input_2, string16(), false, fixup_2,
                                   arraysize(fixup_2)));
   EXPECT_EQ(ASCIIToUTF16("/bogussite.com/a"),
             matches_.front().inline_autocompletion);
 
   // Adding a TLD to a small number like "56" should result in "www.56.com"
   // rather than "0.0.0.56.com".
-  const std::string fixup_3[] = {"http://www.56.com/"};
+  const UrlAndLegalDefault fixup_3[] = {
+    { "http://www.56.com/", true }
+  };
   RunTest(ASCIIToUTF16("56"), ASCIIToUTF16("com"), true, fixup_3,
           arraysize(fixup_3));
 
   // An input looks like a IP address like "127.0.0.1" should result in
   // "http://127.0.0.1/".
-  const std::string fixup_4[] = {"http://127.0.0.1/"};
+  const UrlAndLegalDefault fixup_4[] = {
+    { "http://127.0.0.1/", true }
+  };
   RunTest(ASCIIToUTF16("127.0.0.1"), string16(), false, fixup_4,
           arraysize(fixup_4));
 
   // An number "17173" should result in "http://www.17173.com/" in db.
-  const std::string fixup_5[] = {"http://www.17173.com/"};
+  const UrlAndLegalDefault fixup_5[] = {
+    { "http://www.17173.com/", true }
+  };
   RunTest(ASCIIToUTF16("17173"), string16(), false, fixup_5,
           arraysize(fixup_5));
 }
 
 // Make sure the results for the input 'p' don't change between the first and
 // second passes.
 TEST_F(HistoryURLProviderTest, EmptyVisits) {
   // Wait for history to create the in memory DB.
   profile_->BlockUntilHistoryProcessesPendingRequests();
 
@@ skipping 15 matching lines @@
   EXPECT_TRUE(autocomplete_->done());
   matches_ = autocomplete_->matches();
   ASSERT_GT(matches_.size(), 0u);
   EXPECT_EQ(GURL("http://pandora.com/"), matches_[0].destination_url);
   EXPECT_EQ(pandora_relevance, matches_[0].relevance);
 }
 
 TEST_F(HistoryURLProviderTestNoDB, NavigateWithoutDB) {
   // Ensure that we will still produce matches for navigation when there is no
   // database.
-  std::string navigation_1[] = {"http://test.com/"};
+  UrlAndLegalDefault navigation_1[] = {
+    { "http://test.com/", true }
+  };
   RunTest(ASCIIToUTF16("test.com"), string16(), false, navigation_1,
           arraysize(navigation_1));
 
-  std::string navigation_2[] = {"http://slash/"};
+  UrlAndLegalDefault navigation_2[] = {
+    { "http://slash/", true }
+  };
   RunTest(ASCIIToUTF16("slash"), string16(), false, navigation_2,
           arraysize(navigation_2));
 
   RunTest(ASCIIToUTF16("this is a query"), string16(), false, NULL, 0);
 }
 
 TEST_F(HistoryURLProviderTest, DontAutocompleteOnTrailingWhitespace) {
   AutocompleteInput input(ASCIIToUTF16("slash "), string16::npos, string16(),
                           GURL(), AutocompleteInput::INVALID_SPEC, false, false,
                           true, AutocompleteInput::ALL_MATCHES);
   autocomplete_->Start(input, false);
   if (!autocomplete_->done())
     base::MessageLoop::current()->Run();
 
   // None of the matches should attempt to autocomplete.
   matches_ = autocomplete_->matches();
-  for (size_t i = 0; i < matches_.size(); ++i)
+  for (size_t i = 0; i < matches_.size(); ++i) {
     EXPECT_TRUE(matches_[i].inline_autocompletion.empty());
+    EXPECT_FALSE(matches_[i].allowed_to_be_default_match);
+  }
 }
 
 TEST_F(HistoryURLProviderTest, TreatEmailsAsSearches) {
   // Visiting foo.com should not make this string be treated as a navigation.
   // That means the result should be scored around 1200 ("what you typed")
   // and not 1400+.
-  const std::string expected[] = {"http://user@foo.com/"};
+  const UrlAndLegalDefault expected[] = {
+    { "http://user@foo.com/", true }
+  };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("user@foo.com"), string16(),
                                   false, expected, arraysize(expected)));
   EXPECT_LE(1200, matches_[0].relevance);
   EXPECT_LT(matches_[0].relevance, 1210);
 }
 
 TEST_F(HistoryURLProviderTest, IntranetURLsWithPaths) {
   struct TestCase {
     const char* input;
     int relevance;
   } test_cases[] = {
     { "fooey", 0 },
     { "fooey/", 1200 },     // 1200 for URL would still navigate by default.
     { "fooey/a", 1200 },    // 1200 for UNKNOWN would not.
     { "fooey/a b", 1200 },  // Also UNKNOWN.
     { "gooey", 1410 },
     { "gooey/", 1410 },
     { "gooey/a", 1400 },
     { "gooey/a b", 1400 },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     SCOPED_TRACE(test_cases[i].input);
     if (test_cases[i].relevance == 0) {
       RunTest(ASCIIToUTF16(test_cases[i].input), string16(), false, NULL, 0);
     } else {
-      const std::string output[] = {
-        URLFixerUpper::FixupURL(test_cases[i].input, std::string()).spec()
+      const UrlAndLegalDefault output[] = {
+        { URLFixerUpper::FixupURL(test_cases[i].input, std::string()).spec(),
+          true }
       };
       ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16(test_cases[i].input),
                               string16(), false, output, arraysize(output)));
       // Actual relevance should be at least what test_cases expects and
       // and no more than 10 more.
       EXPECT_LE(test_cases[i].relevance, matches_[0].relevance);
       EXPECT_LT(matches_[0].relevance, test_cases[i].relevance + 10);
     }
   }
 }
 
 TEST_F(HistoryURLProviderTest, IntranetURLsWithRefs) {
   struct TestCase {
     const char* input;
     int relevance;
     AutocompleteInput::Type type;
   } test_cases[] = {
     { "gooey", 1410, AutocompleteInput::UNKNOWN },
     { "gooey/", 1410, AutocompleteInput::URL },
     { "gooey#", 1200, AutocompleteInput::UNKNOWN },
     { "gooey/#", 1200, AutocompleteInput::URL },
     { "gooey#foo", 1200, AutocompleteInput::UNKNOWN },
     { "gooey/#foo", 1200, AutocompleteInput::URL },
     { "gooey# foo", 1200, AutocompleteInput::UNKNOWN },
     { "gooey/# foo", 1200, AutocompleteInput::URL },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     SCOPED_TRACE(test_cases[i].input);
-    const std::string output[] = {
-      URLFixerUpper::FixupURL(test_cases[i].input, std::string()).spec()
+    const UrlAndLegalDefault output[] = {
+      { URLFixerUpper::FixupURL(test_cases[i].input, std::string()).spec(),
+        true }
     };
     AutocompleteInput::Type type;
     ASSERT_NO_FATAL_FAILURE(
         RunTest(ASCIIToUTF16(test_cases[i].input),
                 string16(), false, output, arraysize(output), &type));
     // Actual relevance should be at least what test_cases expects and
     // and no more than 10 more.
     EXPECT_LE(test_cases[i].relevance, matches_[0].relevance);
     EXPECT_LT(matches_[0].relevance, test_cases[i].relevance + 10);
     // Input type should be what we expect.  This is important because
     // this provider counts on SearchProvider to give queries a relevance
     // score >1200 for UNKNOWN inputs and <1200 for URL inputs.  (That's
     // already tested in search_provider_unittest.cc.)  For this test
     // here to test that the user sees the correct behavior, it needs
     // to check that the input type was identified correctly.
     EXPECT_EQ(test_cases[i].type, type);
   }
 }
 
 // Makes sure autocompletion happens for intranet sites that have been
 // previoulsy visited.
 TEST_F(HistoryURLProviderTest, IntranetURLCompletion) {
   sort_matches_ = true;
 
-  const std::string expected1[] = {
-    "http://intra/three",
-    "http://intra/two",
+  const UrlAndLegalDefault expected1[] = {
+    { "http://intra/three", true },
+    { "http://intra/two", true }
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("intra/t"), string16(), false,
                                   expected1, arraysize(expected1)));
   EXPECT_LE(1410, matches_[0].relevance);
   EXPECT_LT(matches_[0].relevance, 1420);
   EXPECT_EQ(matches_[0].relevance - 1, matches_[1].relevance);
 
-  const std::string expected2[] = {
-    "http://moo/b",
-    "http://moo/bar",
+  const UrlAndLegalDefault expected2[] = {
+    { "http://moo/b", true },
+    { "http://moo/bar", true }
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("moo/b"), string16(), false,
                                   expected2, arraysize(expected2)));
   // The url what you typed match should be around 1400, otherwise the
   // search what you typed match is going to be first.
   EXPECT_LE(1400, matches_[0].relevance);
   EXPECT_LT(matches_[0].relevance, 1410);
 
-  const std::string expected3[] = {
-    "http://intra/one",
-    "http://intra/three",
-    "http://intra/two",
+  const UrlAndLegalDefault expected3[] = {
+    { "http://intra/one", true },
+    { "http://intra/three", true },
+    { "http://intra/two", true }
   };
   RunTest(ASCIIToUTF16("intra"), string16(), false, expected3,
           arraysize(expected3));
 
-  const std::string expected4[] = {
-    "http://intra/one",
-    "http://intra/three",
-    "http://intra/two",
+  const UrlAndLegalDefault expected4[] = {
+    { "http://intra/one", true },
+    { "http://intra/three", true },
+    { "http://intra/two", true }
   };
   RunTest(ASCIIToUTF16("intra/"), string16(), false, expected4,
           arraysize(expected4));
 
-  const std::string expected5[] = {
-    "http://intra/one",
+  const UrlAndLegalDefault expected5[] = {
+    { "http://intra/one", true }
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("intra/o"), string16(), false,
                                   expected5, arraysize(expected5)));
   EXPECT_LE(1410, matches_[0].relevance);
   EXPECT_LT(matches_[0].relevance, 1420);
 
-  const std::string expected6[] = {
-    "http://intra/x",
+  const UrlAndLegalDefault expected6[] = {
+    { "http://intra/x", true }
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("intra/x"), string16(), false,
                                   expected6, arraysize(expected6)));
   EXPECT_LE(1400, matches_[0].relevance);
   EXPECT_LT(matches_[0].relevance, 1410);
 
-  const std::string expected7[] = {
-    "http://typedhost/untypedpath",
+  const UrlAndLegalDefault expected7[] = {
+    { "http://typedhost/untypedpath", true }
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("typedhost/untypedpath"),
       string16(), false, expected7, arraysize(expected7)));
   EXPECT_LE(1400, matches_[0].relevance);
   EXPECT_LT(matches_[0].relevance, 1410);
 }
 
 TEST_F(HistoryURLProviderTest, CrashDueToFixup) {
   // This test passes if we don't crash.  The results don't matter.
   const char* const test_cases[] = {
@@ skipping 34 matching lines @@
     {"https://testsearch.com/?q=foobar", 20},
     {"http://foobar.com/", 10}
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     history_service_->AddPageWithDetails(GURL(test_cases[i].url),
         UTF8ToUTF16("Title"), test_cases[i].count, test_cases[i].count,
         Time::Now(), false, history::SOURCE_BROWSED);
   }
 
   // We should not see search URLs when typing a previously used query.
-  const std::string expected_when_searching_query[] = {
-    test_cases[2].url
+  const UrlAndLegalDefault expected_when_searching_query[] = {
+    { test_cases[2].url, false }
   };
   RunTest(ASCIIToUTF16("foobar"), string16(), true,
       expected_when_searching_query, arraysize(expected_when_searching_query));
 
   // We should not see search URLs when typing the search engine name.
-  const std::string expected_when_searching_site[] = {
-    test_cases[0].url
+  const UrlAndLegalDefault expected_when_searching_site[] = {
+    { test_cases[0].url, false }
   };
   RunTest(ASCIIToUTF16("testsearch"), string16(), true,
       expected_when_searching_site, arraysize(expected_when_searching_site));
 }
 
 TEST_F(HistoryURLProviderTest, SuggestExactInput) {
   const size_t npos = std::string::npos;
   struct TestCase {
     // Inputs:
     const char* input;
@@ skipping 64 matching lines @@
       EXPECT_EQ(test_cases[i].offsets[match_index],
                 match.contents_class[match_index].offset);
       EXPECT_EQ(ACMatchClassification::URL |
                 (match_index == test_cases[i].match_classification_index ?
                  ACMatchClassification::MATCH : 0),
                 match.contents_class[match_index].style);
     }
     EXPECT_EQ(npos, test_cases[i].offsets[match.contents_class.size()]);
   }
 }