Omnibox - Do Not Allow HTTP/HTTPS Equivalence if User Explicitly Entered A Scheme

components/omnibox/autocomplete_result_unittest.cc

 // Copyright 2014 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/autocomplete_result.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/autocomplete_input.h"
 #include "components/omnibox/autocomplete_match.h"
 #include "components/omnibox/autocomplete_match_type.h"
 #include "components/omnibox/autocomplete_provider.h"
+#include "components/omnibox/mock_autocomplete_provider_client.h"
 #include "components/omnibox/omnibox_field_trial.h"
 #include "components/omnibox/test_scheme_classifier.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/variations_associated_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using metrics::OmniboxEventProto;
 
 namespace {
@@ skipping 75 matching lines @@
     // Create the list of mock providers.  5 is enough.
     for (size_t i = 0; i < 5; ++i) {
       mock_provider_list_.push_back(new MockAutocompleteProvider(
               static_cast<AutocompleteProvider::Type>(i)));
     }
   }
 
   void SetUp() override {
     template_url_service_.reset(new TemplateURLService(NULL, 0));
     template_url_service_->Load();
+    client_.reset(new MockAutocompleteProviderClient());
   }
 
   // Configures |match| from |data|.
   void PopulateAutocompleteMatch(const TestData& data,
                                  AutocompleteMatch* match);
 
   // Adds |count| AutocompleteMatches to |matches|.
   void PopulateAutocompleteMatches(const TestData* data,
                                    size_t count,
                                    ACMatches* matches);
@@ skipping 10 matching lines @@
                              const TestData* expected, size_t expected_size);
 
   // Returns a (mock) AutocompleteProvider of given |provider_id|.
   MockAutocompleteProvider* GetProvider(int provider_id) {
     EXPECT_LT(provider_id, static_cast<int>(mock_provider_list_.size()));
     return mock_provider_list_[provider_id].get();
   }
 
  protected:
   scoped_ptr<TemplateURLService> template_url_service_;
+  scoped_ptr<MockAutocompleteProviderClient> client_;
 
  private:
   scoped_ptr<base::FieldTrialList> field_trial_list_;
 
   // For every provider mentioned in TestData, we need a mock provider.
   std::vector<scoped_refptr<MockAutocompleteProvider> > mock_provider_list_;
 
   DISALLOW_COPY_AND_ASSIGN(AutocompleteResultTest);
 };
 
