Omnibox - Strip Extra Whitespace from Custom Search Engine Names

components/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 "components/search_engines/template_url_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
@@ skipping 52 matching lines @@
     const std::string& url,
     const std::string& suggest_url,
     const std::string& alternate_url,
     const std::string& favicon_url,
     bool safe_for_autoreplace,
     bool show_in_default_list,
     const std::string& encodings,
     Time date_created,
     Time last_modified) {
   TemplateURLData data;
-  data.short_name = base::UTF8ToUTF16(short_name);
+  data.SetShortName(base::UTF8ToUTF16(short_name));
   data.SetKeyword(base::UTF8ToUTF16(keyword));
   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;
@@ skipping 158 matching lines @@
   // Because times are stored with a granularity of one second, there is a loss
   // of precision when serializing and deserializing the timestamps. Hence, only
   // expect timestamps to be equal to within one second of one another.
   ASSERT_LT((expected - actual).magnitude(), base::TimeDelta::FromSeconds(1));
 }
 
 TemplateURL* TemplateURLServiceTest::CreatePreloadedTemplateURL(
     bool safe_for_autoreplace,
     int prepopulate_id) {
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16("unittest");
+  data.SetShortName(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(data);
@@ skipping 15 matching lines @@
 TEST_F(TemplateURLServiceTest, Load) {
   test_util()->VerifyLoad();
 }
 
 TEST_F(TemplateURLServiceTest, AddUpdateRemove) {
   // Add a new TemplateURL.
   test_util()->VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
 
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16("google");
+  data.SetShortName(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(data);
   model()->Add(t_url);
   ASSERT_TRUE(model()->CanReplaceKeyword(ASCIIToUTF16("keyword"), GURL(),
@@ skipping 57 matching lines @@
   test_util()->VerifyLoad();
 
   AddKeywordWithDate(
       "first", "keyword", "http://test1", std::string(), std::string(),
       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.SetShortName(ASCIIToUTF16("second"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://test2");
   data.safe_for_autoreplace = false;
   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.SetShortName(ASCIIToUTF16("third"));
   data.SetURL("http://test3");
   data.safe_for_autoreplace = true;
   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.SetShortName(ASCIIToUTF16("fourth"));
   data.SetURL("http://test4");
   data.safe_for_autoreplace = false;
   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());
@@ skipping 51 matching lines @@
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_TRUE(extension);
   // Adding a keyword that matches the extension.
   AddKeywordWithDate(
       "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.SetShortName(ASCIIToUTF16("name1"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://test3");
   data.safe_for_autoreplace = true;
   TemplateURL* t_url = new TemplateURL(data);
   model()->Add(t_url);
   EXPECT_EQ(extension,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
   EXPECT_EQ(t_url, model()->GetTemplateURLForHost("test3"));
 
   // Adding a nonreplaceable keyword should remove the existing replaceable
   // keyword and replace the extension as the associated URL for this keyword,
   // but not evict the extension from the service entirely.
-  data.short_name = ASCIIToUTF16("name2");
+  data.SetShortName(ASCIIToUTF16("name2"));
   data.SetURL("http://test4");
   data.safe_for_autoreplace = false;
   TemplateURL* t_url2 = new TemplateURL(data);
   model()->Add(t_url2);
   EXPECT_EQ(t_url2,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword")));
 }
 
 TEST_F(TemplateURLServiceTest, NotPersistOmniboxExtensionKeyword) {
   test_util()->VerifyLoad();
@@ skipping 122 matching lines @@
   EXPECT_EQ(1U, model()->GetTemplateURLs().size());
   EXPECT_EQ(ASCIIToUTF16("key1"), model()->GetTemplateURLs()[0]->keyword());
   EXPECT_TRUE(model()->GetTemplateURLs()[0]->safe_for_autoreplace());
 }
 
 TEST_F(TemplateURLServiceTest, Reset) {
   // Add a new TemplateURL.
   test_util()->VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16("google");
+  data.SetShortName(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(data);
   model()->Add(t_url);
 
   VerifyObserverCount(1);
   base::RunLoop().RunUntilIdle();
@@ skipping 103 matching lines @@
   // Now force the model to load and make sure we still have a default.
   test_util()->VerifyLoad();
 
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceTest, DefaultSearchProviderLoadedFromPrefs) {
   test_util()->VerifyLoad();
 
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16("a");
+  data.SetShortName(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(data);
   model()->Add(t_url);
   const TemplateURLID id = t_url->id();
 
@@ skipping 83 matching lines @@
   const char kAlternateURL[] = "http://test.com/search#t={searchTerms}";
   const char kSearchTermsReplacementKey[] = "espv";
   test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword,
                                                   kSearchURL, std::string(),
                                                   kIconURL, kEncodings,
                                                   kAlternateURL,
                                                   kSearchTermsReplacementKey);
   test_util()->VerifyLoad();
   // Verify that the default manager we are getting is the managed one.
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16(kName);
+  data.SetShortName(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(data));
   EXPECT_TRUE(model()->is_default_search_managed());
   const TemplateURL* actual_managed_default =
@@ skipping 358 matching lines @@
   const char kSearchTermsReplacementKey[] = "espv";
   test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword,
       kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL,
       kSearchTermsReplacementKey);
   VerifyObserverFired();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size());
 
   // Verify that the default manager we are getting is the managed one.
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16(kName);
+  data.SetShortName(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_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.SetShortName(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(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.
@@ skipping 54 matching lines @@
 }
 
 // Test that if we load a TemplateURL with an empty GUID, the load process
 // assigns it a newly generated GUID.
 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.SetShortName(ASCIIToUTF16("google"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   data.SetURL("http://www.google.com/foo/bar");
   data.sync_guid.clear();
   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());
   const TemplateURL* loaded_url =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
   ASSERT_FALSE(loaded_url == NULL);
   ASSERT_FALSE(loaded_url->sync_guid().empty());
 }
 
 // Test that if we load a TemplateURL with duplicate input encodings, the load
 // process de-dupes them.
 TEST_F(TemplateURLServiceTest, DuplicateInputEncodings) {
   // Add a new TemplateURL.
   test_util()->VerifyLoad();
   const size_t initial_count = model()->GetTemplateURLs().size();
 
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16("google");
+  data.SetShortName(ASCIIToUTF16("google"));
   data.SetKeyword(ASCIIToUTF16("keyword"));
   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");
@@ skipping 90 matching lines @@
   const char kIconURL[] = "http://test.com/icon.jpg";
   const char kEncodings[] = "UTF-16;UTF-32";
   const char kAlternateURL[] = "http://test.com/search#t={searchTerms}";
   const char kSearchTermsReplacementKey[] = "espv";
   test_util()->SetManagedDefaultSearchPreferences(
       true, kName, kKeyword, kSearchURL, std::string(), kIconURL, kEncodings,
       kAlternateURL, kSearchTermsReplacementKey);
   test_util()->VerifyLoad();
   // Verify that the default manager we are getting is the managed one.
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16(kName);
+  data.SetShortName(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(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<TemplateURL::AssociatedExtensionInfo> extension_info(
       new TemplateURL::AssociatedExtensionInfo(
           TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, "ext1"));
   extension_info->wants_to_be_default_engine = true;
   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);
 }