Topsites become keyedService based.

chrome/browser/autocomplete/zero_suggest_provider_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 "chrome/browser/autocomplete/zero_suggest_provider.h"
 
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
 #include "chrome/browser/history/top_sites.h"
+#include "chrome/browser/history/top_sites_factory.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/autocomplete_provider_listener.h"
 #include "components/omnibox/omnibox_field_trial.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/variations_associated_data.h"
@@ skipping 33 matching lines @@
   void SyncWithHistory() override {}
   bool HasBlacklistedItems() const override {
     return false;
   }
   void AddBlacklistedURL(const GURL& url) override {}
   void RemoveBlacklistedURL(const GURL& url) override {}
   bool IsBlacklisted(const GURL& url) override {
     return false;
   }
   void ClearBlacklistedURLs() override {}
-  void Shutdown() override {}
   base::CancelableTaskTracker::TaskId StartQueryForMostVisited() override {
     return 0;
   }
   bool IsKnownURL(const GURL& url) override {
     return false;
   }
   const std::string& GetCanonicalURLString(const GURL& url) const override {
     CHECK(false);
     return *(new std::string());
   }
   bool IsNonForcedFull() override {
     return false;
   }
   bool IsForcedFull() override {
     return false;
   }
   bool loaded() const override {
     return false;
   }
   history::MostVisitedURLList GetPrepopulatePages() override {
     return history::MostVisitedURLList();
   }
   bool AddForcedURL(const GURL& url, const base::Time& time) override {
     return false;
   }
+
+  // RefcountedKeyedService:
+  void ShutdownOnUIThread() override {}
+
   // content::NotificationObserver:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override {}
 
   // A test-specific field for controlling when most visited callback is run
   // after top sites have been requested.
   GetMostVisitedURLsCallback mv_callback;
 
  protected:
   ~FakeEmptyTopSites() override {}
 };
 
 void FakeEmptyTopSites::GetMostVisitedURLs(
     const GetMostVisitedURLsCallback& callback,
     bool include_forced_urls)  {
   mv_callback = callback;
 }
 
+scoped_refptr<RefcountedKeyedService> BuildFakeEmptyTopSites(
+    content::BrowserContext* profile) {
+  scoped_refptr<history::TopSites> top_sites = new FakeEmptyTopSites();
+  return top_sites;
+}
+
 }  // namespace
 
 
 class ZeroSuggestProviderTest : public testing::Test,
                                 public AutocompleteProviderListener {
  public:
   ZeroSuggestProviderTest();
 
   void SetUp() override;
   void TearDown() override;
@@ skipping 46 matching lines @@
   TemplateURLData data;
   data.short_name = base::ASCIIToUTF16("t");
   data.SetURL("https://www.google.com/?q={searchTerms}");
   data.suggestions_url = "https://www.google.com/complete/?q={searchTerms}";
   data.instant_url = "https://does/not/exist?strk=1";
   data.search_terms_replacement_key = "strk";
   default_t_url_ = new TemplateURL(data);
   turl_model->Add(default_t_url_);
   turl_model->SetUserSelectedDefaultSearchProvider(default_t_url_);
 
-  profile_.SetTopSites(new FakeEmptyTopSites());
-
+  profile_.DestroyTopSites();
+  TopSitesFactory::GetInstance()->SetTestingFactory(&profile_,
+                                                    BuildFakeEmptyTopSites);
   provider_ = ZeroSuggestProvider::Create(this, turl_model, &profile_);
 }
 
 void ZeroSuggestProviderTest::TearDown() {
   // Shutdown the provider before the profile.
   provider_ = NULL;
 }
 
 void ZeroSuggestProviderTest::OnProviderUpdate(bool updated_matches) {
 }
@@ skipping 67 matching lines @@
                           metrics::OmniboxEventProto::OTHER, false, false,
                           true, true,
                           ChromeAutocompleteSchemeClassifier(&profile_));
   history::MostVisitedURLList urls;
   history::MostVisitedURL url(GURL("http://foo.com/"),
                               base::ASCIIToUTF16("Foo"));
   urls.push_back(url);
 
   provider_->Start(input, false, true);
   EXPECT_TRUE(provider_->matches().empty());
-  static_cast<FakeEmptyTopSites*>(profile_.GetTopSites())->mv_callback.Run(
-      urls);
+  scoped_refptr<history::TopSites> top_sites =
+      TopSitesFactory::GetForProfile(&profile_);
+  static_cast<FakeEmptyTopSites*>(top_sites.get())->mv_callback.Run(urls);
   // Should have verbatim match + most visited url match.
   EXPECT_EQ(2U, provider_->matches().size());
   provider_->Stop(false);
 
   provider_->Start(input, false, true);
   provider_->Stop(false);
   EXPECT_TRUE(provider_->matches().empty());
   // Most visited results arriving after Stop() has been called, ensure they
   // are not displayed.
-  static_cast<FakeEmptyTopSites*>(profile_.GetTopSites())->mv_callback.Run(
-      urls);
+  static_cast<FakeEmptyTopSites*>(top_sites.get())->mv_callback.Run(urls);
   EXPECT_TRUE(provider_->matches().empty());
 }
 
 TEST_F(ZeroSuggestProviderTest, TestMostVisitedNavigateToSearchPage) {
   CreateMostVisitedFieldTrial();
 
   std::string current_url("http://www.foxnews.com/");
   std::string input_url("http://www.cnn.com/");
   AutocompleteInput input(base::ASCIIToUTF16(input_url), base::string16::npos,
                           std::string(), GURL(current_url),
@@ skipping 19 matching lines @@
           SEARCH_RESULT_PAGE_DOING_SEARCH_TERM_REPLACEMENT,
       false,
       false,
       true,
       true,
       ChromeAutocompleteSchemeClassifier(&profile_));
 
   provider_->Start(srp_input, false, true);
   EXPECT_TRUE(provider_->matches().empty());
   // Most visited results arriving after a new request has been started.
-  static_cast<FakeEmptyTopSites*>(profile_.GetTopSites())->mv_callback.Run(
-      urls);
+  scoped_refptr<history::TopSites> top_sites =
+      TopSitesFactory::GetForProfile(&profile_);
+  static_cast<FakeEmptyTopSites*>(top_sites.get())->mv_callback.Run(urls);
   EXPECT_TRUE(provider_->matches().empty());
 }
 
 TEST_F(ZeroSuggestProviderTest, TestPsuggestZeroSuggestCachingFirstRun) {
   CreatePersonalizedFieldTrial();
 
   // Ensure the cache is empty.
   PrefService* prefs = profile_.GetPrefs();
   prefs->SetString(prefs::kZeroSuggestCachedResults, std::string());
 
@@ skipping 105 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   // Expect that the matches have been cleared.
   ASSERT_TRUE(provider_->matches().empty());
 
   // Expect the new results have been stored.
   EXPECT_EQ(empty_response,
             prefs->GetString(prefs::kZeroSuggestCachedResults));
 }