Remove Profile* from TemplateURL

chrome/browser/search_engines/template_url_service_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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
@@ skipping 92 matching lines @@
   data.SetURL(url);
   data.suggestions_url = suggest_url;
   if (!alternate_url.empty())
     data.alternate_urls.push_back(alternate_url);
   data.favicon_url = GURL(favicon_url);
   data.safe_for_autoreplace = safe_for_autoreplace;
   data.show_in_default_list = show_in_default_list;
   base::SplitString(encodings, ';', &data.input_encodings);
   data.date_created = date_created;
   data.last_modified = last_modified;
-  return new TemplateURL(model->profile(), data);
+  return new TemplateURL(data);
 }
 
 TemplateURL* AddKeywordWithDate(
     TemplateURLService* model,
     const std::string& short_name,
     const std::string& keyword,
     const std::string& url,
     const std::string& suggest_url,
     const std::string& alternate_url,
     const std::string& favicon_url,
@@ skipping 64 matching lines @@
   void VerifyObserverCount(int expected_changed_count);
   void VerifyObserverFired();
   TemplateURLService* model() { return test_util_.model(); }
   const SearchTermsData& search_terms_data() {
     return model()->search_terms_data();
   }
 
  protected:
   TemplateURLServiceTestUtil test_util_;
 
-  void TestGenerateSearchURL(SearchTermsData* search_terms_data) {
-    struct GenerateSearchURLCase {
-      const char* test_name;
-      const char* url;
-      const char* expected;
-    } generate_url_cases[] = {
-      { "invalid URL", "foo{searchTerms}", "" },
-      { "URL with no replacements", "http://foo/", "http://foo/" },
-      { "basic functionality", "http://foo/{searchTerms}",
-        "http://foo/blah.blah.blah.blah.blah" }
-    };
-
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(generate_url_cases); ++i) {
-      TemplateURLData data;
-      data.SetURL(generate_url_cases[i].url);
-      TemplateURL t_url(NULL, data);
-      std::string result;
-      if (search_terms_data) {
-          result = TemplateURLService::GenerateSearchURLUsingTermsData(
-              &t_url, *search_terms_data).spec();
-      } else {
-          result = TemplateURLService::GenerateSearchURL(&t_url).spec();
-      }
-      EXPECT_EQ(result,  generate_url_cases[i].expected)
-          << generate_url_cases[i].test_name << " failed. Expected "
-          << generate_url_cases[i].expected << " Actual " << result;
-    }
-  }
-
-
   DISALLOW_COPY_AND_ASSIGN(TemplateURLServiceTest);
 };
 
 class TemplateURLServiceWithoutFallbackTest : public TemplateURLServiceTest {
  public:
   TemplateURLServiceWithoutFallbackTest() : TemplateURLServiceTest() {}
 
   virtual void SetUp() OVERRIDE {
     TemplateURLService::set_fallback_search_engines_disabled(true);
     TemplateURLServiceTest::SetUp();
@@ skipping 58 matching lines @@
   data.short_name = ASCIIToUTF16("unittest");
   data.SetKeyword(ASCIIToUTF16("unittest"));
   data.SetURL("http://www.unittest.com/{searchTerms}");
   data.favicon_url = GURL("http://favicon.url");
   data.show_in_default_list = true;
   data.safe_for_autoreplace = safe_for_autoreplace;
   data.input_encodings.push_back("UTF-8");
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
   data.prepopulate_id = prepopulate_id;
-  return new TemplateURL(test_util_.profile(), data);
+  return new TemplateURL(data);
 }
 
 void TemplateURLServiceTest::VerifyObserverCount(int expected_changed_count) {
   EXPECT_EQ(expected_changed_count, test_util_.GetObserverCount());
   test_util_.ResetObserverCount();
 }
 
 void TemplateURLServiceTest::VerifyObserverFired() {
   EXPECT_LE(1, test_util_.GetObserverCount());
   test_util_.ResetObserverCount();
@@ skipping 13 matching lines @@
 
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("google");
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://www.google.com/foo/bar");
   data.favicon_url = GURL("http://favicon.url");
   data.safe_for_autoreplace = true;
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
   data.sync_guid = "00000000-0000-0000-0000-000000000001";
-  TemplateURL* t_url = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url = new TemplateURL(data);
   model()->Add(t_url);
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("keyword"), GURL(),
                                          NULL));
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(t_url->keyword()));
   // We need to make a second copy as the model takes ownership of |t_url| and
   // will delete it.  We have to do this after calling Add() since that gives
   // |t_url| its ID.
