Clean up some sync integration test code.

chrome/browser/sync/test/integration/search_engines_helper.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/test/integration/search_engines_helper.h"
 
 #include <vector>
 
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 16 matching lines @@
 }
 
 TemplateURLService* GetVerifierService() {
   return TemplateURLServiceFactory::GetForProfile(test()->verifier());
 }
 
 GUIDToTURLMap CreateGUIDToTURLMap(TemplateURLService* service) {
   CHECK(service);
 
   GUIDToTURLMap map;
-  std::vector<const TemplateURL*> turls = service->GetTemplateURLs();
-  for (std::vector<const TemplateURL*>::iterator it = turls.begin();
+  TemplateURLService::TemplateURLVector turls = service->GetTemplateURLs();
+  for (TemplateURLService::TemplateURLVector::iterator it = turls.begin();
        it != turls.end(); ++it) {
     CHECK(*it);
     CHECK(map.find((*it)->sync_guid()) == map.end());
     map[(*it)->sync_guid()] = *it;
   }
 
   return map;
 }
 
 std::string GetTURLInfoString(const TemplateURL* turl) {
@@ skipping 28 matching lines @@
   return result;
 }
 
 bool ServiceMatchesVerifier(int profile) {
   TemplateURLService* verifier = GetVerifierService();
   TemplateURLService* other = GetServiceForProfile(profile);
 
   CHECK(verifier);
   CHECK(other);
 
-  std::vector<const TemplateURL*> verifier_turls = verifier->GetTemplateURLs();
+  TemplateURLService::TemplateURLVector verifier_turls =
+      verifier->GetTemplateURLs();
   if (verifier_turls.size() != other->GetTemplateURLs().size()) {
     LOG(ERROR) << "Verifier and other service have a different count of TURLs: "
                << verifier_turls.size() << " vs "
                << other->GetTemplateURLs().size() << " respectively.";
     return false;
   }
 
   for (size_t i = 0; i < verifier_turls.size(); ++i) {
     const TemplateURL* verifier_turl = verifier_turls.at(i);
     CHECK(verifier_turl);
@@ skipping 73 matching lines @@
   return true;
 }
 
 // Convenience helper for consistently generating the same keyword for a given
 // seed.
 string16 CreateKeyword(int seed) {
   return ASCIIToUTF16(base::StringPrintf("test%d", seed));
 }
 
 TemplateURL* CreateTestTemplateURL(int seed) {
+  return CreateTestTemplateURL(seed, CreateKeyword(seed),
+                               base::StringPrintf("0000-0000-0000-%04d", seed));
+}
+
+TemplateURL* CreateTestTemplateURL(int seed,
+                                   const string16& keyword,
+                                   const std::string& sync_guid) {
+  return CreateTestTemplateURL(seed,
+      base::StringPrintf("http://www.test%d.com/", seed), keyword, sync_guid);
+}
+
+TemplateURL* CreateTestTemplateURL(int seed,
+                                   const std::string& url,
+                                   const string16& keyword,
+                                   const std::string& sync_guid) {
   TemplateURL* turl = new TemplateURL();
-  turl->SetURL(base::StringPrintf("http://www.test%d.com/", seed), 0, 0);
-  turl->set_keyword(CreateKeyword(seed));
-  turl->set_short_name(ASCIIToUTF16(base::StringPrintf("test%d", seed)));
+  turl->set_short_name(CreateKeyword(seed));
+  turl->set_keyword(keyword);
   turl->set_safe_for_autoreplace(true);
-  GURL favicon_url("http://favicon.url");
-  turl->SetFaviconURL(favicon_url);
   turl->set_date_created(base::Time::FromTimeT(100));
   turl->set_last_modified(base::Time::FromTimeT(100));
   turl->SetPrepopulateId(999999);
-  turl->set_sync_guid(base::StringPrintf("0000-0000-0000-%04d", seed));
+  turl->set_sync_guid(sync_guid);
+  turl->SetURL(url, 0, 0);
+  turl->SetFaviconURL(GURL("http://favicon.url"));
   return turl;
 }
 
 void AddSearchEngine(int profile, int seed) {
   GetServiceForProfile(profile)->Add(CreateTestTemplateURL(seed));
   if (test()->use_verifier())
     GetVerifierService()->Add(CreateTestTemplateURL(seed));
 }
 
 void EditSearchEngine(int profile,
-                      const std::string& keyword,
-                      const std::string& short_name,
-                      const std::string& new_keyword,
+                      const string16& keyword,
+                      const string16& short_name,
+                      const string16& new_keyword,
                       const std::string& url) {
-  const TemplateURL* turl = GetServiceForProfile(profile)->
-      GetTemplateURLForKeyword(ASCIIToUTF16(keyword));
+  DCHECK(!url.empty());
+  const TemplateURL* turl =
+      GetServiceForProfile(profile)->GetTemplateURLForKeyword(keyword);
   EXPECT_TRUE(turl);
-  GetServiceForProfile(profile)->ResetTemplateURL(turl,
-                                                  ASCIIToUTF16(short_name),
-                                                  ASCIIToUTF16(new_keyword),
+  ASSERT_FALSE(new_keyword.empty());
+  GetServiceForProfile(profile)->ResetTemplateURL(turl, short_name, new_keyword,
                                                   url);
   // Make sure we do the same on the verifier.
   if (test()->use_verifier()) {
     const TemplateURL* verifier_turl =
-        GetVerifierService()->GetTemplateURLForKeyword(ASCIIToUTF16(keyword));
+        GetVerifierService()->GetTemplateURLForKeyword(keyword);
     EXPECT_TRUE(verifier_turl);
-    GetVerifierService()->ResetTemplateURL(verifier_turl,
-                                           ASCIIToUTF16(short_name),
-                                           ASCIIToUTF16(new_keyword),
-                                           url);
+    GetVerifierService()->ResetTemplateURL(verifier_turl, short_name,
+                                           new_keyword, url);
   }
 }
 
-void DeleteSearchEngineByKeyword(int profile, const string16 keyword) {
-  const TemplateURL* turl = GetServiceForProfile(profile)->
-      GetTemplateURLForKeyword(keyword);
+void DeleteSearchEngineByKeyword(int profile, const string16& keyword) {
+  const TemplateURL* turl =
+      GetServiceForProfile(profile)->GetTemplateURLForKeyword(keyword);
   EXPECT_TRUE(turl);
   GetServiceForProfile(profile)->Remove(turl);
   // Make sure we do the same on the verifier.
   if (test()->use_verifier()) {
     const TemplateURL* verifier_turl =
         GetVerifierService()->GetTemplateURLForKeyword(keyword);
     EXPECT_TRUE(verifier_turl);
     GetVerifierService()->Remove(verifier_turl);
   }
 }
 
 void DeleteSearchEngineBySeed(int profile, int seed) {
   DeleteSearchEngineByKeyword(profile, CreateKeyword(seed));
 }
 
 void ChangeDefaultSearchProvider(int profile, int seed) {
   TemplateURLService* service = GetServiceForProfile(profile);
   ASSERT_TRUE(service);
-  const TemplateURL* turl = service->GetTemplateURLForKeyword(
-      CreateKeyword(seed));
+  const TemplateURL* turl =
+      service->GetTemplateURLForKeyword(CreateKeyword(seed));
   ASSERT_TRUE(turl);
   service->SetDefaultSearchProvider(turl);
   if (test()->use_verifier()) {
     const TemplateURL* verifier_turl =
         GetVerifierService()->GetTemplateURLForKeyword(CreateKeyword(seed));
     ASSERT_TRUE(verifier_turl);
     GetVerifierService()->SetDefaultSearchProvider(verifier_turl);
   }
 }
 
 }  // namespace search_engines_helper