Move the URL string from TemplateURLRef onto the owning TemplateURL. This will make it easier to m…

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/string_split.h"
@@ skipping 240 matching lines @@
   t_url->SetSuggestionsURL(suggest_url);
   t_url->SetURL(url);
   t_url->set_favicon_url(GURL(favicon_url));
   model()->Add(t_url);
   EXPECT_NE(0, t_url->id());
   return t_url;
 }
 
 void TemplateURLServiceTest::AssertEquals(const TemplateURL& expected,
                                           const TemplateURL& actual) {
-  ASSERT_TRUE(TemplateURLRef::SameUrlRefs(expected.url(), actual.url()));
-  ASSERT_TRUE(TemplateURLRef::SameUrlRefs(expected.suggestions_url(),
-                                          actual.suggestions_url()));
+  ASSERT_EQ(expected.short_name(), actual.short_name());
+  ASSERT_EQ(expected.url(), actual.url());
+  ASSERT_EQ(expected.suggestions_url(), actual.suggestions_url());
   ASSERT_EQ(expected.keyword(), actual.keyword());
-  ASSERT_EQ(expected.short_name(), actual.short_name());
-  ASSERT_EQ(JoinString(expected.input_encodings(), ';'),
-            JoinString(actual.input_encodings(), ';'));
+  ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
+  ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace());
   ASSERT_EQ(expected.favicon_url(), actual.favicon_url());
-  ASSERT_EQ(expected.id(), actual.id());
-  ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace());
-  ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
   ASSERT_EQ(expected.date_created(), actual.date_created());
   ASSERT_EQ(expected.last_modified(), actual.last_modified());
+  ASSERT_EQ(expected.input_encodings(), actual.input_encodings());
+  ASSERT_EQ(expected.id(), actual.id());
   ASSERT_EQ(expected.sync_guid(), actual.sync_guid());
 }
 
 void TemplateURLServiceTest::ExpectSimilar(const TemplateURL* expected,
                                            const TemplateURL* actual) {
   ASSERT_TRUE(expected != NULL);
   ASSERT_TRUE(actual != NULL);
-  EXPECT_TRUE(TemplateURLRef::SameUrlRefs(expected->url(), actual->url()));
-  EXPECT_TRUE(TemplateURLRef::SameUrlRefs(expected->suggestions_url(),
-                                          actual->suggestions_url()));
+  EXPECT_EQ(expected->short_name(), actual->short_name());
+  EXPECT_EQ(expected->url(), actual->url());
+  EXPECT_EQ(expected->suggestions_url(), actual->suggestions_url());
   EXPECT_EQ(expected->keyword(), actual->keyword());
-  EXPECT_EQ(expected->short_name(), actual->short_name());
-  EXPECT_EQ(JoinString(expected->input_encodings(), ';'),
-            JoinString(actual->input_encodings(), ';'));
+  EXPECT_EQ(expected->show_in_default_list(), actual->show_in_default_list());
+  EXPECT_EQ(expected->safe_for_autoreplace(), actual->safe_for_autoreplace());
   EXPECT_EQ(expected->favicon_url(), actual->favicon_url());
-  EXPECT_EQ(expected->safe_for_autoreplace(), actual->safe_for_autoreplace());
-  EXPECT_EQ(expected->show_in_default_list(), actual->show_in_default_list());
+  EXPECT_EQ(expected->input_encodings(), actual->input_encodings());
 }
 
 void TemplateURLServiceTest::SetManagedDefaultSearchPreferences(
     bool enabled,
     const std::string& name,
     const std::string& search_url,
     const std::string& suggest_url,
     const std::string& icon_url,
     const std::string& encodings,
     const std::string& keyword) {
@@ skipping 35 matching lines @@
   size_t default_search_provider_index = 0;
   TemplateURLPrepopulateData::GetPrepopulatedEngines(
       test_util_.profile()->GetPrefs(), &prepopulated_urls.get(),
       &default_search_provider_index);
   EXPECT_LT(index_offset_from_default, prepopulated_urls.size());
   size_t prepopulated_index = (default_search_provider_index +
       index_offset_from_default) % prepopulated_urls.size();
   TemplateURL* t_url = CreatePreloadedTemplateURL(safe_for_autoreplace,
       prepopulated_urls[prepopulated_index]->prepopulate_id());
   *prepopulated_display_url =
-      prepopulated_urls[prepopulated_index]->url()->DisplayURL();
+      prepopulated_urls[prepopulated_index]->url_ref().DisplayURL();
   return t_url;
 }
 
 void TemplateURLServiceTest::TestLoadUpdatingPreloadedURL(
     size_t index_offset_from_default) {
   string16 prepopulated_url;
   TemplateURL* t_url = CreateReplaceablePreloadedTemplateURL(false,
       index_offset_from_default, &prepopulated_url);
 
-  string16 original_url = t_url->url()->DisplayURL();
+  string16 original_url = t_url->url_ref().DisplayURL();
   ASSERT_NE(prepopulated_url, original_url);
 
   // Then add it to the model and save it all.
   test_util_.ChangeModelToLoadState();
   model()->Add(t_url);
   const TemplateURL* keyword_url =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
   ASSERT_EQ(t_url, keyword_url);
-  ASSERT_EQ(original_url, keyword_url->url()->DisplayURL());
+  ASSERT_EQ(original_url, keyword_url->url_ref().DisplayURL());
   test_util_.BlockTillServiceProcessesRequests();
 
   // Now reload the model and verify that the merge updates the url.
   test_util_.ResetModel(true);
   keyword_url = model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
   ASSERT_TRUE(keyword_url != NULL);
-  ASSERT_EQ(prepopulated_url, keyword_url->url()->DisplayURL());
+  ASSERT_EQ(prepopulated_url, keyword_url->url_ref().DisplayURL());
 
   // Wait for any saves to finish.
   test_util_.BlockTillServiceProcessesRequests();
 
   // Reload the model to verify that change was saved correctly.
   test_util_.ResetModel(true);
   keyword_url = model()->GetTemplateURLForKeyword(ASCIIToUTF16("unittest"));
   ASSERT_TRUE(keyword_url != NULL);
-  ASSERT_EQ(prepopulated_url, keyword_url->url()->DisplayURL());
+  ASSERT_EQ(prepopulated_url, keyword_url->url_ref().DisplayURL());
 }
 
 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 47 matching lines @@
   // 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()->url());