-  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->profile(),
-                                                     t_url->data()));
+  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
 
   // Reload the model to verify it was actually saved to the database.
   test_util_.ResetModel(true);
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   TemplateURL* loaded_url =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_TRUE(loaded_url != NULL);
   AssertEquals(*cloned_url, *loaded_url);
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("keyword"), GURL(),
                                          NULL));
 
   // We expect the last_modified time to be updated to the present time on an
   // explicit reset. We have to set up the expectation here because ResetModel
   // resets the TimeProvider in the TemplateURLService.
   StrictMock<base::MockTimeProvider> mock_time;
   model()->set_time_provider(&base::MockTimeProvider::StaticNow);
   EXPECT_CALL(mock_time, Now()).WillOnce(Return(base::Time::FromDoubleT(1337)));
 
   // Mutate an element and verify it succeeded.
   model()->ResetTemplateURL(loaded_url, ASCIIToUTF16("a"), ASCIIToUTF16("b"),
                             "c");
   ASSERT_EQ(ASCIIToUTF16("a"), loaded_url->short_name());
   ASSERT_EQ(ASCIIToUTF16("b"), loaded_url->keyword());
   ASSERT_EQ("c", loaded_url->url());
   ASSERT_FALSE(loaded_url->safe_for_autoreplace());
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("keyword"), GURL(),
                                          NULL));
   ASSERT_FALSE(model()->CanReplaceKeyword(ASCIIToUTF16("b"), GURL(), NULL));
-  cloned_url.reset(new TemplateURL(loaded_url->profile(), loaded_url->data()));
+  cloned_url.reset(new TemplateURL(loaded_url->data()));
   base::RunLoop().RunUntilIdle();
   test_util_.ResetModel(true);
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   loaded_url = model()->GetTemplateURLForKeyword(ASCIIToUTF16("b"));
   ASSERT_TRUE(loaded_url != NULL);
   AssertEquals(*cloned_url, *loaded_url);
   // We changed a TemplateURL in the service, so ensure that the time was
   // updated.
   ASSERT_EQ(base::Time::FromDoubleT(1337), loaded_url->last_modified());
 
@@ skipping 13 matching lines @@
       std::string(), true, "UTF-8", Time(), Time());
   VerifyObserverCount(1);
 
   // Test what happens when we try to add a TemplateURL with the same keyword as
   // one in the model.
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("second");
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://test2");
   data.safe_for_autoreplace = false;
-  TemplateURL* t_url = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url = new TemplateURL(data);
   model()->Add(t_url);
 
   // Because the old TemplateURL was replaceable and the new one wasn't, the new
   // one should have replaced the old.
   VerifyObserverCount(1);
   EXPECT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_EQ(ASCIIToUTF16("second"), t_url->short_name());
   EXPECT_EQ(ASCIIToUTF16("keyword"), t_url->keyword());
   EXPECT_FALSE(t_url->safe_for_autoreplace());
 
   // Now try adding a replaceable TemplateURL.  This should just delete the
   // passed-in URL.
   data.short_name = ASCIIToUTF16("third");
   data.SetURL("http://test3");
   data.safe_for_autoreplace = true;
-  model()->Add(new TemplateURL(test_util_.profile(), data));
+  model()->Add(new TemplateURL(data));
   VerifyObserverCount(0);
   EXPECT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_EQ(ASCIIToUTF16("second"), t_url->short_name());
   EXPECT_EQ(ASCIIToUTF16("keyword"), t_url->keyword());
   EXPECT_FALSE(t_url->safe_for_autoreplace());
 
   // Now try adding a non-replaceable TemplateURL again.  This should uniquify
   // the existing entry's keyword.
   data.short_name = ASCIIToUTF16("fourth");
   data.SetURL("http://test4");
   data.safe_for_autoreplace = false;