@@ skipping 42 matching lines @@
     const TestData* last, size_t last_size,
     const TestData* current, size_t current_size,
     const TestData* expected, size_t expected_size) {
   AutocompleteInput input(base::ASCIIToUTF16("a"), base::string16::npos,
                           std::string(), GURL(),
                           OmniboxEventProto::INVALID_SPEC, false, false, false,
                           true, false, TestSchemeClassifier());
 
   ACMatches last_matches;
   PopulateAutocompleteMatches(last, last_size, &last_matches);
-  AutocompleteResult last_result;
+  AutocompleteResult last_result(client_.get());
   last_result.AppendMatches(input, last_matches);
   last_result.SortAndCull(input, template_url_service_.get());
 
   ACMatches current_matches;
   PopulateAutocompleteMatches(current, current_size, &current_matches);
-  AutocompleteResult current_result;
+  AutocompleteResult current_result(client_.get());
   current_result.AppendMatches(input, current_matches);
   current_result.SortAndCull(input, template_url_service_.get());
   current_result.CopyOldMatches(
       input, last_result, template_url_service_.get());
 
   AssertResultMatches(current_result, expected, expected_size);
 }
 
 // Assertion testing for AutocompleteResult::Swap.
 TEST_F(AutocompleteResultTest, Swap) {
-  AutocompleteResult r1;
-  AutocompleteResult r2;
+  AutocompleteResult r1(client_.get());
+  AutocompleteResult r2(client_.get());
 
   // 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;
@@ skipping 132 matching lines @@
 
   ACMatches matches;
   PopulateAutocompleteMatches(data, arraysize(data), &matches);
   matches[1].destination_url = GURL();
   matches[3].destination_url = GURL();
   matches[4].destination_url = GURL();
 
   AutocompleteInput input(base::string16(), base::string16::npos, std::string(),
                           GURL(), OmniboxEventProto::INVALID_SPEC, false, false,
                           false, true, false, TestSchemeClassifier());
-  AutocompleteResult result;
+  AutocompleteResult result(client_.get());
   result.AppendMatches(input, matches);
   result.SortAndCull(input, template_url_service_.get());
 
   // 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());
@@ skipping 24 matching lines @@
   PopulateAutocompleteMatches(data, arraysize(data), &matches);
   matches[0].destination_url = GURL("http://www.foo.com/s?q=foo");
   matches[1].destination_url = GURL("http://www.foo.com/s?q=foo2");
   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/");
 
   AutocompleteInput input(base::string16(), base::string16::npos, std::string(),
                           GURL(), OmniboxEventProto::INVALID_SPEC, false, false,
                           false, true, false, TestSchemeClassifier());
-  AutocompleteResult result;
+  AutocompleteResult result(client_.get());
   result.AppendMatches(input, matches);
   result.SortAndCull(input, template_url_service_.get());
 
   // 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());
@@ skipping 30 matching lines @@
   matches[0].destination_url = GURL("http://www.foo.com/s?q=foo");
   matches[1].destination_url = GURL("http://www.foo.com/s?q=foo2");
   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/");
   matches[5].destination_url = GURL("http://www.foo.com/s?q=foo2&oq=f");
 
   AutocompleteInput input(base::string16(), base::string16::npos, std::string(),
                           GURL(), OmniboxEventProto::INVALID_SPEC, false, false,
                           false, true, false, TestSchemeClassifier());
-  AutocompleteResult result;
+  AutocompleteResult result(client_.get());
   result.AppendMatches(input, matches);
   result.SortAndCull(input, template_url_service_.get());
 
   // 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);
@@ skipping 32 matching lines @@
         "1:50,7:100,2:0";  // 3 == HOME_PAGE
     ASSERT_TRUE(variations::AssociateVariationParams(
         OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A", params));
   }
   base::FieldTrialList::CreateFieldTrial(
       OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A");
 
   AutocompleteInput input(base::string16(), base::string16::npos, std::string(),
                           GURL(), OmniboxEventProto::HOME_PAGE, false, false,
                           false, true, false, TestSchemeClassifier());
-  AutocompleteResult result;
+  AutocompleteResult result(client_.get());
   result.AppendMatches(input, matches);
   result.SortAndCull(input, template_url_service_.get());
 
   // 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/",
@@ skipping 24 matching lines @@
         OmniboxFieldTrial::kBundledExperimentFieldTrialName, "C", params));
   }
   base::FieldTrialList::CreateFieldTrial(
       OmniboxFieldTrial::kBundledExperimentFieldTrialName, "C");
 
   {
     AutocompleteInput input(
         base::string16(), base::string16::npos, std::string(), GURL(),
         OmniboxEventProto::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS, false,
         false, false, true, false, TestSchemeClassifier());
-    AutocompleteResult result;
+    AutocompleteResult result(client_.get());
     result.AppendMatches(input, matches);
     result.SortAndCull(input, template_url_service_.get());
 
     // 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());
@@ skipping 17 matching lines @@
   {
     // Check that reorder doesn't do anything if the top result
     // is already a legal default match (which is the default from
     // PopulateAutocompleteMatches()).
     ACMatches matches;
     PopulateAutocompleteMatches(data, arraysize(data), &matches);
     AutocompleteInput input(base::string16(), base::string16::npos,
                             std::string(), GURL(), OmniboxEventProto::HOME_PAGE,
                             false, false, false, true, false,
                             TestSchemeClassifier());
-    AutocompleteResult result;
+    AutocompleteResult result(client_.get());
     result.AppendMatches(input, matches);
     result.SortAndCull(input, template_url_service_.get());
     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;
     AutocompleteInput input(base::string16(), base::string16::npos,
                             std::string(), GURL(), OmniboxEventProto::HOME_PAGE,
                             false, false, false, true, false,
                             TestSchemeClassifier());
-    AutocompleteResult result;
+    AutocompleteResult result(client_.get());
     result.AppendMatches(input, matches);
     result.SortAndCull(input, template_url_service_.get());
     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());
   }
 }
 
 TEST_F(AutocompleteResultTest, TopMatchIsStandaloneVerbatimMatch) {
   ACMatches matches;
-  AutocompleteResult result;
+  AutocompleteResult result(client_.get());
   result.AppendMatches(AutocompleteInput(), matches);
 
   // Case 1: Result set is empty.
   EXPECT_FALSE(result.TopMatchIsStandaloneVerbatimMatch());
 
   // Case 2: Top match is not a verbatim match.
   PopulateAutocompleteMatchesFromTestData(kNonVerbatimMatches, 1, &matches);
   result.AppendMatches(AutocompleteInput(), matches);
   EXPECT_FALSE(result.TopMatchIsStandaloneVerbatimMatch());
   result.Reset();
   matches.clear();
 
   // Case 3: Top match is a verbatim match.
   PopulateAutocompleteMatchesFromTestData(kVerbatimMatches, 1, &matches);
   result.AppendMatches(AutocompleteInput(), matches);
   EXPECT_TRUE(result.TopMatchIsStandaloneVerbatimMatch());
   result.Reset();
   matches.clear();
 
   // Case 4: Standalone verbatim match found in AutocompleteResult.
   PopulateAutocompleteMatchesFromTestData(kVerbatimMatches, 1, &matches);
   PopulateAutocompleteMatchesFromTestData(kNonVerbatimMatches, 1, &matches);
   result.AppendMatches(AutocompleteInput(), matches);
   EXPECT_TRUE(result.TopMatchIsStandaloneVerbatimMatch());
   result.Reset();
   matches.clear();
 }