Include a URL what-you-typed option when the default search provider is not available and the input…

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/path_service.h"
@@ skipping 10 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/history/core/browser/url_database.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/autocomplete_match.h"
 #include "components/omnibox/autocomplete_provider.h"
 #include "components/omnibox/autocomplete_provider_listener.h"
 #include "components/omnibox/autocomplete_result.h"
+#include "components/search_engines/default_search_manager.h"
 #include "components/search_engines/search_terms_data.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/url_fixer/url_fixer.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
@@ skipping 135 matching lines @@
     return new TemplateURLService(
         profile->GetPrefs(), make_scoped_ptr(new SearchTermsData), NULL,
         scoped_ptr<TemplateURLServiceClient>(
             new ChromeTemplateURLServiceClient(
                 HistoryServiceFactory::GetForProfile(
                     profile, Profile::EXPLICIT_ACCESS))),
         NULL, NULL, base::Closure());
   }
 
   // testing::Test
-  virtual void SetUp() {
+  void SetUp() override {
     ASSERT_TRUE(SetUpImpl(false));
   }
-  virtual void TearDown();
+  void TearDown() override;
 
   // Does the real setup.
   bool SetUpImpl(bool no_db) WARN_UNUSED_RESULT;
 
   // Fills test data into the history system.
   void FillData();
 
   // Runs an autocomplete query on |text| and checks to see that the returned
   // results' destination URLs match those provided.  Also allows checking
   // that the input type was identified correctly.
@@ skipping 19 matching lines @@
   ACMatches matches_;
   scoped_ptr<TestingProfile> profile_;
   HistoryService* history_service_;
   scoped_refptr<HistoryURLProvider> autocomplete_;
   // Should the matches be sorted and duplicates removed?
   bool sort_matches_;
 };
 
 class HistoryURLProviderTestNoDB : public HistoryURLProviderTest {
  protected:
-  virtual void SetUp() {
+  void SetUp() override {
     ASSERT_TRUE(SetUpImpl(true));
   }
 };
 
+class HistoryURLProviderTestNoSearchProvider : public HistoryURLProviderTest {
+ protected:
+  void SetUp() override {
+    DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(true);
+    HistoryURLProviderTest::SetUp();
+  }
+
+  void TearDown() override {
+    HistoryURLProviderTest::TearDown();
+    DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(false);
+  }
+};
+
 void HistoryURLProviderTest::OnProviderUpdate(bool updated_matches) {
   if (autocomplete_->done())
     base::MessageLoop::current()->Quit();
 }
 
 bool HistoryURLProviderTest::SetUpImpl(bool no_db) {
   profile_.reset(new TestingProfile());
   if (!(profile_->CreateHistoryService(true, no_db)))
     return false;
   if (!no_db) {
@@ skipping 229 matching lines @@
   // "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 }
   };
   RunTest(typing, std::string(), true, expected_results,
           arraysize(expected_results));
 }
 
+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,
+          arraysize(results_1));
+
+  RunTest(ASCIIToUTF16("wytmatch foo bar"), std::string(), false, NULL, 0);
+  RunTest(ASCIIToUTF16("wytmatch+foo+bar"), std::string(), false, NULL, 0);
+
+  const UrlAndLegalDefault results_2[] = {
+    { "http://wytmatch+foo+bar.com/", true }
+  };
+  RunTest(ASCIIToUTF16("wytmatch+foo+bar.com"), std::string(), false,
+          results_2, arraysize(results_2));
+}
+
 TEST_F(HistoryURLProviderTest, WhatYouTyped) {
   // Make sure we suggest a What You Typed match at the right times.
   RunTest(ASCIIToUTF16("wytmatch"), std::string(), false, NULL, 0);
   RunTest(ASCIIToUTF16("wytmatch foo bar"), std::string(), false, NULL, 0);
   RunTest(ASCIIToUTF16("wytmatch+foo+bar"), std::string(), false, NULL, 0);
   RunTest(ASCIIToUTF16("wytmatch+foo+bar.com"), std::string(), false, NULL, 0);
 
   const UrlAndLegalDefault results_1[] = {
     { "http://www.wytmatch.com/", true }
   };
@@ skipping 496 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);
     }
   }
 }