Reduces dependency from AutocompleteMatch to Profile.

chrome/browser/autocomplete/autocomplete_result_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/autocomplete_result.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
@@ skipping 168 matching lines @@
     const TestData* expected, size_t expected_size) {
   AutocompleteInput input(base::ASCIIToUTF16("a"), base::string16::npos,
                           base::string16(), GURL(),
                           OmniboxEventProto::INVALID_SPEC, false, false, false,
                           true, test_util_.profile());
 
   ACMatches last_matches;
   PopulateAutocompleteMatches(last, last_size, &last_matches);
   AutocompleteResult last_result;
   last_result.AppendMatches(last_matches);
-  last_result.SortAndCull(input, test_util_.profile());
+  last_result.SortAndCull(input, test_util_.model());
 
   ACMatches current_matches;
   PopulateAutocompleteMatches(current, current_size, &current_matches);
   AutocompleteResult current_result;
   current_result.AppendMatches(current_matches);
-  current_result.SortAndCull(input, test_util_.profile());
-  current_result.CopyOldMatches(input, last_result, test_util_.profile());
+  current_result.SortAndCull(input, test_util_.model());
+  current_result.CopyOldMatches(input, last_result, test_util_.model());
 
   AssertResultMatches(current_result, expected, expected_size);
 }
 
 // Assertion testing for AutocompleteResult::Swap.
 TEST_F(AutocompleteResultTest, Swap) {
   AutocompleteResult r1;
   AutocompleteResult r2;
 
   // Swap with empty shouldn't do anything interesting.
   r1.Swap(&r2);
   EXPECT_EQ(r1.end(), r1.default_match());
   EXPECT_EQ(r2.end(), r2.default_match());
 
   // Swap with a single match.
   ACMatches matches;
   AutocompleteMatch match;
   match.relevance = 1;
   match.allowed_to_be_default_match = true;
   AutocompleteInput input(base::ASCIIToUTF16("a"), base::string16::npos,
                           base::string16(), GURL(),
                           OmniboxEventProto::INVALID_SPEC, false, false, false,
                           true, test_util_.profile());
   matches.push_back(match);
   r1.AppendMatches(matches);
-  r1.SortAndCull(input, test_util_.profile());
+  r1.SortAndCull(input, test_util_.model());
   EXPECT_EQ(r1.begin(), r1.default_match());
   EXPECT_EQ("http://a/", r1.alternate_nav_url().spec());
   r1.Swap(&r2);
   EXPECT_TRUE(r1.empty());
   EXPECT_EQ(r1.end(), r1.default_match());
   EXPECT_TRUE(r1.alternate_nav_url().is_empty());
   ASSERT_FALSE(r2.empty());
   EXPECT_EQ(r2.begin(), r2.default_match());
   EXPECT_EQ("http://a/", r2.alternate_nav_url().spec());
 }
@@ skipping 60 matching lines @@
   matches[1].destination_url = GURL();
   matches[3].destination_url = GURL();
   matches[4].destination_url = GURL();
 
   AutocompleteResult result;
   result.AppendMatches(matches);
   AutocompleteInput input(base::string16(), base::string16::npos,
                           base::string16(), GURL(),
                           OmniboxEventProto::INVALID_SPEC, false, false, false,
                           true, test_util_.profile());
-  result.SortAndCull(input, test_util_.profile());
+  result.SortAndCull(input, test_util_.model());
 
   // Of the two results with the same non-empty destination URL, the
   // lower-relevance one should be dropped.  All of the results with empty URLs
   // should be kept.
   ASSERT_EQ(4U, result.size());
   EXPECT_TRUE(result.match_at(0)->destination_url.is_empty());
   EXPECT_EQ(1300, result.match_at(0)->relevance);
   EXPECT_TRUE(result.match_at(1)->destination_url.is_empty());
   EXPECT_EQ(1200, result.match_at(1)->relevance);
   EXPECT_TRUE(result.match_at(2)->destination_url.is_empty());
@@ skipping 25 matching lines @@
   matches[2].destination_url = GURL("http://www.foo.com/s?q=foo&oq=f");
   matches[3].destination_url = GURL("http://www.foo.com/s?q=foo&aqs=0");
   matches[4].destination_url = GURL("http://www.foo.com/");
 
   AutocompleteResult result;
   result.AppendMatches(matches);
   AutocompleteInput input(base::string16(), base::string16::npos,
                           base::string16(), GURL(),
                           OmniboxEventProto::INVALID_SPEC, false, false, false,
                           true, test_util_.profile());