+  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 = *loaded_url;
   test_util_.BlockTillServiceProcessesRequests();
   test_util_.ResetModel(true);
   ASSERT_EQ(initial_count + 1, model()->GetTemplateURLs().size());
   loaded_url = model()->GetTemplateURLForKeyword(ASCIIToUTF16("b"));
   ASSERT_TRUE(loaded_url != NULL);
@@ skipping 186 matching lines @@
   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 string16 new_short_name(ASCIIToUTF16("a"));
   const 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()->url());
+  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);
 
   TemplateURL last_url(*t_url);
 
   // Reload the model from the database and make sure the change took.
   test_util_.ResetModel(true);
@@ skipping 64 matching lines @@
       "http://sugg1", "http://icon1", "UTF-8;UTF-16",  "name1", true, Time(),
       Time());
 
   // Can still replace, newly added template url is marked safe to replace.
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("foo"),
                                          GURL("http://foo2"), NULL));
 
   // ResetTemplateURL marks the TemplateURL as unsafe to replace, so it should
   // no longer be replaceable.
   model()->ResetTemplateURL(t_url, t_url->short_name(), t_url->keyword(),
-                            t_url->url()->url());
+                            t_url->url());
 
   ASSERT_FALSE(model()->CanReplaceKeyword(ASCIIToUTF16("foo"),
                                           GURL("http://foo2"), NULL));
 }
 
 TEST_F(TemplateURLServiceTest, CantReplaceWithSameHosts) {
   test_util_.ChangeModelToLoadState();
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("foo"),
                                          GURL("http://foo.com"), NULL));
   TemplateURL* t_url = AddKeywordWithDate("foo", false, "http://foo.com",
       "http://sugg1", "http://icon1", "UTF-8;UTF-16",  "name1", true, Time(),
       Time());
 
   // Can still replace, newly added template url is marked safe to replace.
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("bar"),
                                          GURL("http://foo.com"), NULL));
 
   // ResetTemplateURL marks the TemplateURL as unsafe to replace, so it should
   // no longer be replaceable.
   model()->ResetTemplateURL(t_url, t_url->short_name(), t_url->keyword(),
-                            t_url->url()->url());
+                            t_url->url());
 
   ASSERT_FALSE(model()->CanReplaceKeyword(ASCIIToUTF16("bar"),
                                           GURL("http://foo.com"), NULL));
 }
 
 TEST_F(TemplateURLServiceTest, HasDefaultSearchProvider) {
   // We should have a default search provider even if we haven't loaded.
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 
   // Now force the model to load and make sure we still have a default.
@@ skipping 21 matching lines @@
   TemplateURL first_default_search_provider(*t_url);
 
   // 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);
-  ASSERT_TRUE(default_turl->url());
-  ASSERT_EQ("http://url", default_turl->url()->url());
-  ASSERT_TRUE(default_turl->suggestions_url());
-  ASSERT_EQ("http://url2", default_turl->suggestions_url()->url());
-  ASSERT_TRUE(default_turl->instant_url());
-  EXPECT_EQ("http://instant", default_turl->instant_url()->url());
+  ASSERT_EQ("http://url", default_turl->url());
+  ASSERT_EQ("http://url2", default_turl->suggestions_url());
+  EXPECT_EQ("http://instant", default_turl->instant_url());
   ASSERT_EQ(ASCIIToUTF16("a"), default_turl->short_name());
   ASSERT_EQ(id, default_turl->id());
 
   // Now do a load and make sure the default search provider really takes.
   test_util_.VerifyLoad();
 
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
   AssertEquals(first_default_search_provider,
                *model()->GetDefaultSearchProvider());
 }