-  TemplateURL* t_url2 = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url2 = new TemplateURL(data);
   model()->Add(t_url2);
   VerifyObserverCount(1);
   EXPECT_EQ(t_url2, model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_EQ(ASCIIToUTF16("fourth"), t_url2->short_name());
   EXPECT_EQ(ASCIIToUTF16("keyword"), t_url2->keyword());
   EXPECT_EQ(ASCIIToUTF16("second"), t_url->short_name());
   EXPECT_EQ(ASCIIToUTF16("test2"), t_url->keyword());
 }
 
 TEST_F(TemplateURLServiceTest, AddExtensionKeyword) {
@@ skipping 12 matching lines @@
 
   // Add an extension keyword that conflicts with each of the above three
   // keywords.
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("test");
   data.SetKeyword(ASCIIToUTF16("keyword1"));
   data.SetURL(std::string(extensions::kExtensionScheme) + "://test4");
   data.safe_for_autoreplace = false;
 
   // Both replaceable and non-replaceable keywords should be uniquified.
-  TemplateURL* extension1 = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* extension1 = new TemplateURL(data);
   model()->Add(extension1);
   ASSERT_EQ(extension1,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1")));
   EXPECT_EQ(original1,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("test1")));
   data.SetKeyword(ASCIIToUTF16("keyword2"));
-  TemplateURL* extension2 = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* extension2 = new TemplateURL(data);
   model()->Add(extension2);
   ASSERT_EQ(extension2,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2")));
   EXPECT_EQ(original2,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("test2")));
 
   // They should override extension keywords added earlier.
   data.SetKeyword(ASCIIToUTF16("keyword3"));
-  TemplateURL* extension3 = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* extension3 = new TemplateURL(data);
   model()->Add(extension3);
   ASSERT_EQ(extension3,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword3")));
   EXPECT_EQ(original3,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword3_")));
 }
 
 TEST_F(TemplateURLServiceTest, AddSameKeywordWithExtensionPresent) {
   test_util_.VerifyLoad();
 
@@ skipping 10 matching lines @@
       "replaceable", "keyword", "http://test1", std::string(),  std::string(),
       std::string(), true, "UTF-8", Time(), Time());
 
   // Adding another replaceable keyword should remove the existing one, but
   // leave the extension as is.
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("name1");
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://test3");
   data.safe_for_autoreplace = true;
-  TemplateURL* t_url = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url = new TemplateURL(data);
   model()->Add(t_url);
   EXPECT_EQ(extension,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword_")));
   EXPECT_TRUE(model()->GetTemplateURLForHost("test1") == NULL);
   EXPECT_EQ(t_url, model()->GetTemplateURLForHost("test3"));
 
   // Adding a nonreplaceable keyword should remove the existing replaceable
   // keyword.
   data.short_name = ASCIIToUTF16("name2");
   data.SetURL("http://test4");
   data.safe_for_autoreplace = false;
-  TemplateURL* t_url2 = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url2 = new TemplateURL(data);
   model()->Add(t_url2);
   EXPECT_EQ(t_url2,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_TRUE(model()->GetTemplateURLForHost("test3") == NULL);
   EXPECT_EQ(extension,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword_")));
 }
 
 TEST_F(TemplateURLServiceTest, GenerateKeyword) {
   ASSERT_EQ(ASCIIToUTF16("foo"),
             TemplateURLService::GenerateKeyword(GURL("http://foo")));
   // www. should be stripped.
   ASSERT_EQ(ASCIIToUTF16("foo"),
             TemplateURLService::GenerateKeyword(GURL("http://www.foo")));
   // Make sure we don't get a trailing '/'.
   ASSERT_EQ(ASCIIToUTF16("blah"),
             TemplateURLService::GenerateKeyword(GURL("http://blah/")));
   // Don't generate the empty string.
   ASSERT_EQ(ASCIIToUTF16("www"),
             TemplateURLService::GenerateKeyword(GURL("http://www.")));
 }
 
 TEST_F(TemplateURLServiceTest, GenerateSearchURL) {
-  TestGenerateSearchURL(NULL);
-}
+  TestSearchTermsData search_terms_data("http://google.com/");
 
-TEST_F(TemplateURLServiceTest, GenerateSearchURLUsingTermsData) {
-  // Run the test for GenerateSearchURLUsingTermsData on the "IO" thread and
-  // wait for it to finish.
-  TestSearchTermsData search_terms_data("http://google.com/");
-  TestGenerateSearchURL(&search_terms_data);
+  struct GenerateSearchURLCase {
+    const char* test_name;
+    const char* url;
+    const char* expected;
+  } generate_url_cases[] = {
+    { "invalid URL", "foo{searchTerms}", "" },
+    { "URL with no replacements", "http://foo/", "http://foo/" },
+    { "basic functionality", "http://foo/{searchTerms}",
+      "http://foo/blah.blah.blah.blah.blah" }
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(generate_url_cases); ++i) {
+    TemplateURLData data;
+    data.SetURL(generate_url_cases[i].url);
+    TemplateURL t_url(data);
+    std::string result = TemplateURLService::GenerateSearchURL(
+        &t_url, search_terms_data).spec();
+    EXPECT_EQ(result, generate_url_cases[i].expected)
+        << generate_url_cases[i].test_name << " failed.";
+  }
 }
 
 TEST_F(TemplateURLServiceTest, ClearBrowsingData_Keywords) {
   Time now = Time::Now();
   TimeDelta one_day = TimeDelta::FromDays(1);
   Time month_ago = now - TimeDelta::FromDays(30);
 
   // Nothing has been added.
   EXPECT_EQ(0U, model()->GetTemplateURLs().size());
 
@@ skipping 107 matching lines @@
   // Add a new TemplateURL.
   test_util_.VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("google");
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://www.google.com/foo/bar");
   data.favicon_url = GURL("http://favicon.url");
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
-  TemplateURL* t_url = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url = new TemplateURL(data);
   model()->Add(t_url);
 
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
 
   StrictMock<base::MockTimeProvider> mock_time;
   model()->set_time_provider(&base::MockTimeProvider::StaticNow);
   EXPECT_CALL(mock_time, Now()).WillOnce(Return(base::Time::FromDoubleT(1337)));
 
   // Reset the short name, keyword, url and make sure it takes.
   const base::string16 new_short_name(ASCIIToUTF16("a"));
   const base::string16 new_keyword(ASCIIToUTF16("b"));
   const std::string new_url("c");
   model()->ResetTemplateURL(t_url, new_short_name, new_keyword, new_url);
   ASSERT_EQ(new_short_name, t_url->short_name());
   ASSERT_EQ(new_keyword, t_url->keyword());
   ASSERT_EQ(new_url, t_url->url());
 
   // Make sure the mappings in the model were updated.
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(new_keyword));
   ASSERT_TRUE(
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")) == NULL);
 
-  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->profile(),
-                                                     t_url->data()));
+  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
 
   // Reload the model from the database and make sure the change took.
   test_util_.ResetModel(true);
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   const TemplateURL* read_url = model()->GetTemplateURLForKeyword(new_keyword);
   ASSERT_TRUE(read_url);
   AssertEquals(*cloned_url, *read_url);
   ASSERT_EQ(base::Time::FromDoubleT(1337), read_url->last_modified());
 }
 
 TEST_F(TemplateURLServiceTest, DefaultSearchProvider) {
   // Add a new TemplateURL.
   test_util_.VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
   TemplateURL* t_url = AddKeywordWithDate(
       "name1", "key1", "http://foo1/{searchTerms}", "http://sugg1",
       std::string(), "http://icon1", true, "UTF-8;UTF-16", Time(), Time());
   test_util_.ResetObserverCount();
 
   model()->SetUserSelectedDefaultSearchProvider(t_url);
   ASSERT_EQ(t_url, model()->GetDefaultSearchProvider());
   ASSERT_TRUE(t_url->safe_for_autoreplace());
   ASSERT_TRUE(t_url->show_in_default_list());
 
   // Setting the default search provider should have caused notification.
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
 
-  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->profile(),
-                                                     t_url->data()));
+  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
 
   // Make sure when we reload we get a default search provider.
   test_util_.ResetModel(true);
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
   AssertEquals(*cloned_url, *model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceTest, CantReplaceWithSameKeyword) {
   test_util_.ChangeModelToLoadState();
@@ skipping 50 matching lines @@
   test_util_.VerifyLoad();
 
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("a");
   data.safe_for_autoreplace = true;
   data.SetURL("http://url/{searchTerms}");
   data.suggestions_url = "http://url2";
   data.instant_url = "http://instant";
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
-  TemplateURL* t_url = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url = new TemplateURL(data);
   model()->Add(t_url);
   const TemplateURLID id = t_url->id();
 
   model()->SetUserSelectedDefaultSearchProvider(t_url);
   base::RunLoop().RunUntilIdle();
-  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->profile(),
-                                                     t_url->data()));
+  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
 
   // Reset the model and don't load it. The template url we set as the default
   // should be pulled from prefs now.
   test_util_.ResetModel(false);
 
   // NOTE: This doesn't use AssertEquals as only a subset of the TemplateURLs
   // value are persisted to prefs.
   const TemplateURL* default_turl = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_turl);
   EXPECT_EQ(ASCIIToUTF16("a"), default_turl->short_name());
