Remove Profile* from TemplateURL

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 258 matching lines @@
   data.SetKeyword(keyword);
   data.SetURL(url);
   data.favicon_url = GURL("http://favicon.url");
   data.safe_for_autoreplace = safe_for_autoreplace;
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(last_mod);
   data.created_by_policy = created_by_policy;
   data.prepopulate_id = 999999;
   if (!guid.empty())
     data.sync_guid = guid;
-  return new TemplateURL(NULL, data);
+  return new TemplateURL(data);
 }
 
 void TemplateURLServiceSyncTest::AssertEquals(const TemplateURL& expected,
                                               const TemplateURL& actual) const {
   ASSERT_EQ(expected.short_name(), actual.short_name());
   ASSERT_EQ(expected.keyword(), actual.keyword());
   ASSERT_EQ(expected.url(), actual.url());
   ASSERT_EQ(expected.suggestions_url(), actual.suggestions_url());
   ASSERT_EQ(expected.favicon_url(), actual.favicon_url());
   ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
@@ skipping 58 matching lines @@
 
 TemplateURL* TemplateURLServiceSyncTest::CopyTemplateURL(
     const TemplateURLData* turl,
     const std::string& url,
     const std::string& guid) {
   TemplateURLData data = *turl;
   data.SetURL(url);
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
   data.sync_guid = guid;
-  return new TemplateURL(NULL, data);
+  return new TemplateURL(data);
 }
 
 // Actual tests ---------------------------------------------------------------
 
 TEST_F(TemplateURLServiceSyncTest, SerializeDeserialize) {
   // Create a TemplateURL and convert it into a sync specific type.
   scoped_ptr<TemplateURL> turl(
       CreateTestTemplateURL(
           ASCIIToUTF16("unittest"), "http://www.unittest.com/"));
   syncer::SyncData sync_data =
@@ skipping 875 matching lines @@
   data.input_encodings.push_back("UTF-8");
   data.input_encodings.push_back("UTF-16");
   data.input_encodings.push_back("UTF-8");
   data.input_encodings.push_back("Big5");
   data.input_encodings.push_back("UTF-16");
   data.input_encodings.push_back("Big5");
   data.input_encodings.push_back("Windows-1252");
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
   data.sync_guid = "keyword";
-  scoped_ptr<TemplateURL> turl(new TemplateURL(NULL, data));
+  scoped_ptr<TemplateURL> turl(new TemplateURL(data));
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
 
   // Now try to sync the data locally.
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   // The entry should have been added, with duplicate encodings removed.
   TemplateURL* keyword =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
@@ skipping 140 matching lines @@
           syncer::SEARCH_ENGINES,
           initial_data,
           PassProcessor(),
           CreateAndPassSyncErrorFactory()).error();
   ASSERT_FALSE(error.IsSet());
 
   // We should have updated the original TemplateURL with Sync's version.
   // Keep a copy of it so we can compare it after we re-merge.
   TemplateURL* key1_url = model()->GetTemplateURLForGUID("key1");
   ASSERT_TRUE(key1_url);
-  scoped_ptr<TemplateURL> updated_turl(new TemplateURL(key1_url->profile(),
-                                                       key1_url->data()));
+  scoped_ptr<TemplateURL> updated_turl(new TemplateURL(key1_url->data()));
   EXPECT_EQ(Time::FromTimeT(90), updated_turl->last_modified());
 
   // Modify a single field of the initial data. This should not be updated in
   // the second merge, as the last_modified timestamp remains the same.
   scoped_ptr<TemplateURL> temp_turl(Deserialize(initial_data[0]));
   TemplateURLData data(temp_turl->data());
   data.short_name = ASCIIToUTF16("SomethingDifferent");
-  temp_turl.reset(new TemplateURL(temp_turl->profile(), data));
+  temp_turl.reset(new TemplateURL(data));
   initial_data.clear();
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*temp_turl));
 
   // Remerge the data again. This simulates shutting down and syncing again
   // at a different time, but the cloud data has not changed.
   model()->StopSyncing(syncer::SEARCH_ENGINES);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   error = model()->MergeDataAndStartSyncing(
@@ skipping 67 matching lines @@
   data.SetKeyword(ASCIIToUTF16("key2"));
   data.SetURL("http://key2.com/{searchTerms}");
   data.favicon_url = GURL("http://favicon.url");
   data.safe_for_autoreplace = false;
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
   data.created_by_policy = false;
   data.prepopulate_id = 999999;
   data.sync_guid = "key2";
   data.show_in_default_list = true;
-  scoped_ptr<TemplateURL> turl2(new TemplateURL(NULL, data));
+  scoped_ptr<TemplateURL> turl2(new TemplateURL(data));
   initial_data.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(
       *turl1));
   initial_data.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(
       *turl2));
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
   model()->SetUserSelectedDefaultSearchProvider(
       model()->GetTemplateURLForGUID("key1"));
   ASSERT_EQ("key1", model()->GetDefaultSearchProvider()->sync_guid());
 
