Omnibox: Make Exact Match Tab-to-Search Work

chrome/browser/autocomplete/autocomplete_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 "components/autocomplete/autocomplete_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 144 matching lines @@
     matches_.push_back(match);
   }
 }
 
 class AutocompleteProviderTest : public testing::Test,
                                  public content::NotificationObserver {
  protected:
   struct KeywordTestData {
     const base::string16 fill_into_edit;
     const base::string16 keyword;
-    const bool expected_keyword_result;
+    const base::string16 expected_associated_keyword;
   };
 
   struct AssistedQueryStatsTestData {
     const AutocompleteMatch::Type match_type;
     const std::string expected_aqs;
   };
 
  protected:
    // Registers a test TemplateURL under the given keyword.
   void RegisterTemplateURL(const base::string16 keyword,
                            const std::string& template_url);
 
   // Resets |controller_| with two TestProviders.  |provider1_ptr| and
   // |provider2_ptr| are updated to point to the new providers if non-NULL.
   void ResetControllerWithTestProviders(bool same_destinations,
                                         TestProvider** provider1_ptr,
                                         TestProvider** provider2_ptr);
 
   // Runs a query on the input "a", and makes sure both providers' input is
   // properly collected.
   void RunTest();
 
-  void RunRedundantKeywordTest(const KeywordTestData* match_data, size_t size);
+  // Constructs an AutocompleteResult from |match_data|, sets the |controller_|
+  // to pretend it was running against input |input|, calls the |controller_|'s
+  // UpdateAssociatedKeywords, and checks that the matches have associated
+  // keywords as expected.
+  void RunKeywordTest(const base::string16& input,
+                      const KeywordTestData* match_data,
+                      size_t size);
 
   void RunAssistedQueryStatsTest(
       const AssistedQueryStatsTestData* aqs_test_data,
       size_t size);
 
   void RunQuery(const base::string16 query);
 
   void ResetControllerWithKeywordAndSearchProviders();
   void ResetControllerWithKeywordProvider();
   void RunExactKeymatchTest(bool allow_exact_keyword_match);
@@ skipping 135 matching lines @@
 
   // Create a TemplateURL for KeywordProvider.
   TemplateURLData data;
   data.short_name = base::ASCIIToUTF16("foo.com");
   data.SetKeyword(base::ASCIIToUTF16("foo.com"));
   data.SetURL("http://foo.com/{searchTerms}");
   TemplateURL* keyword_t_url = new TemplateURL(data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
+  // Make a TemplateURL for KeywordProvider that a shorter version of the
+  // first.
+  data.short_name = base::ASCIIToUTF16("f");
+  data.SetKeyword(base::ASCIIToUTF16("f"));
+  data.SetURL("http://f.com/{searchTerms}");
+  keyword_t_url = new TemplateURL(data);
+  turl_model->Add(keyword_t_url);
+  ASSERT_NE(0, keyword_t_url->id());
+
   // Create another TemplateURL for KeywordProvider.
   data.short_name = base::ASCIIToUTF16("bar.com");
   data.SetKeyword(base::ASCIIToUTF16("bar.com"));
   data.SetURL("http://bar.com/{searchTerms}");
   keyword_t_url = new TemplateURL(data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   controller_.reset(new AutocompleteController(
       &profile_, TemplateURLServiceFactory::GetForProfile(&profile_), NULL,
       AutocompleteProvider::TYPE_KEYWORD));
 }
 
 void AutocompleteProviderTest::RunTest() {
   RunQuery(base::ASCIIToUTF16("a"));
 }
 
-void AutocompleteProviderTest::RunRedundantKeywordTest(
-    const KeywordTestData* match_data,
-    size_t size) {
+void AutocompleteProviderTest::RunKeywordTest(const base::string16& input,
+                                              const KeywordTestData* match_data,
+                                              size_t size) {
   ACMatches matches;
   for (size_t i = 0; i < size; ++i) {
     AutocompleteMatch match;
     match.relevance = 1000;  // Arbitrary non-zero value.
     match.allowed_to_be_default_match = true;
     match.fill_into_edit = match_data[i].fill_into_edit;
     match.transition = content::PAGE_TRANSITION_KEYWORD;
     match.keyword = match_data[i].keyword;
     matches.push_back(match);
   }
 
   AutocompleteResult result;
   result.AppendMatches(matches);
+  controller_->input_ = AutocompleteInput(
+      input, base::string16::npos, base::string16(), GURL(),
+      metrics::OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS,
+      false, true, true, true, ChromeAutocompleteSchemeClassifier(&profile_));
   controller_->UpdateAssociatedKeywords(&result);
 
   for (size_t j = 0; j < result.size(); ++j) {
-    EXPECT_EQ(match_data[j].expected_keyword_result,
-        result.match_at(j)->associated_keyword.get() != NULL);
+    EXPECT_EQ(match_data[j].expected_associated_keyword,
+              result.match_at(j)->associated_keyword.get() ?
+                  result.match_at(j)->associated_keyword->keyword :
+                  base::string16());
   }
 }
 
 void AutocompleteProviderTest::RunAssistedQueryStatsTest(
     const AssistedQueryStatsTestData* aqs_test_data,
     size_t size) {
   // Prepare input.
   const size_t kMaxRelevance = 1000;
   ACMatches matches;
   for (size_t i = 0; i < size; ++i) {
@@ skipping 143 matching lines @@
   EXPECT_EQ("http://defaultturl/k%20test?a=b",
             result_.match_at(1)->destination_url.possibly_invalid_spec());
 }
 
 // Test that redundant associated keywords are removed.
 TEST_F(AutocompleteProviderTest, RedundantKeywordsIgnoredInResult) {
   ResetControllerWithKeywordProvider();
 
   {
     KeywordTestData duplicate_url[] = {
-      { base::ASCIIToUTF16("fo"), base::string16(), false },
-      { base::ASCIIToUTF16("foo.com"), base::string16(), true },
-      { base::ASCIIToUTF16("foo.com"), base::string16(), false }
+      { base::ASCIIToUTF16("fo"), base::string16(), base::string16() },
+      { base::ASCIIToUTF16("foo.com"), base::string16(),
+        base::ASCIIToUTF16("foo.com") },
+      { base::ASCIIToUTF16("foo.com"), base::string16(), base::string16() }
     };
 
     SCOPED_TRACE("Duplicate url");
-    RunRedundantKeywordTest(duplicate_url, ARRAYSIZE_UNSAFE(duplicate_url));
+    RunKeywordTest(base::ASCIIToUTF16("fo"), duplicate_url,
+                   ARRAYSIZE_UNSAFE(duplicate_url));
   }
 
   {
     KeywordTestData keyword_match[] = {
-      { base::ASCIIToUTF16("foo.com"), base::ASCIIToUTF16("foo.com"), false },
-      { base::ASCIIToUTF16("foo.com"), base::string16(), false }
+      { base::ASCIIToUTF16("foo.com"), base::ASCIIToUTF16("foo.com"),
+        base::string16() },
+      { base::ASCIIToUTF16("foo.com"), base::string16(), base::string16() }
     };
 
     SCOPED_TRACE("Duplicate url with keyword match");
-    RunRedundantKeywordTest(keyword_match, ARRAYSIZE_UNSAFE(keyword_match));
+    RunKeywordTest(base::ASCIIToUTF16("fo"), keyword_match,
+                   ARRAYSIZE_UNSAFE(keyword_match));
   }
 
   {
     KeywordTestData multiple_keyword[] = {
-      { base::ASCIIToUTF16("fo"), base::string16(), false },
-      { base::ASCIIToUTF16("foo.com"), base::string16(), true },
-      { base::ASCIIToUTF16("foo.com"), base::string16(), false },
-      { base::ASCIIToUTF16("bar.com"), base::string16(), true },
+      { base::ASCIIToUTF16("fo"), base::string16(), base::string16() },
+      { base::ASCIIToUTF16("foo.com"), base::string16(),
+        base::ASCIIToUTF16("foo.com") },
+      { base::ASCIIToUTF16("foo.com"), base::string16(), base::string16() },
+      { base::ASCIIToUTF16("bar.com"), base::string16(),
+        base::ASCIIToUTF16("bar.com") },
     };
 
     SCOPED_TRACE("Duplicate url with multiple keywords");
-    RunRedundantKeywordTest(multiple_keyword,
-        ARRAYSIZE_UNSAFE(multiple_keyword));
+    RunKeywordTest(base::ASCIIToUTF16("fo"), multiple_keyword,
+                   ARRAYSIZE_UNSAFE(multiple_keyword));
   }
 }
 
+// Test that exact match keywords trump keywords associated with
+// the match.
+TEST_F(AutocompleteProviderTest, ExactMatchKeywords) {
+  ResetControllerWithKeywordProvider();
+
+  {
+    KeywordTestData keyword_match[] = {
+      { base::ASCIIToUTF16("foo.com"), base::string16(),
+        base::ASCIIToUTF16("foo.com") }
+    };
+
+    SCOPED_TRACE("keyword match as usual");
+    RunKeywordTest(base::ASCIIToUTF16("fo"), keyword_match,
+                   ARRAYSIZE_UNSAFE(keyword_match));
+  }
+
+  // The same result set with an input of "f" (versus "fo") should get
+  // a different associated keyword because "f" is an exact match for
+  // a keyword and that should trump the keyword normally associated with
+  // this match.
+  {
+    KeywordTestData keyword_match[] = {
+      { base::ASCIIToUTF16("foo.com"), base::string16(),
+        base::ASCIIToUTF16("f") }
+    };
+
+    SCOPED_TRACE("keyword exact match");
+    RunKeywordTest(base::ASCIIToUTF16("f"), keyword_match,
+                   ARRAYSIZE_UNSAFE(keyword_match));
+  }
+}
+
 TEST_F(AutocompleteProviderTest, UpdateAssistedQueryStats) {
   ResetControllerWithTestProviders(false, NULL, NULL);
 
   {
     AssistedQueryStatsTestData test_data[] = {
       //  MSVC doesn't support zero-length arrays, so supply some dummy data.
       { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, "" }
     };
     SCOPED_TRACE("No matches");
     // Note: We pass 0 here to ignore the dummy data above.
@@ skipping 81 matching lines @@
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j0j4&", url.path());
 
   // Test page classification and field trial triggered set.
   controller_->search_provider_->field_trial_triggered_in_session_ = true;
   EXPECT_TRUE(
       controller_->search_provider_->field_trial_triggered_in_session());
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j1j4&", url.path());
 }