Stop using TemplateURLServiceTestUtil to initialize TemplateURLServiceFactory

chrome/browser/profile_resetter/automatic_profile_resetter_delegate_unittest.cc

 // Copyright 2013 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/profile_resetter/automatic_profile_resetter_delegate.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/browser/profile_resetter/brandcoded_default_settings.h"
 #include "chrome/browser/profile_resetter/profile_reset_global_error.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
-#include "chrome/browser/search_engines/template_url_service_test_util.h"
+#include "chrome/browser/search_engines/template_url_service_factory_test_util.h"
 #include "chrome/browser/ui/global_error/global_error.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/search_engines/default_search_manager.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 115 matching lines @@
   }
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 
 // Test fixture --------------------------------------------------------------
 
 // ExtensionServiceTestBase sets up a TestingProfile with the ExtensionService,
 // we then add the TemplateURLService, so the ProfileResetter can be exercised.
 class AutomaticProfileResetterDelegateTest
-    : public extensions::ExtensionServiceTestBase,
-      public TemplateURLServiceTestUtilBase {
+    : public extensions::ExtensionServiceTestBase {
  protected:
   AutomaticProfileResetterDelegateTest() {}
   virtual ~AutomaticProfileResetterDelegateTest() {}
 
   virtual void SetUp() OVERRIDE {
     extensions::ExtensionServiceTestBase::SetUp();
     ExtensionServiceInitParams params = CreateDefaultInitParams();
     params.pref_file.clear();  // Prescribes a TestingPrefService to be created.
     InitializeExtensionService(params);
-    TemplateURLServiceTestUtilBase::CreateTemplateUrlService();
+    util_.reset(new TemplateURLServiceFactoryTestUtil(profile_.get()));
     resetter_delegate_.reset(
         new AutomaticProfileResetterDelegateUnderTest(profile()));
   }
 
   virtual void TearDown() OVERRIDE {
     resetter_delegate_.reset();
+    util_.reset();
     extensions::ExtensionServiceTestBase::TearDown();
   }
 
   scoped_ptr<TemplateURL> CreateTestTemplateURL() {
     TemplateURLData data;
 
     data.SetURL("http://example.com/search?q={searchTerms}");
     data.suggestions_url = "http://example.com/suggest?q={searchTerms}";
     data.instant_url = "http://example.com/instant?q={searchTerms}";
     data.image_url = "http://example.com/image?q={searchTerms}";
@@ skipping 33 matching lines @@
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* global_error = global_error_service->
         GetGlobalErrorByMenuItemCommandID(IDC_SHOW_SETTINGS_RESET_BUBBLE);
     EXPECT_EQ(active, !!global_error);
   }
 
   AutomaticProfileResetterDelegateUnderTest* resetter_delegate() {
     return resetter_delegate_.get();
   }
 
-  // TemplateURLServiceTestUtilBase:
-  virtual TestingProfile* profile() const OVERRIDE { return profile_.get(); }
+  TemplateURLServiceFactoryTestUtil* util() { return util_.get(); }
 
  private:
+  scoped_ptr<TemplateURLServiceFactoryTestUtil> util_;
   net::TestURLFetcherFactory test_url_fetcher_factory_;
   scoped_ptr<AutomaticProfileResetterDelegateUnderTest> resetter_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterDelegateTest);
 };
 
 
 // Tests ---------------------------------------------------------------------
 
 TEST_F(AutomaticProfileResetterDelegateTest,
@@ skipping 89 matching lines @@
   EXPECT_CALL(mock_target, Run());
   late_resetter_delegate->RequestCallbackWhenTemplateURLServiceIsLoaded(
       mock_target.CreateClosure());
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(AutomaticProfileResetterDelegateTest,
        DefaultSearchProviderDataWhenNotManaged) {
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile());
-  TemplateURLServiceTestUtilBase::VerifyLoad();
+  util()->VerifyLoad();
 
   // Check that the "managed state" and the details returned by the delegate are
   // correct. We verify the details against the data stored by
   // TemplateURLService into Prefs.
   scoped_ptr<TemplateURL> owned_custom_dsp(CreateTestTemplateURL());
   TemplateURL* custom_dsp = owned_custom_dsp.get();
   template_url_service->Add(owned_custom_dsp.release());
   template_url_service->SetUserSelectedDefaultSearchProvider(custom_dsp);
 
   PrefService* prefs = profile()->GetPrefs();
   ASSERT_TRUE(prefs);
   scoped_ptr<base::DictionaryValue> dsp_details(
       resetter_delegate()->GetDefaultSearchProviderDetails());
   const base::DictionaryValue* expected_dsp_details =
       GetDefaultSearchProviderDetailsFromPrefs(prefs);
 
   ExpectDetailsMatch(*expected_dsp_details, *dsp_details);
   EXPECT_FALSE(resetter_delegate()->IsDefaultSearchProviderManaged());
 }
 
 TEST_F(AutomaticProfileResetterDelegateTest,
        DefaultSearchProviderDataWhenManaged) {
   const char kTestSearchURL[] = "http://example.com/search?q={searchTerms}";
   const char kTestName[] = "name";
   const char kTestKeyword[] = "keyword";
 
-  TemplateURLServiceTestUtilBase::VerifyLoad();
+  util()->VerifyLoad();
 
   EXPECT_FALSE(resetter_delegate()->IsDefaultSearchProviderManaged());
 
   // Set managed preferences to emulate a default search provider set by policy.
-  SetManagedDefaultSearchPreferences(
+  util()->SetManagedDefaultSearchPreferences(
       true, kTestName, kTestKeyword, kTestSearchURL, std::string(),
       std::string(), std::string(), std::string(), std::string());
 
   EXPECT_TRUE(resetter_delegate()->IsDefaultSearchProviderManaged());
   scoped_ptr<base::DictionaryValue> dsp_details(
       resetter_delegate()->GetDefaultSearchProviderDetails());
   // Checking that all details are correct is already done by the above test.
   // Just make sure details are reported about the correct engine.
   base::ExpectDictStringValue(kTestSearchURL, *dsp_details, "search_url");
 
   // Set managed preferences to emulate that having a default search provider is
   // disabled by policy.
-  RemoveManagedDefaultSearchPreferences();
-  SetManagedDefaultSearchPreferences(
+  util()->RemoveManagedDefaultSearchPreferences();
+  util()->SetManagedDefaultSearchPreferences(
       false, std::string(), std::string(), std::string(), std::string(),
       std::string(), std::string(), std::string(), std::string());
 
   dsp_details = resetter_delegate()->GetDefaultSearchProviderDetails();
   EXPECT_TRUE(resetter_delegate()->IsDefaultSearchProviderManaged());
   EXPECT_TRUE(dsp_details->empty());
 }
 
 TEST_F(AutomaticProfileResetterDelegateTest,
        GetPrepopulatedSearchProvidersDetails) {
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile());
-  TemplateURLServiceTestUtilBase::VerifyLoad();
+  util()->VerifyLoad();
 
   scoped_ptr<base::ListValue> search_engines_details(
       resetter_delegate()->GetPrepopulatedSearchProvidersDetails());
 
   // Do the same kind of verification as for GetDefaultSearchEngineDetails:
   // subsequently set each pre-populated engine as the default, so we can verify
   // that the details returned by the delegate about one particular engine are
   // correct in comparison to what has been stored to the Prefs.
   std::vector<TemplateURL*> prepopulated_engines =
       template_url_service->GetTemplateURLs();
@@ skipping 177 matching lines @@
   if (ProfileResetGlobalError::IsSupportedOnPlatform())
     ExpectResetPromptState(true /*active*/);
   else
     ExpectResetPromptState(false /*active*/);
   resetter_delegate()->DismissPrompt();
   ExpectResetPromptState(false /*active*/);
   resetter_delegate()->DismissPrompt();
 }
 
 }  // namespace