Omnibox: Make HUP Scoring More Sane in Prevent-Inline Mode

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/prefs/pref_service.h"
@@ skipping 395 matching lines @@
   };
   RunTest(ASCIIToUTF16("foo.com"), std::string(), true, short_2,
           arraysize(short_2));
   RunTest(ASCIIToUTF16("foo.com/"), std::string(), 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 UrlAndLegalDefault short_3[] = {
+    { "http://foo.com/dir/another/", false },
     { "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"), std::string(), true, short_3,
           arraysize(short_3));
+  // If prevent_inline_autocomplete is false, we won't bother creating the
+  // URL-what-you-typed match because we have promoted inline autocompletions.
+  const UrlAndLegalDefault short_3_allow_inline[] = {
+    { "http://foo.com/dir/another/", true },
+    { "http://foo.com/dir/another/again/myfile.html", true },
+    { "http://foo.com/dir/", true }
+  };
+  RunTest(ASCIIToUTF16("foo.com/d"), std::string(), false, short_3_allow_inline,
+          arraysize(short_3_allow_inline));
 
   // We shouldn't promote shorter URLs than the best if they're not good
   // enough.
   const UrlAndLegalDefault short_4[] = {
+    { "http://foo.com/dir/another/again/myfile.html", false },
     { "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"), std::string(), true, short_4,
           arraysize(short_4));
+  // If prevent_inline_autocomplete is false, we won't bother creating the
+  // URL-what-you-typed match because we have promoted inline autocompletions.
+  const UrlAndLegalDefault short_4_allow_inline[] = {
+    { "http://foo.com/dir/another/again/myfile.html", true },
+    { "http://foo.com/dir/another/again/", true }
+  };
+  RunTest(ASCIIToUTF16("foo.com/dir/another/a"), std::string(), false,
+          short_4_allow_inline, arraysize(short_4_allow_inline));
 
   // Exact matches should always be best no matter how much more another match
   // has been typed.
   const UrlAndLegalDefault short_5a[] = {
     { "http://gooey/", true },
     { "http://www.google.com/", true },
     { "http://go/", true }
   };
   const UrlAndLegalDefault short_5b[] = {
     { "http://go/", true },
@@ skipping 35 matching lines @@
   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, ui::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 base::string16 typing(ASCIIToUTF16("http://redirects/"));
   const UrlAndLegalDefault expected_results[] = {
-    { base::UTF16ToUTF8(typing), true },
-    { test_cases[0].url, false }
+    { test_cases[0].url, false },
+    { base::UTF16ToUTF8(typing), true }
   };
   RunTest(typing, std::string(), true, expected_results,
           arraysize(expected_results));
+
+  // If prevent_inline_autocomplete is false, we won't bother creating the
+  // URL-what-you-typed match because we have promoted inline autocompletions.
+  // The result set should instead consist of a single URL representing the
+  // whole set of redirects.
+  const UrlAndLegalDefault expected_results_allow_inlining[] = {
+    { test_cases[0].url, true }
+  };
+  RunTest(typing, std::string(), false, expected_results_allow_inlining,
+          arraysize(expected_results_allow_inlining));
 }
 
 TEST_F(HistoryURLProviderTestNoSearchProvider, WhatYouTypedNoSearchProvider) {
   // When no search provider is available, make sure we provide WYT matches
   // for text that could be a URL.
 
   const UrlAndLegalDefault results_1[] = {
     { "http://wytmatch/", true }
   };
   RunTest(ASCIIToUTF16("wytmatch"), std::string(), false, results_1,
@@ skipping 528 matching lines @@
     // Test the experiment (scoring enabled).
     autocomplete_->scoring_params_.experimental_scoring_enabled = true;
     ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16(test_cases[i].input),
                                     std::string(), false, output, max_matches));
     for (int j = 0; j < max_matches; ++j) {
       EXPECT_EQ(test_cases[i].matches[j].experiment_relevance,
                 matches_[j].relevance);
     }
   }
 }