Stop using TemplateURLServiceTestUtil to initialize TemplateURLServiceFactory

chrome/browser/search_engines/template_url_service_sync_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 "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 139 matching lines @@
 
 class TemplateURLServiceSyncTest : public testing::Test {
  public:
   typedef TemplateURLService::SyncDataMap SyncDataMap;
 
   TemplateURLServiceSyncTest();
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
-  TemplateURLService* model() { return test_util_a_.model(); }
+  TemplateURLService* model() { return test_util_a_->model(); }
   // For readability, we redefine an accessor for Model A for use in tests that
   // involve syncing two models.
-  TemplateURLService* model_a() { return test_util_a_.model(); }
+  TemplateURLService* model_a() { return test_util_a_->model(); }
   TemplateURLService* model_b() { return model_b_.get(); }
-  TestingProfile* profile_a() { return test_util_a_.profile(); }
+  TestingProfile* profile_a() { return test_util_a_->profile(); }
   TestChangeProcessor* processor() { return sync_processor_.get(); }
   scoped_ptr<syncer::SyncChangeProcessor> PassProcessor();
   scoped_ptr<syncer::SyncErrorFactory> CreateAndPassSyncErrorFactory();
 
   // Creates a TemplateURL with some test values. The caller owns the returned
   // TemplateURL*.
   TemplateURL* CreateTestTemplateURL(const base::string16& keyword,
                                      const std::string& url,
                                      const std::string& guid = std::string(),
                                      time_t last_mod = 100,
@@ skipping 27 matching lines @@
   // Creates a new TemplateURL copying the fields of |turl| but replacing
   // the |url| and |guid| and initializing the date_created and last_modified
   // timestamps to a default value of 100. The caller owns the returned
   // TemplateURL*.
   TemplateURL* CopyTemplateURL(const TemplateURLData* turl,
                                const std::string& url,
                                const std::string& guid);
 
  protected:
   // We keep two TemplateURLServices to test syncing between them.
-  TemplateURLServiceTestUtil test_util_a_;
+  scoped_ptr<TemplateURLServiceTestUtil> test_util_a_;
   scoped_ptr<TestingProfile> profile_b_;
   scoped_ptr<TemplateURLService> model_b_;
 
   // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
   scoped_ptr<TestChangeProcessor> sync_processor_;
   scoped_ptr<syncer::SyncChangeProcessorWrapperForTest> sync_processor_wrapper_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLServiceSyncTest);
 };
 
 TemplateURLServiceSyncTest::TemplateURLServiceSyncTest()
     : sync_processor_(new TestChangeProcessor),
       sync_processor_wrapper_(new syncer::SyncChangeProcessorWrapperForTest(
           sync_processor_.get())) {}
 
 void TemplateURLServiceSyncTest::SetUp() {
   DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(true);
-  test_util_a_.SetUp();
+  test_util_a_.reset(new TemplateURLServiceTestUtil);
   // Use ChangeToLoadState() instead of VerifyLoad() so we don't actually pull
   // in the prepopulate data, which the sync tests don't care about (and would
   // just foul them up).
-  test_util_a_.ChangeModelToLoadState();
+  test_util_a_->ChangeModelToLoadState();
   profile_b_.reset(new TestingProfile);
   TemplateURLServiceFactory::GetInstance()->
       RegisterUserPrefsOnBrowserContextForTest(profile_b_.get());
   model_b_.reset(new TemplateURLService(
       profile_b_->GetPrefs(), scoped_ptr<SearchTermsData>(
           new UIThreadSearchTermsData(profile_b_.get())), NULL,
       scoped_ptr<TemplateURLServiceClient>(), NULL, NULL, base::Closure()));
   model_b_->Load();
 }
 
 void TemplateURLServiceSyncTest::TearDown() {
-  test_util_a_.TearDown();
+  test_util_a_.reset();
   DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(false);
 }
 
 scoped_ptr<syncer::SyncChangeProcessor>
 TemplateURLServiceSyncTest::PassProcessor() {
   return sync_processor_wrapper_.PassAs<syncer::SyncChangeProcessor>();
 }
 
 scoped_ptr<syncer::SyncErrorFactory> TemplateURLServiceSyncTest::
     CreateAndPassSyncErrorFactory() {
@@ skipping 1396 matching lines @@
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 
   // Change the default search provider to a managed one.
   const char kName[] = "manageddefault";
   const char kSearchURL[] = "http://manageddefault.com/search?t={searchTerms}";
   const char kIconURL[] = "http://manageddefault.com/icon.jpg";
   const char kEncodings[] = "UTF-16;UTF-32";
   const char kAlternateURL[] =
       "http://manageddefault.com/search#t={searchTerms}";
   const char kSearchTermsReplacementKey[] = "espv";
-  test_util_a_.SetManagedDefaultSearchPreferences(true, kName, kName,
+  test_util_a_->SetManagedDefaultSearchPreferences(true, kName, kName,
       kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL,
       kSearchTermsReplacementKey);
   const TemplateURL* dsp_turl = model()->GetDefaultSearchProvider();
 
   EXPECT_TRUE(model()->is_default_search_managed());
 
   // Add a new entry from Sync. It should still sync in despite the default
   // being managed.
   syncer::SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
@@ skipping 10 matching lines @@
       prefs::kSyncedDefaultSearchProviderGUID,
       "newdefault");
 
   EXPECT_EQ(dsp_turl, model()->GetDefaultSearchProvider());
   EXPECT_TRUE(model()->is_default_search_managed());
 
   // Go unmanaged. Ensure that the DSP changes to the expected pending entry
   // from Sync.
   const TemplateURL* expected_default =
       model()->GetTemplateURLForGUID("newdefault");
-  test_util_a_.RemoveManagedDefaultSearchPreferences();
+  test_util_a_->RemoveManagedDefaultSearchPreferences();
 
   EXPECT_EQ(expected_default, model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncMergeDeletesDefault) {
   // If the value from Sync is a duplicate of the local default and is newer, it
   // should safely replace the local value and set as the new default.
   TemplateURL* default_turl = CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com/{searchTerms}", "whateverguid", 10);
   model()->Add(default_turl);
@@ skipping 133 matching lines @@
   data_copy.last_modified = Time::FromTimeT(10);
   base::string16 original_keyword = data_copy.keyword();
   data_copy.SetKeyword(ASCIIToUTF16(kNewKeyword));
   // Set safe_for_autoreplace to false so our keyword survives.
   data_copy.safe_for_autoreplace = false;
   model()->Add(new TemplateURL(data_copy));
 
   // Merge the prepopulate search engines.
   base::Time pre_merge_time = base::Time::Now();
   base::RunLoop().RunUntilIdle();
-  test_util_a_.ResetModel(true);
+  test_util_a_->ResetModel(true);
 
   // The newly added search engine should have been safely merged, with an
   // updated time.
   TemplateURL* added_turl = model()->GetTemplateURLForKeyword(
       ASCIIToUTF16(kNewKeyword));
   ASSERT_TRUE(added_turl);
   base::Time new_timestamp = added_turl->last_modified();
   EXPECT_GE(new_timestamp, pre_merge_time);
   std::string sync_guid = added_turl->sync_guid();
 
@@ skipping 28 matching lines @@
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(static_cast<int>(prepop_turls.size()),
             merge_result.num_items_before_association());
   EXPECT_EQ(static_cast<int>(prepop_turls.size()),
             merge_result.num_items_after_association());
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncBaseURLs) {
   // Verify that bringing in a remote TemplateURL that uses Google base URLs
   // causes it to get a local keyword that matches the local base URL.
-  test_util_a_.SetGoogleBaseURL(GURL("http://google.com/"));
+  test_util_a_->SetGoogleBaseURL(GURL("http://google.com/"));
   syncer::SyncDataList initial_data;
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(
       ASCIIToUTF16("google.co.uk"), "{google:baseURL}search?q={searchTerms}",
       "guid"));
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
   TemplateURL* synced_turl = model()->GetTemplateURLForGUID("guid");
   ASSERT_TRUE(synced_turl);
   EXPECT_EQ(ASCIIToUTF16("google.com"), synced_turl->keyword());
   EXPECT_EQ(0U, processor()->change_list_size());
 
   // Remote updates to this URL's keyword should be silently ignored.
   syncer::SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("google.de"),
           "{google:baseURL}search?q={searchTerms}", "guid")));
   model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_EQ(ASCIIToUTF16("google.com"), synced_turl->keyword());
   EXPECT_EQ(0U, processor()->change_list_size());
 
   // A local change to the Google base URL should update the keyword and
   // generate a sync change.
-  test_util_a_.SetGoogleBaseURL(GURL("http://google.co.in/"));
+  test_util_a_->SetGoogleBaseURL(GURL("http://google.co.in/"));
   EXPECT_EQ(ASCIIToUTF16("google.co.in"), synced_turl->keyword());
   EXPECT_EQ(1U, processor()->change_list_size());
   ASSERT_TRUE(processor()->contains_guid("guid"));
   syncer::SyncChange change(processor()->change_for_guid("guid"));
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
   EXPECT_EQ("google.co.in", GetKeyword(change.sync_data()));
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeInSyncTemplateURL) {
   // An enumeration used to indicate which TemplateURL test value is expected
@@ skipping 301 matching lines @@
   const char kNewGUID[] = "newdefault";
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"),
                                      "http://thewhat.com/{searchTerms}",
                                      kNewGUID));
   model()->SetUserSelectedDefaultSearchProvider(
       model()->GetTemplateURLForGUID(kNewGUID));
 
   EXPECT_EQ(kNewGUID, profile_a()->GetTestingPrefService()->GetString(
       prefs::kSyncedDefaultSearchProviderGUID));
 }