@@ skipping 305 matching lines @@
   ASSERT_FALSE(prepop_turls.empty());
 
   // Create a copy of the first TemplateURL with a really old timestamp and a
   // new keyword. Add it to the model.
   TemplateURLData data_copy(*prepop_turls[0]);
   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(profile_a(), data_copy));
+  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);
 
   // 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();
 
   // Bring down a copy of the prepopulate engine from Sync with the old values,
   // including the old timestamp and the same GUID. Ensure that it loses
   // conflict resolution against the local value, and an update is sent to the
   // server. The new timestamp should be preserved.
   syncer::SyncDataList initial_data;
   data_copy.SetKeyword(original_keyword);
   data_copy.sync_guid = sync_guid;
-  scoped_ptr<TemplateURL> sync_turl(new TemplateURL(profile_a(), data_copy));
+  scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data_copy));
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
 
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES,
       initial_data, PassProcessor(), CreateAndPassSyncErrorFactory());
 
   ASSERT_EQ(added_turl, model()->GetTemplateURLForKeyword(
       ASCIIToUTF16(kNewKeyword)));
   EXPECT_EQ(new_timestamp, added_turl->last_modified());
@@ skipping 253 matching lines @@
   EXPECT_EQ(default_turl->url(), result_turl->url());
 }
 
 TEST_F(TemplateURLServiceSyncTest, UpdatePrepopulatedEngine) {
   scoped_ptr<TemplateURLData> default_turl(
       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
 
   TemplateURLData data = *default_turl;
   data.SetURL("http://old.wrong.url.com?q={searchTerms}");
   data.sync_guid = "default";
-  model()->Add(new TemplateURL(NULL, data));
+  model()->Add(new TemplateURL(data));
 
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, syncer::SyncDataList(), PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
   TemplateURL* sync_turl = CopyTemplateURL(default_turl.get(),
       "http://new.wrong.url.com?q={searchTerms}", "default");
 
   // Update the engine in the model, which is prepopulated, with a new one.
   // Both have wrong URLs, but it should still get corrected.
@@ skipping 14 matching lines @@
       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
 
   TemplateURLData data(*default_turl);
   data.safe_for_autoreplace = false;
   data.SetKeyword(ASCIIToUTF16("new_kw"));
   data.short_name = ASCIIToUTF16("my name");
   data.SetURL("http://wrong.url.com?q={searchTerms}");
   data.date_created = Time::FromTimeT(50);
   data.last_modified = Time::FromTimeT(50);
   data.sync_guid = "default";
-  model()->Add(new TemplateURL(NULL, data));
+  model()->Add(new TemplateURL(data));
 
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
-  scoped_ptr<TemplateURL> sync_turl(new TemplateURL(NULL, data));
+  scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data));
   syncer::SyncDataList list;
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, list, PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
   EXPECT_TRUE(result_turl);
   EXPECT_EQ(ASCIIToUTF16("new_kw"), result_turl->keyword());
   EXPECT_EQ(ASCIIToUTF16("my name"), result_turl->short_name());
   EXPECT_EQ(default_turl->url(), result_turl->url());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeNonEditedPrepopulatedEngine) {
   scoped_ptr<TemplateURLData> default_turl(
       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
 
   TemplateURLData data(*default_turl);
   data.safe_for_autoreplace = true;  // Can be replaced with built-in values.
   data.SetKeyword(ASCIIToUTF16("new_kw"));
   data.short_name = ASCIIToUTF16("my name");
   data.SetURL("http://wrong.url.com?q={searchTerms}");
   data.date_created = Time::FromTimeT(50);
   data.last_modified = Time::FromTimeT(50);
   data.sync_guid = "default";
-  model()->Add(new TemplateURL(NULL, data));
+  model()->Add(new TemplateURL(data));
 
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
-  scoped_ptr<TemplateURL> sync_turl(new TemplateURL(NULL, data));
+  scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data));
   syncer::SyncDataList list;
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, list, PassProcessor(),
       CreateAndPassSyncErrorFactory());
 
   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
   EXPECT_TRUE(result_turl);
   EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
   EXPECT_EQ(default_turl->short_name, result_turl->short_name());
@@ skipping 14 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));
 }