Instant: Use only one hidden WebContents per profile.

chrome/browser/autocomplete/search_provider_unittest.cc

 // Copyright 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/search_provider.h"
 
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
 #include "chrome/browser/autocomplete/autocomplete_controller.h"
 #include "chrome/browser/autocomplete/autocomplete_field_trial.h"
 #include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/autocomplete/autocomplete_provider_listener.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
-#include "chrome/browser/ui/browser_instant_controller.h"
+#include "chrome/browser/ui/search/search.h"
 #include "chrome/common/metrics/entropy_provider.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
@@ skipping 229 matching lines @@
   // URLFetchers runs.
   message_loop_.RunUntilIdle();
 }
 
 void SearchProviderTest::QueryForInputAndSetWYTMatch(
     const string16& text,
     AutocompleteMatch* wyt_match) {
   QueryForInput(text, string16(), false);
   profile_.BlockUntilHistoryProcessesPendingRequests();
   ASSERT_NO_FATAL_FAILURE(FinishDefaultSuggestQuery());
-  EXPECT_NE(chrome::BrowserInstantController::IsInstantEnabled(&profile_),
-            provider_->done());
+  EXPECT_NE(chrome::search::IsInstantEnabled(&profile_), provider_->done());
   if (!wyt_match)
     return;
   ASSERT_GE(provider_->matches().size(), 1u);
   EXPECT_TRUE(FindMatchWithDestination(GURL(
       default_t_url_->url_ref().ReplaceSearchTerms(
           TemplateURLRef::SearchTermsArgs(text))),
       wyt_match));
 }
 
 void SearchProviderTest::TearDown() {
@@ skipping 210 matching lines @@
 }
 
 // Make sure FinalizeInstantQuery works.
 TEST_F(SearchProviderTest, FinalizeInstantQuery) {
   PrefService* service = profile_.GetPrefs();
   service->SetBoolean(prefs::kInstantEnabled, true);
 
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("foo"),
                                                       NULL));
 
-  // Tell the provider instant is done.
+  // Tell the provider Instant is done.
   provider_->FinalizeInstantQuery(ASCIIToUTF16("foo"),
                                   InstantSuggestion(ASCIIToUTF16("bar"),
                                                     INSTANT_COMPLETE_NOW,
-                                                    INSTANT_SUGGESTION_SEARCH));
+                                                    false));
 
   // The provider should now be done.
   EXPECT_TRUE(provider_->done());
 
   // There should be two matches, one for what you typed, the other for
   // 'foobar'.
   EXPECT_EQ(2u, provider_->matches().size());
   GURL instant_url(default_t_url_->url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("foobar"))));
   AutocompleteMatch instant_match;
   EXPECT_TRUE(FindMatchWithDestination(instant_url, &instant_match));
 
   // And the 'foobar' match should not have a description, it'll be set later.
   EXPECT_TRUE(instant_match.description.empty());
 
   // Make sure the what you typed match has no description.
   AutocompleteMatch wyt_match;
   EXPECT_TRUE(FindMatchWithDestination(
       GURL(default_t_url_->url_ref().ReplaceSearchTerms(
           TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("foo")))),
           &wyt_match));
   EXPECT_TRUE(wyt_match.description.empty());
 
-  // The instant search should be more relevant.
+  // The Instant search should be more relevant.
   EXPECT_GT(instant_match.relevance, wyt_match.relevance);
 }
 
 // Make sure FinalizeInstantQuery works with URL suggestions.
 TEST_F(SearchProviderTest, FinalizeInstantURL) {
   PrefService* service = profile_.GetPrefs();
   service->SetBoolean(prefs::kInstantEnabled, true);
 
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("ex"),
                                                       NULL));
 
-  // Tell the provider instant is done.
+  // Tell the provider Instant is done.
   provider_->FinalizeInstantQuery(ASCIIToUTF16("ex"),
                                   InstantSuggestion(
                                       ASCIIToUTF16("http://example.com/"),
                                       INSTANT_COMPLETE_NOW,
-                                      INSTANT_SUGGESTION_URL));
+                                      true));
 
   // The provider should now be done.
   EXPECT_TRUE(provider_->done());
 
   // There should be two matches, one for what you typed, the other for
   // "http://example.com/".
   EXPECT_EQ(2u, provider_->matches().size());
   GURL instant_url("http://example.com");
   AutocompleteMatch instant_match;
   EXPECT_TRUE(FindMatchWithDestination(instant_url, &instant_match));
 
-  // The instant match should not have a description, it'll be set later.
+  // The Instant match should not have a description, it'll be set later.
   EXPECT_TRUE(instant_match.description.empty());
 
   // Make sure the what you typed match has no description.
   AutocompleteMatch wyt_match;
   EXPECT_TRUE(FindMatchWithDestination(
       GURL(default_t_url_->url_ref().ReplaceSearchTerms(
           TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("ex")))),
           &wyt_match));
   EXPECT_TRUE(wyt_match.description.empty());
 
