Add four new sync integration tests for custom search engines.

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 68 matching lines @@
 
 bool ServiceMatchesVerifier(int profile) {
   TemplateURLService* verifier = GetVerifierService();
   TemplateURLService* other = GetServiceForProfile(profile);
 
   CHECK(verifier);
   CHECK(other);
 
   std::vector<const TemplateURL*> verifier_turls = verifier->GetTemplateURLs();
   if (verifier_turls.size() != other->GetTemplateURLs().size()) {
-    LOG(ERROR) << "verifier and other service have a different count of TURLs: "
+    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);
     const TemplateURL* other_turl = other->GetTemplateURLForKeyword(
         verifier_turl->keyword());
@@ skipping 49 matching lines @@
   } else {
     LOG(INFO) << "A had default with URL: " << default_a->url()->url()
               << " and keyword: " << default_a->keyword();
   }
 
   return true;
 }
 
 bool AllServicesMatch() {
   // Use 0 as the baseline.
-  if (!ServiceMatchesVerifier(0))
+  if (!ServiceMatchesVerifier(0)) {
+    LOG(ERROR) << "TemplateURLService 0 does not match verifier.";
     return false;
+  }
 
   for (int it = 0; it < test()->num_clients(); ++it) {
     if (!ServicesMatch(0, it)) {
       LOG(ERROR) << "TemplateURLService " << it << " does not match with "
                  << "service 0.";
       return false;
     }
   }
   return true;
 }
@@ skipping 13 matching lines @@
   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));
   return turl;
 }
 
 void AddSearchEngine(int profile, int seed) {
-  GetServiceForProfile(profile)->Add(CreateTestTemplateURL(seed));
+  if (profile != -1)
+    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 std::string& url) {
-  const TemplateURL* turl = GetServiceForProfile(profile)->
+  if (profile != -1) {
+    const TemplateURL* turl = GetServiceForProfile(profile)->
       GetTemplateURLForKeyword(ASCIIToUTF16(keyword));
-  EXPECT_TRUE(turl);
-  GetServiceForProfile(profile)->ResetTemplateURL(turl,
-                                                  ASCIIToUTF16(short_name),
-                                                  ASCIIToUTF16(new_keyword),
-                                                  url);
+    EXPECT_TRUE(turl);
+    GetServiceForProfile(profile)->ResetTemplateURL(turl,
+                                                    ASCIIToUTF16(short_name),
+                                                    ASCIIToUTF16(new_keyword),
+                                                    url);
+  }
   // Make sure we do the same on the verifier.
   if (test()->use_verifier()) {
     const TemplateURL* verifier_turl =
         GetVerifierService()->GetTemplateURLForKeyword(ASCIIToUTF16(keyword));
     EXPECT_TRUE(verifier_turl);
     GetVerifierService()->ResetTemplateURL(verifier_turl,
                                            ASCIIToUTF16(short_name),
                                            ASCIIToUTF16(new_keyword),
                                            url);
   }
 }
 
 void DeleteSearchEngineByKeyword(int profile, const string16 keyword) {
-  const TemplateURL* turl = GetServiceForProfile(profile)->
-      GetTemplateURLForKeyword(keyword);
-  EXPECT_TRUE(turl);
-  GetServiceForProfile(profile)->Remove(turl);
+  if (profile != -1) {
+    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* new_default = service->GetTemplateURLForKeyword(
-      CreateKeyword(seed));
-  ASSERT_TRUE(new_default);
-  service->SetDefaultSearchProvider(new_default);
+  if (profile != -1) {
+    TemplateURLService* service = GetServiceForProfile(profile);
+    ASSERT_TRUE(service);
+    const TemplateURL* turl = service->GetTemplateURLForKeyword(
+        CreateKeyword(seed));
+    ASSERT_TRUE(turl);
+    service->SetDefaultSearchProvider(turl);
+  }
   if (test()->use_verifier()) {
-    new_default = GetVerifierService()->GetTemplateURLForKeyword(
-        CreateKeyword(seed));
-    ASSERT_TRUE(new_default);
-    GetVerifierService()->SetDefaultSearchProvider(new_default);
+    const TemplateURL* verifier_turl =
+        GetVerifierService()->GetTemplateURLForKeyword(CreateKeyword(seed));
+    ASSERT_TRUE(verifier_turl);
+    GetVerifierService()->SetDefaultSearchProvider(verifier_turl);
   }
 }
 
 }  // namespace search_engines_helper