@@ skipping 40 matching lines @@
   model()->RegisterOmniboxKeyword("abcdefg", "extension_name", "bing.com");
   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("bing.com")));
 
   model()->RepairPrepopulatedSearchEngines();
 
   // Google is default.
   ASSERT_EQ(google, model()->GetDefaultSearchProvider());
   // The keyword wasn't reverted.
   EXPECT_EQ(ASCIIToUTF16("trash"), google->short_name());
   EXPECT_EQ("www.google.com",
-            TemplateURLService::GenerateSearchURL(google).host());
+            TemplateURLService::GenerateSearchURL(
+                google, model()->search_terms_data()).host());
 
   // Bing was repaired.
   bing = model()->GetTemplateURLForKeyword(ASCIIToUTF16("bing.com"));
   ASSERT_TRUE(bing);
   EXPECT_EQ(TemplateURL::NORMAL, bing->GetType());
 
   // User search engine is preserved.
   EXPECT_EQ(user_dse, model()->GetTemplateURLForHost("www.goo.com"));
   EXPECT_EQ(ASCIIToUTF16("google.com"), user_dse->keyword());
 }
@@ skipping 16 matching lines @@
   // Verify that the default manager we are getting is the managed one.
   TemplateURLData data;
   data.short_name = ASCIIToUTF16(kName);
   data.SetKeyword(ASCIIToUTF16(kKeyword));
   data.SetURL(kSearchURL);
   data.favicon_url = GURL(kIconURL);
   data.show_in_default_list = true;
   base::SplitString(kEncodings, ';', &data.input_encodings);
   data.alternate_urls.push_back(kAlternateURL);
   data.search_terms_replacement_key = kSearchTermsReplacementKey;