-  // The instant URL should be more relevant.
+  // The Instant URL should be more relevant.
   EXPECT_GT(instant_match.relevance, wyt_match.relevance);
 }
 
 // An Instant URL suggestion should behave the same way whether the input text
 // is classified as UNKNOWN or as an URL. Otherwise if the user types
 // "example.co" url-what-you-typed will displace the Instant suggestion for
 // "example.com".
 TEST_F(SearchProviderTest, FinalizeInstantURLWithURLText) {
   PrefService* service = profile_.GetPrefs();
   service->SetBoolean(prefs::kInstantEnabled, true);
 
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(
       ASCIIToUTF16("example.co"), NULL));
 
-  // Tell the provider instant is done.
+  // Tell the provider Instant is done.
   provider_->FinalizeInstantQuery(ASCIIToUTF16("example.co"),
                                   InstantSuggestion(
                                       ASCIIToUTF16("http://example.com/"),
                                       INSTANT_COMPLETE_NOW,
-                                      INSTANT_SUGGESTION_URL));
+                                      true));
 
   // The provider should now be done.
   EXPECT_TRUE(provider_->done());
 
   // There should be two matches, one for what you typed, the other for
   // "http://example.com/".
   EXPECT_EQ(2u, provider_->matches().size());
   GURL instant_url("http://example.com");
   AutocompleteMatch instant_match;
   EXPECT_TRUE(FindMatchWithDestination(instant_url, &instant_match));
 
-  // The instant match should not have a description, it'll be set later.
+  // The Instant match should not have a description, it'll be set later.
   EXPECT_TRUE(instant_match.description.empty());
 
-  // The instant URL should be more relevant than a URL_WHAT_YOU_TYPED match.
+  // The Instant URL should be more relevant than a URL_WHAT_YOU_TYPED match.
   EXPECT_GT(instant_match.relevance,
             HistoryURLProvider::kScoreForWhatYouTypedResult);
 }
 
 // Make sure that if FinalizeInstantQuery is invoked before suggest results
 // return, the suggest text from FinalizeInstantQuery is remembered.
 TEST_F(SearchProviderTest, RememberInstantQuery) {
   PrefService* service = profile_.GetPrefs();
   service->SetBoolean(prefs::kInstantEnabled, true);
 
   QueryForInput(ASCIIToUTF16("foo"), string16(), false);
 
-  // Finalize the instant query immediately.
+  // Finalize the Instant query immediately.
   provider_->FinalizeInstantQuery(ASCIIToUTF16("foo"),
                                   InstantSuggestion(ASCIIToUTF16("bar"),
                                                     INSTANT_COMPLETE_NOW,
-                                                    INSTANT_SUGGESTION_SEARCH));
+                                                    false));
 
   // There should be two matches, one for what you typed, the other for
   // 'foobar'.
   EXPECT_EQ(2u, provider_->matches().size());
   GURL instant_url(default_t_url_->url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("foobar"))));
   AutocompleteMatch instant_match;
   EXPECT_TRUE(FindMatchWithDestination(instant_url, &instant_match));
 
   // Wait until history and the suggest query complete.
@@ skipping 14 matching lines @@
 
 // Make sure that if trailing whitespace is added to the text supplied to
 // AutocompleteInput the default suggest text is cleared.
 TEST_F(SearchProviderTest, DifferingText) {
   PrefService* service = profile_.GetPrefs();
   service->SetBoolean(prefs::kInstantEnabled, true);
 
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("foo"),
                                                       NULL));
 
-  // Finalize the instant query immediately.
+  // Finalize the Instant query immediately.
   provider_->FinalizeInstantQuery(ASCIIToUTF16("foo"),
                                   InstantSuggestion(ASCIIToUTF16("bar"),
                                                     INSTANT_COMPLETE_NOW,
-                                                    INSTANT_SUGGESTION_SEARCH));
+                                                    false));
 
   // Query with the same input text, but trailing whitespace.
   AutocompleteMatch instant_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("foo "),
                                                       &instant_match));
 
   // There should only one match, for what you typed.
   EXPECT_EQ(1u, provider_->matches().size());
   EXPECT_FALSE(instant_match.destination_url.is_empty());
 }
@@ skipping 275 matching lines @@
     // chrome/browser/extensions/api/omnibox/omnibox_apitest.cc.
   };
 
   // Test not in keyword mode.
   RunTest(cases, arraysize(cases), false);
 
   // Test in keyword mode.  (Both modes should give the same result.)
   RunTest(cases, arraysize(cases), true);
 }
 
-// Verifies Navsuggest results don't set a TemplateURL, which instant relies on.
+// Verifies Navsuggest results don't set a TemplateURL, which Instant relies on.
 // Also verifies that just the *first* navigational result is listed as a match
 // if suggested relevance scores were not sent.
 TEST_F(SearchProviderTest, NavSuggestNoSuggestedRelevanceScores) {
   QueryForInput(ASCIIToUTF16("a.c"), string16(), false);
 
   // Make sure the default providers suggest service was queried.
   net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(fetcher);
 
@@ skipping 591 matching lines @@
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[0].style);
   EXPECT_EQ(4U, match.contents_class[1].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL |
             AutocompleteMatch::ACMatchClassification::MATCH,
             match.contents_class[1].style);
   EXPECT_EQ(5U, match.contents_class[2].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[2].style);
 }