-  result.SortAndCull(input, test_util_.profile());
+  result.SortAndCull(input, test_util_.model());
 
   // We expect the 3rd and 4th results to be removed.
   ASSERT_EQ(3U, result.size());
   EXPECT_EQ("http://www.foo.com/s?q=foo",
             result.match_at(0)->destination_url.spec());
   EXPECT_EQ(1300, result.match_at(0)->relevance);
   EXPECT_EQ("http://www.foo.com/s?q=foo2",
             result.match_at(1)->destination_url.spec());
   EXPECT_EQ(1200, result.match_at(1)->relevance);
   EXPECT_EQ("http://www.foo.com/",
@@ skipping 31 matching lines @@
   matches[3].destination_url = GURL("http://www.foo.com/s?q=foo&aqs=0");
   matches[4].destination_url = GURL("http://www.foo.com/");
   matches[5].destination_url = GURL("http://www.foo.com/s?q=foo2&oq=f");
 
   AutocompleteResult result;
   result.AppendMatches(matches);
   AutocompleteInput input(base::string16(), base::string16::npos,
                           base::string16(), GURL(),
                           OmniboxEventProto::INVALID_SPEC, false, false, false,
                           true, test_util_.profile());
-  result.SortAndCull(input, test_util_.profile());
+  result.SortAndCull(input, test_util_.model());
 
   // Expect 3 unique results after SortAndCull().
   ASSERT_EQ(3U, result.size());
 
   // Check that 3rd and 4th result got added to the first result as dups
   // and also duplicates of the 4th match got copied.
   ASSERT_EQ(4U, result.match_at(0)->duplicate_matches.size());
   const AutocompleteMatch* first_match = result.match_at(0);
   EXPECT_EQ(matches[2].destination_url,
             first_match->duplicate_matches.at(1).destination_url);
@@ skipping 33 matching lines @@
   }
   base::FieldTrialList::CreateFieldTrial(
       OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A");
 
   AutocompleteResult result;
   result.AppendMatches(matches);
   AutocompleteInput input(base::string16(), base::string16::npos,
                           base::string16(), GURL(),
                           OmniboxEventProto::HOME_PAGE, false, false, false,
                           true, test_util_.profile());
-  result.SortAndCull(input, test_util_.profile());
+  result.SortAndCull(input, test_util_.model());
 
   // Check the new ordering.  The history-title results should be omitted.
   // We cannot check relevance scores because the matches are sorted by
   // demoted relevance but the actual relevance scores are not modified.
   ASSERT_EQ(3u, result.size());
   EXPECT_EQ("http://search-what-you-typed/",
             result.match_at(0)->destination_url.spec());
   EXPECT_EQ("http://history-url/",
             result.match_at(1)->destination_url.spec());
   EXPECT_EQ("http://search-history/",
@@ skipping 24 matching lines @@
   base::FieldTrialList::CreateFieldTrial(
       OmniboxFieldTrial::kBundledExperimentFieldTrialName, "C");
 
   {
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(
         base::string16(), base::string16::npos, base::string16(), GURL(),
         OmniboxEventProto::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS, false,
         false, false, true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
 
     // The NAVSUGGEST dup-url stay above search-url since the navsuggest
     // variant should not be demoted.
     ASSERT_EQ(4u, result.size());
     EXPECT_EQ("http://search-what-you-typed/",
               result.match_at(0)->destination_url.spec());
     EXPECT_EQ("http://dup-url/",
               result.match_at(1)->destination_url.spec());
     EXPECT_EQ(AutocompleteMatchType::NAVSUGGEST,
               result.match_at(1)->type);
@@ skipping 17 matching lines @@
     // is already a legal default match (which is the default from
     // PopulateAutocompleteMatches()).
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     AssertResultMatches(result, data, 4);
   }
 
   {
     // Check that reorder swaps up a result appropriately.
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     matches[0].allowed_to_be_default_match = false;
     matches[1].allowed_to_be_default_match = false;
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     ASSERT_EQ(4U, result.size());
     EXPECT_EQ("http://c/", result.match_at(0)->destination_url.spec());
     EXPECT_EQ("http://a/", result.match_at(1)->destination_url.spec());
     EXPECT_EQ("http://b/", result.match_at(2)->destination_url.spec());
     EXPECT_EQ("http://d/", result.match_at(3)->destination_url.spec());
   }
 }
 
 
 
@@ skipping 10 matching lines @@
     // first even if it has an inline autocompletion.
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     matches[0].inline_autocompletion = base::ASCIIToUTF16("completion");
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     AssertResultMatches(result, data, 4);
   }
 
   // Enable the field trial to disable inlining.
   {
     std::map<std::string, std::string> params;
     params[OmniboxFieldTrial::kDisableInliningRule] = "true";
     ASSERT_TRUE(chrome_variations::AssociateVariationParams(
         OmniboxFieldTrial::kBundledExperimentFieldTrialName, "D", params));
   }
   base::FieldTrialList::CreateFieldTrial(
       OmniboxFieldTrial::kBundledExperimentFieldTrialName, "D");
 
   {
     // Now the first match should be demoted past the second.
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     matches[0].inline_autocompletion = base::ASCIIToUTF16("completion");
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     ASSERT_EQ(4U, result.size());
     EXPECT_EQ("http://b/", result.match_at(0)->destination_url.spec());
     EXPECT_EQ("http://a/", result.match_at(1)->destination_url.spec());
     EXPECT_EQ("http://c/", result.match_at(2)->destination_url.spec());
     EXPECT_EQ("http://d/", result.match_at(3)->destination_url.spec());
   }
 
   {
     // But if there was no inline autocompletion on the first match, then
     // the order should stay the same.  This is true even if there are
     // inline autocompletions elsewhere.
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     matches[2].inline_autocompletion = base::ASCIIToUTF16("completion");
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     AssertResultMatches(result, data, 4);
   }
 
   {
     // Try a more complicated situation.
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     matches[0].allowed_to_be_default_match = false;
     matches[1].inline_autocompletion = base::ASCIIToUTF16("completion");
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     ASSERT_EQ(4U, result.size());
     EXPECT_EQ("http://c/", result.match_at(0)->destination_url.spec());
     EXPECT_EQ("http://a/", result.match_at(1)->destination_url.spec());
     EXPECT_EQ("http://b/", result.match_at(2)->destination_url.spec());
     EXPECT_EQ("http://d/", result.match_at(3)->destination_url.spec());
   }
 
   {
     // Try another complicated situation.
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     matches[0].inline_autocompletion = base::ASCIIToUTF16("completion");
     matches[1].allowed_to_be_default_match = false;
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     ASSERT_EQ(4U, result.size());
     EXPECT_EQ("http://c/", result.match_at(0)->destination_url.spec());
     EXPECT_EQ("http://a/", result.match_at(1)->destination_url.spec());
     EXPECT_EQ("http://b/", result.match_at(2)->destination_url.spec());
     EXPECT_EQ("http://d/", result.match_at(3)->destination_url.spec());
   }
 
   {
     // Check that disaster doesn't strike if we can't demote the top inline
     // autocompletion because every match either has a completion or isn't
     // allowed to be the default match.  In this case, we should leave
     // everything untouched.
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     matches[0].inline_autocompletion = base::ASCIIToUTF16("completion");
     matches[1].allowed_to_be_default_match = false;
     matches[2].allowed_to_be_default_match = false;
     matches[3].inline_autocompletion = base::ASCIIToUTF16("completion");
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     AssertResultMatches(result, data, 4);
   }
 
   {
     // Check a similar situation, except in this case the top match is not
     // allowed to the default match, so it still needs to be demoted so we
     // get a legal default match first.  That match will have an inline
     // autocompletion because we don't have any better options.
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     matches[0].allowed_to_be_default_match = false;
     matches[1].inline_autocompletion = base::ASCIIToUTF16("completion");
     matches[2].allowed_to_be_default_match = false;
     matches[3].inline_autocompletion = base::ASCIIToUTF16("completion");
     AutocompleteResult result;
     result.AppendMatches(matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             base::string16(), GURL(),
                             OmniboxEventProto::HOME_PAGE, false, false, false,
                             true, test_util_.profile());
-    result.SortAndCull(input, test_util_.profile());
+    result.SortAndCull(input, test_util_.model());
     ASSERT_EQ(4U, result.size());
     EXPECT_EQ("http://b/", result.match_at(0)->destination_url.spec());
     EXPECT_EQ("http://a/", result.match_at(1)->destination_url.spec());
     EXPECT_EQ("http://c/", result.match_at(2)->destination_url.spec());
     EXPECT_EQ("http://d/", result.match_at(3)->destination_url.spec());
   }
 }
 
 TEST_F(AutocompleteResultTest, ShouldHideTopMatch) {
   base::FieldTrialList::CreateFieldTrial("InstantExtended",
@@ skipping 99 matching lines @@
   result.Reset();
   matches.clear();
 
   // Case 5: Multiple verbatim matches found in AutocompleteResult.
   PopulateAutocompleteMatchesFromTestData(kVerbatimMatches,
                                           arraysize(kVerbatimMatches),
                                           &matches);
   result.AppendMatches(matches);
   EXPECT_FALSE(result.ShouldHideTopMatch());
 }