-  scoped_ptr<TemplateURL> expected_managed_default(new TemplateURL(
-      test_util_.profile(), data));
+  scoped_ptr<TemplateURL> expected_managed_default(new TemplateURL(data));
   EXPECT_TRUE(model()->is_default_search_managed());
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 
   // The following call has no effect on the managed search engine.
   model()->RepairPrepopulatedSearchEngines();
 
   EXPECT_TRUE(model()->is_default_search_managed());
   actual_managed_default = model()->GetDefaultSearchProvider();
@@ skipping 186 matching lines @@
 
 // Make sure that load routine doesn't delete prepopulated engines that no
 // longer exist in the prepopulate data if it has been modified by the user.
 TEST_F(TemplateURLServiceTest, LoadRetainsModifiedProvider) {
   // Create a preloaded template url and add it to a loaded model.
   TemplateURL* t_url = CreatePreloadedTemplateURL(false, 999999);
   test_util_.ChangeModelToLoadState();
   model()->Add(t_url);
 
   // Do the copy after t_url is added so that the id is set.
-  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->profile(),
-                                                     t_url->data()));
+  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")));
 
   // Wait for any saves to finish.
   base::RunLoop().RunUntilIdle();
 
   // Ensure that merging won't clear it if the user has edited it.
   test_util_.ResetModel(true);
   const TemplateURL* url_for_unittest =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
   ASSERT_TRUE(url_for_unittest != NULL);
   AssertEquals(*cloned_url, *url_for_unittest);
 
   // Wait for any saves to finish.
   base::RunLoop().RunUntilIdle();
 
   // Reload the model to verify that save/reload retains the item.
   test_util_.ResetModel(true);
   ASSERT_TRUE(
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")) != NULL);
 }
 
 // Make sure that load routine doesn't delete
 // prepopulated engines that no longer exist in the prepopulate data if
 // it has been modified by the user.
 TEST_F(TemplateURLServiceTest, LoadSavesPrepopulatedDefaultSearchProvider) {
   test_util_.VerifyLoad();
   // Verify that the default search provider is set to something.
   TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search != NULL);