@@ skipping 97 matching lines @@
 TEST_F(TemplateURLServiceTest, ChangeGoogleBaseValue) {
   // NOTE: Do not do a VerifyLoad() here as it will load the prepopulate data,
   // which also has a {google:baseURL} keyword in it, which will confuse this
   // test.
   test_util_.ChangeModelToLoadState();
   test_util_.SetGoogleBaseURL("http://google.com/");
   const TemplateURL* t_url = AddKeywordWithDate("google.com", true,
       "{google:baseURL}?q={searchTerms}", "http://sugg1", "http://icon1",
       "UTF-8;UTF-16", "name", false, Time(), Time());
   ASSERT_EQ(t_url, model()->GetTemplateURLForHost("google.com"));
-  EXPECT_EQ("google.com", t_url->url()->GetHost());
+  EXPECT_EQ("google.com", t_url->url_ref().GetHost());
   EXPECT_EQ(ASCIIToUTF16("google.com"), t_url->keyword());
 
   // Change the Google base url.
   test_util_.ResetObserverCount();
   test_util_.SetGoogleBaseURL("http://google.co.uk/");
   VerifyObserverCount(1);
 
   // Make sure the host->TemplateURL map was updated appropriately.
   ASSERT_EQ(t_url, model()->GetTemplateURLForHost("google.co.uk"));
   EXPECT_TRUE(model()->GetTemplateURLForHost("google.com") == NULL);
-  EXPECT_EQ("google.co.uk", t_url->url()->GetHost());
+  EXPECT_EQ("google.co.uk", t_url->url_ref().GetHost());
   EXPECT_EQ(ASCIIToUTF16("google.co.uk"), t_url->keyword());
-  EXPECT_EQ("http://google.co.uk/?q=x", t_url->url()->ReplaceSearchTerms(
+  EXPECT_EQ("http://google.co.uk/?q=x", t_url->url_ref().ReplaceSearchTerms(
       ASCIIToUTF16("x"), TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
 }
 
 struct QueryHistoryCallbackImpl {
   QueryHistoryCallbackImpl() : success(false) {}
 
   void Callback(HistoryService::Handle handle,
                 bool success,
                 const history::URLRow* row,
                 history::VisitVector* visits) {
@@ skipping 18 matching lines @@
   // Create a keyword.
   TemplateURL* t_url = AddKeywordWithDate(
       "keyword", false, "http://foo.com/foo?query={searchTerms}",
       "http://sugg1", "http://icon1", "UTF-8;UTF-16", "keyword",
       true, base::Time::Now(), base::Time::Now());
 
   // Add a visit that matches the url of the keyword.
   HistoryService* history =
       test_util_.profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   history->AddPage(
-      GURL(t_url->url()->ReplaceSearchTerms(ASCIIToUTF16("blah"),
+      GURL(t_url->url_ref().ReplaceSearchTerms(ASCIIToUTF16("blah"),
           TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16())),
       NULL, 0, GURL(), content::PAGE_TRANSITION_KEYWORD,
       history::RedirectList(), history::SOURCE_BROWSED, false);
 
   // Wait for history to finish processing the request.
   test_util_.profile()->BlockUntilHistoryProcessesPendingRequests();
 
   // Query history for the generated url.
   CancelableRequestConsumer consumer;
   QueryHistoryCallbackImpl callback;
@@ skipping 328 matching lines @@
 
   // 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());
   const TemplateURL* loaded_url =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_TRUE(loaded_url != NULL);
   ASSERT_FALSE(loaded_url->sync_guid().empty());
 }