-  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(default_search->profile(),
-                                                     default_search->data()));
+  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(default_search->data()));
 
   // Wait for any saves to finish.
   base::RunLoop().RunUntilIdle();
 
   // Reload the model and check that the default search provider
   // was properly saved.
   test_util_.ResetModel(true);
   default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search != NULL);
   AssertEquals(*cloned_url, *default_search);
 }
 
 // Make sure that the load routine doesn't delete
 // prepopulated engines that no longer exist in the prepopulate data if
 // it is the default search provider.
 TEST_F(TemplateURLServiceTest, LoadRetainsDefaultProvider) {
   // Set the default search provider to a preloaded template url which
   // is not in the current set of preloaded template urls and save
   // the result.
   TemplateURL* t_url = CreatePreloadedTemplateURL(true, 999999);
   test_util_.ChangeModelToLoadState();
   model()->Add(t_url);
   model()->SetUserSelectedDefaultSearchProvider(t_url);
   // Do the copy after t_url is added and set as default so that its
   // internal state is correct.
-  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->profile(),
-                                                     t_url->data()));
+  scoped_ptr<TemplateURL> cloned_url(new TemplateURL(t_url->data()));
 
   ASSERT_EQ(t_url, model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest")));
   ASSERT_EQ(t_url, model()->GetDefaultSearchProvider());
   base::RunLoop().RunUntilIdle();
 
   // Ensure that merging won't clear the prepopulated template url
   // which is no longer present if it's the default engine.
   test_util_.ResetModel(true);
   {
     const TemplateURL* keyword_url =
@@ skipping 97 matching lines @@
   // Verify that the default manager we are getting is the managed one.
   TemplateURLData data;
   data.short_name = ASCIIToUTF16(kName);
   data.SetKeyword(ASCIIToUTF16(kKeyword));
   data.SetURL(kSearchURL);
   data.favicon_url = GURL(kIconURL);
   data.show_in_default_list = true;
   base::SplitString(kEncodings, ';', &data.input_encodings);
   data.alternate_urls.push_back(kAlternateURL);
   data.search_terms_replacement_key = kSearchTermsReplacementKey;
-  Profile* profile = test_util_.profile();
-  scoped_ptr<TemplateURL> expected_managed_default1(new TemplateURL(profile,
-                                                                    data));
+  scoped_ptr<TemplateURL> expected_managed_default1(new TemplateURL(data));
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default1.get(), actual_managed_default);
   EXPECT_TRUE(actual_managed_default->show_in_default_list());
 
   // Update the managed preference and check that the model has changed.
   const char kNewName[] = "test2";
   const char kNewKeyword[] = "other.com";
   const char kNewSearchURL[] = "http://other.com/search?t={searchTerms}";
   const char kNewSuggestURL[] = "http://other.com/suggest?t={searchTerms}";
   test_util_.SetManagedDefaultSearchPreferences(true, kNewName, kNewKeyword,
       kNewSearchURL, kNewSuggestURL, std::string(), std::string(),
       std::string(), std::string());
   VerifyObserverFired();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size());
 
   // Verify that the default manager we are now getting is the correct one.
   TemplateURLData data2;
   data2.short_name = ASCIIToUTF16(kNewName);
   data2.SetKeyword(ASCIIToUTF16(kNewKeyword));
   data2.SetURL(kNewSearchURL);
   data2.suggestions_url = kNewSuggestURL;
   data2.show_in_default_list = true;
-  scoped_ptr<TemplateURL> expected_managed_default2(new TemplateURL(profile,
-                                                                    data2));
+  scoped_ptr<TemplateURL> expected_managed_default2(new TemplateURL(data2));
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default2.get(), actual_managed_default);
   EXPECT_EQ(actual_managed_default->show_in_default_list(), true);
 
   // Remove all the managed prefs and check that we are no longer managed.
   test_util_.RemoveManagedDefaultSearchPreferences();
   VerifyObserverFired();
   EXPECT_FALSE(model()->is_default_search_managed());
   EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
 
@@ skipping 53 matching lines @@
 TEST_F(TemplateURLServiceTest, PatchEmptySyncGUID) {
   // Add a new TemplateURL.
   test_util_.VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
 
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("google");
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://www.google.com/foo/bar");
   data.sync_guid.clear();
-  TemplateURL* t_url = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url = new TemplateURL(data);
   model()->Add(t_url);
 
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
 
   // Reload the model to verify it was actually saved to the database and
   // assigned a new GUID when brought back.
   test_util_.ResetModel(true);
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
@@ skipping 16 matching lines @@
   data.SetURL("http://www.google.com/foo/bar");
   std::vector<std::string> encodings;
   data.input_encodings.push_back("UTF-8");
   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");
-  TemplateURL* t_url = new TemplateURL(test_util_.profile(), data);
+  TemplateURL* t_url = new TemplateURL(data);
   model()->Add(t_url);
 
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   const TemplateURL* loaded_url =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_TRUE(loaded_url != NULL);
   EXPECT_EQ(8U, loaded_url->input_encodings().size());
 
@@ skipping 85 matching lines @@
   // Verify that the default manager we are getting is the managed one.
   TemplateURLData data;
   data.short_name = ASCIIToUTF16(kName);
   data.SetKeyword(ASCIIToUTF16(kKeyword));
   data.SetURL(kSearchURL);
   data.favicon_url = GURL(kIconURL);
   data.show_in_default_list = true;
   base::SplitString(kEncodings, ';', &data.input_encodings);
   data.alternate_urls.push_back(kAlternateURL);
   data.search_terms_replacement_key = kSearchTermsReplacementKey;
-  scoped_ptr<TemplateURL> expected_managed_default(new TemplateURL(
-      test_util_.profile(), data));
+  scoped_ptr<TemplateURL> expected_managed_default(new TemplateURL(data));
   EXPECT_TRUE(model()->is_default_search_managed());
   const TemplateURL* actual_managed_default =
       model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 
   TemplateURL* ext_dse = CreateKeywordWithDate(
       model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}",
       std::string(), std::string(), std::string(),
       true, true, "UTF-8", Time(), Time());
   scoped_ptr<AssociatedExtensionInfo> extension_info(
       new AssociatedExtensionInfo);
   extension_info->wants_to_be_default_engine = true;
   extension_info->extension_id = "ext1";
   model()->AddExtensionControlledTURL(ext_dse, extension_info.Pass());
   EXPECT_EQ(ext_dse, model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1")));
   EXPECT_TRUE(model()->is_default_search_managed());
   actual_managed_default = model()->GetDefaultSearchProvider();
   ExpectSimilar(expected_managed_default.get(), actual_managed_default);
 }