components/search_engines/template_url_service_sync_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "base/memory/scoped_vector.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/run_loop.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/time/time.h"
  12 #include "chrome/browser/search_engines/template_url_service_test_util.h"
  13 #include "chrome/test/base/testing_pref_service_syncable.h"
  14 #include "chrome/test/base/testing_profile.h"
  15 #include "components/search_engines/search_engines_pref_names.h"
  16 #include "components/search_engines/search_terms_data.h"
  17 #include "components/search_engines/template_url.h"
  18 #include "components/search_engines/template_url_prepopulate_data.h"
  19 #include "components/search_engines/template_url_service.h"
  20 #include "components/search_engines/template_url_service_client.h"
  21 #include "net/base/net_util.h"
  22 #include "sync/api/sync_change_processor_wrapper_for_test.h"
  23 #include "sync/api/sync_error_factory.h"
  24 #include "sync/api/sync_error_factory_mock.h"
  25 #include "sync/protocol/search_engine_specifics.pb.h"
  26 #include "sync/protocol/sync.pb.h"
  27 #include "testing/gtest/include/gtest/gtest.h"
  28
  29 using base::ASCIIToUTF16;
  30 using base::UTF8ToUTF16;
  31 using base::Time;
  32
  33 namespace {
  34
  35 // Extract the GUID from a search engine syncer::SyncData.
  36 std::string GetGUID(const syncer::SyncData& sync_data) {
  37   return sync_data.GetSpecifics().search_engine().sync_guid();
  38 }
  39
  40 // Extract the URL from a search engine syncer::SyncData.
  41 std::string GetURL(const syncer::SyncData& sync_data) {
  42   return sync_data.GetSpecifics().search_engine().url();
  43 }
  44
  45 // Extract the keyword from a search engine syncer::SyncData.
  46 std::string GetKeyword(const syncer::SyncData& sync_data) {
  47   return sync_data.GetSpecifics().search_engine().keyword();
  48 }
  49
  50 // Much like TemplateURLService::CreateSyncDataFromTemplateURL(), but allows the
  51 // caller to override the keyword, URL, or GUID fields with empty strings, in
  52 // order to create custom data that should be handled specially when synced to a
  53 // client.
  54 syncer::SyncData CreateCustomSyncData(const TemplateURL& turl,
  55                               bool autogenerate_keyword,
  56                               const std::string& url,
  57                               const std::string& sync_guid) {
  58   sync_pb::EntitySpecifics specifics;
  59   sync_pb::SearchEngineSpecifics* se_specifics =
  60       specifics.mutable_search_engine();
  61   se_specifics->set_short_name(base::UTF16ToUTF8(turl.short_name()));
  62   se_specifics->set_keyword(
  63       autogenerate_keyword ? std::string() : base::UTF16ToUTF8(turl.keyword()));
  64   se_specifics->set_favicon_url(turl.favicon_url().spec());
  65   se_specifics->set_url(url);
  66   se_specifics->set_safe_for_autoreplace(turl.safe_for_autoreplace());
  67   se_specifics->set_originating_url(turl.originating_url().spec());
  68   se_specifics->set_date_created(turl.date_created().ToInternalValue());
  69   se_specifics->set_input_encodings(JoinString(turl.input_encodings(), ';'));
  70   se_specifics->set_show_in_default_list(turl.show_in_default_list());
  71   se_specifics->set_suggestions_url(turl.suggestions_url());
  72   se_specifics->set_prepopulate_id(turl.prepopulate_id());
  73   se_specifics->set_autogenerate_keyword(autogenerate_keyword);
  74   se_specifics->set_instant_url(turl.instant_url());
  75   se_specifics->set_last_modified(turl.last_modified().ToInternalValue());
  76   se_specifics->set_sync_guid(sync_guid);
  77   return syncer::SyncData::CreateLocalData(turl.sync_guid(),  // Must be valid!
  78                                    se_specifics->keyword(), specifics);
  79 }
  80
  81
  82 // TestChangeProcessor --------------------------------------------------------
  83
  84 // Dummy SyncChangeProcessor used to help review what SyncChanges are pushed
  85 // back up to Sync.
  86 class TestChangeProcessor : public syncer::SyncChangeProcessor {
  87  public:
  88   TestChangeProcessor();
  89   virtual ~TestChangeProcessor();
  90
  91   // Store a copy of all the changes passed in so we can examine them later.
  92   virtual syncer::SyncError ProcessSyncChanges(
  93       const tracked_objects::Location& from_here,
  94       const syncer::SyncChangeList& change_list) override;
  95
  96   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
  97       override {
  98     return syncer::SyncDataList();
  99   }
 100
 101   bool contains_guid(const std::string& guid) const {
 102     return change_map_.count(guid) != 0;
 103   }
 104
 105   syncer::SyncChange change_for_guid(const std::string& guid) const {
 106     DCHECK(contains_guid(guid));
 107     return change_map_.find(guid)->second;
 108   }
 109
 110   size_t change_list_size() { return change_map_.size(); }
 111
 112   void set_erroneous(bool erroneous) { erroneous_ = erroneous; }
 113
 114  private:
 115   // Track the changes received in ProcessSyncChanges.
 116   std::map<std::string, syncer::SyncChange> change_map_;
 117   bool erroneous_;
 118
 119   DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor);
 120 };
 121
 122 TestChangeProcessor::TestChangeProcessor() : erroneous_(false) {
 123 }
 124
 125 TestChangeProcessor::~TestChangeProcessor() {
 126 }
 127
 128 syncer::SyncError TestChangeProcessor::ProcessSyncChanges(
 129     const tracked_objects::Location& from_here,
 130     const syncer::SyncChangeList& change_list) {
 131   if (erroneous_)
 132     return syncer::SyncError(
 133         FROM_HERE,
 134         syncer::SyncError::DATATYPE_ERROR,
 135         "Some error.",
 136         syncer::SEARCH_ENGINES);
 137
 138   change_map_.erase(change_map_.begin(), change_map_.end());
 139   for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
 140       iter != change_list.end(); ++iter)
 141     change_map_[GetGUID(iter->sync_data())] = *iter;
 142   return syncer::SyncError();
 143 }
 144
 145
 146 }  // namespace
 147
 148
 149 // TemplateURLServiceSyncTest -------------------------------------------------
 150
 151 class TemplateURLServiceSyncTest : public testing::Test {
 152  public:
 153   typedef TemplateURLService::SyncDataMap SyncDataMap;
 154
 155   TemplateURLServiceSyncTest();
 156
 157   virtual void SetUp() override;
 158   virtual void TearDown() override;
 159
 160   TemplateURLService* model() { return test_util_a_->model(); }
 161   // For readability, we redefine an accessor for Model A for use in tests that
 162   // involve syncing two models.
 163   TemplateURLService* model_a() { return test_util_a_->model(); }
 164   TemplateURLService* model_b() { return test_util_b_->model(); }
 165   TestingProfile* profile_a() { return test_util_a_->profile(); }
 166   TestChangeProcessor* processor() { return sync_processor_.get(); }
 167   scoped_ptr<syncer::SyncChangeProcessor> PassProcessor();
 168   scoped_ptr<syncer::SyncErrorFactory> CreateAndPassSyncErrorFactory();
 169
 170   // Creates a TemplateURL with some test values. The caller owns the returned
 171   // TemplateURL*.
 172   TemplateURL* CreateTestTemplateURL(const base::string16& keyword,
 173                                      const std::string& url,
 174                                      const std::string& guid = std::string(),
 175                                      time_t last_mod = 100,
 176                                      bool safe_for_autoreplace = false,
 177                                      bool created_by_policy = false) const;
 178
 179   // Verifies the two TemplateURLs are equal.
 180   // TODO(stevet): Share this with TemplateURLServiceTest.
 181   void AssertEquals(const TemplateURL& expected,
 182                     const TemplateURL& actual) const;
 183
 184   // Expect that two syncer::SyncDataLists have equal contents, in terms of the
 185   // sync_guid, keyword, and url fields.
 186   void AssertEquals(const syncer::SyncDataList& data1,
 187                     const syncer::SyncDataList& data2) const;
 188
 189   // Convenience helper for creating SyncChanges. Takes ownership of |turl|.
 190   syncer::SyncChange CreateTestSyncChange(
 191       syncer::SyncChange::SyncChangeType type,
 192       TemplateURL* turl) const;
 193
 194   // Helper that creates some initial sync data. We cheat a little by specifying
 195   // GUIDs for easy identification later. We also make the last_modified times
 196   // slightly older than CreateTestTemplateURL's default, to test conflict
 197   // resolution.
 198   syncer::SyncDataList CreateInitialSyncData() const;
 199
 200   // Syntactic sugar.
 201   TemplateURL* Deserialize(const syncer::SyncData& sync_data);
 202
 203   // Creates a new TemplateURL copying the fields of |turl| but replacing
 204   // the |url| and |guid| and initializing the date_created and last_modified
 205   // timestamps to a default value of 100. The caller owns the returned
 206   // TemplateURL*.
 207   TemplateURL* CopyTemplateURL(const TemplateURLData* turl,
 208                                const std::string& url,
 209                                const std::string& guid);
 210
 211  protected:
 212   base::MessageLoop message_loop_;
 213   // We keep two TemplateURLServices to test syncing between them.
 214   scoped_ptr<TemplateURLServiceTestUtil> test_util_a_;
 215   scoped_ptr<TemplateURLServiceTestUtil> test_util_b_;
 216
 217   // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
 218   scoped_ptr<TestChangeProcessor> sync_processor_;
 219   scoped_ptr<syncer::SyncChangeProcessorWrapperForTest> sync_processor_wrapper_;
 220
 221   DISALLOW_COPY_AND_ASSIGN(TemplateURLServiceSyncTest);
 222 };
 223
 224 TemplateURLServiceSyncTest::TemplateURLServiceSyncTest()
 225     : sync_processor_(new TestChangeProcessor),
 226       sync_processor_wrapper_(new syncer::SyncChangeProcessorWrapperForTest(
 227           sync_processor_.get())) {}
 228
 229 void TemplateURLServiceSyncTest::SetUp() {
 230   DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(true);
 231   test_util_a_.reset(new TemplateURLServiceTestUtil);
 232   // Use ChangeToLoadState() instead of VerifyLoad() so we don't actually pull
 233   // in the prepopulate data, which the sync tests don't care about (and would
 234   // just foul them up).
 235   test_util_a_->ChangeModelToLoadState();
 236
 237   test_util_b_.reset(new TemplateURLServiceTestUtil);
 238   test_util_b_->VerifyLoad();
 239 }
 240
 241 void TemplateURLServiceSyncTest::TearDown() {
 242   test_util_a_.reset();
 243   DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(false);
 244 }
 245
 246 scoped_ptr<syncer::SyncChangeProcessor>
 247 TemplateURLServiceSyncTest::PassProcessor() {
 248   return sync_processor_wrapper_.PassAs<syncer::SyncChangeProcessor>();
 249 }
 250
 251 scoped_ptr<syncer::SyncErrorFactory> TemplateURLServiceSyncTest::
 252     CreateAndPassSyncErrorFactory() {
 253   return scoped_ptr<syncer::SyncErrorFactory>(
 254       new syncer::SyncErrorFactoryMock());
 255 }
 256
 257 TemplateURL* TemplateURLServiceSyncTest::CreateTestTemplateURL(
 258     const base::string16& keyword,
 259     const std::string& url,
 260     const std::string& guid,
 261     time_t last_mod,
 262     bool safe_for_autoreplace,
 263     bool created_by_policy) const {
 264   TemplateURLData data;
 265   data.short_name = ASCIIToUTF16("unittest");
 266   data.SetKeyword(keyword);
 267   data.SetURL(url);
 268   data.favicon_url = GURL("http://favicon.url");
 269   data.safe_for_autoreplace = safe_for_autoreplace;
 270   data.date_created = Time::FromTimeT(100);
 271   data.last_modified = Time::FromTimeT(last_mod);
 272   data.created_by_policy = created_by_policy;
 273   data.prepopulate_id = 999999;
 274   if (!guid.empty())
 275     data.sync_guid = guid;
 276   return new TemplateURL(data);
 277 }
 278
 279 void TemplateURLServiceSyncTest::AssertEquals(const TemplateURL& expected,
 280                                               const TemplateURL& actual) const {
 281   ASSERT_EQ(expected.short_name(), actual.short_name());
 282   ASSERT_EQ(expected.keyword(), actual.keyword());
 283   ASSERT_EQ(expected.url(), actual.url());
 284   ASSERT_EQ(expected.suggestions_url(), actual.suggestions_url());
 285   ASSERT_EQ(expected.favicon_url(), actual.favicon_url());
 286   ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
 287   ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace());
 288   ASSERT_EQ(expected.input_encodings(), actual.input_encodings());
 289   ASSERT_EQ(expected.date_created(), actual.date_created());
 290   ASSERT_EQ(expected.last_modified(), actual.last_modified());
 291 }
 292
 293 void TemplateURLServiceSyncTest::AssertEquals(
 294     const syncer::SyncDataList& data1,
 295     const syncer::SyncDataList& data2) const {
 296   SyncDataMap map1 = TemplateURLService::CreateGUIDToSyncDataMap(data1);
 297   SyncDataMap map2 = TemplateURLService::CreateGUIDToSyncDataMap(data2);
 298
 299   for (SyncDataMap::const_iterator iter1 = map1.begin();
 300       iter1 != map1.end(); iter1++) {
 301     SyncDataMap::iterator iter2 = map2.find(iter1->first);
 302     if (iter2 != map2.end()) {
 303       ASSERT_EQ(GetKeyword(iter1->second), GetKeyword(iter2->second));
 304       ASSERT_EQ(GetURL(iter1->second), GetURL(iter2->second));
 305       map2.erase(iter2);
 306     }
 307   }
 308   EXPECT_EQ(0U, map2.size());
 309 }
 310
 311 syncer::SyncChange TemplateURLServiceSyncTest::CreateTestSyncChange(
 312     syncer::SyncChange::SyncChangeType type,
 313     TemplateURL* turl) const {
 314   // We take control of the TemplateURL so make sure it's cleaned up after
 315   // we create data out of it.
 316   scoped_ptr<TemplateURL> scoped_turl(turl);
 317   return syncer::SyncChange(
 318       FROM_HERE,
 319       type,
 320       TemplateURLService::CreateSyncDataFromTemplateURL(*scoped_turl));
 321 }
 322
 323 syncer::SyncDataList TemplateURLServiceSyncTest::CreateInitialSyncData() const {
 324   syncer::SyncDataList list;
 325
 326   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key1"),
 327       "http://key1.com", "key1", 90));
 328   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
 329   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com",
 330                                    "key2", 90));
 331   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
 332   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com",
 333                                    "key3", 90));
 334   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
 335
 336   return list;
 337 }
 338
 339 TemplateURL* TemplateURLServiceSyncTest::Deserialize(
 340     const syncer::SyncData& sync_data) {
 341   syncer::SyncChangeList dummy;
 342   return TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
 343       NULL, SearchTermsData(), NULL, sync_data, &dummy);
 344 }
 345
 346 TemplateURL* TemplateURLServiceSyncTest::CopyTemplateURL(
 347     const TemplateURLData* turl,
 348     const std::string& url,
 349     const std::string& guid) {
 350   TemplateURLData data = *turl;
 351   data.SetURL(url);
 352   data.date_created = Time::FromTimeT(100);
 353   data.last_modified = Time::FromTimeT(100);
 354   data.sync_guid = guid;
 355   return new TemplateURL(data);
 356 }
 357
 358 // Actual tests ---------------------------------------------------------------
 359
 360 TEST_F(TemplateURLServiceSyncTest, SerializeDeserialize) {
 361   // Create a TemplateURL and convert it into a sync specific type.
 362   scoped_ptr<TemplateURL> turl(
 363       CreateTestTemplateURL(
 364           ASCIIToUTF16("unittest"), "http://www.unittest.com/"));
 365   syncer::SyncData sync_data =
 366       TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
 367   // Convert the specifics back to a TemplateURL.
 368   scoped_ptr<TemplateURL> deserialized(Deserialize(sync_data));
 369   EXPECT_TRUE(deserialized.get());
 370   // Ensure that the original and the deserialized TURLs are equal in values.
 371   AssertEquals(*turl, *deserialized);
 372 }
 373
 374 TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataBasic) {
 375   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
 376   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
 377   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com"));
 378   syncer::SyncDataList all_sync_data =
 379       model()->GetAllSyncData(syncer::SEARCH_ENGINES);
 380
 381   EXPECT_EQ(3U, all_sync_data.size());
 382
 383   for (syncer::SyncDataList::const_iterator iter = all_sync_data.begin();
 384       iter != all_sync_data.end(); ++iter) {
 385     std::string guid = GetGUID(*iter);
 386     const TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
 387     scoped_ptr<TemplateURL> deserialized(Deserialize(*iter));
 388     AssertEquals(*service_turl, *deserialized);
 389   }
 390 }
 391
 392 TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataWithExtension) {
 393   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
 394   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
 395   model()->RegisterOmniboxKeyword("blahblahblah", "unittest", "key3",
 396                                   "http://blahblahblah");
 397   syncer::SyncDataList all_sync_data =
 398       model()->GetAllSyncData(syncer::SEARCH_ENGINES);
 399
 400   EXPECT_EQ(3U, all_sync_data.size());
 401
 402   for (syncer::SyncDataList::const_iterator iter = all_sync_data.begin();
 403       iter != all_sync_data.end(); ++iter) {
 404     std::string guid = GetGUID(*iter);
 405     const TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
 406     scoped_ptr<TemplateURL> deserialized(Deserialize(*iter));
 407     AssertEquals(*service_turl, *deserialized);
 408   }
 409 }
 410
 411 TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataNoManagedEngines) {
 412   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
 413   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
 414   TemplateURL* managed_turl = CreateTestTemplateURL(ASCIIToUTF16("key3"),
 415       "http://key3.com", std::string(), 100, false, true);
 416   model()->Add(managed_turl);
 417   syncer::SyncDataList all_sync_data =
 418       model()->GetAllSyncData(syncer::SEARCH_ENGINES);
 419
 420   EXPECT_EQ(2U, all_sync_data.size());
 421
 422   for (syncer::SyncDataList::const_iterator iter = all_sync_data.begin();
 423       iter != all_sync_data.end(); ++iter) {
 424     std::string guid = GetGUID(*iter);
 425     TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
 426     scoped_ptr<TemplateURL> deserialized(Deserialize(*iter));
 427     ASSERT_FALSE(service_turl->created_by_policy());
 428     AssertEquals(*service_turl, *deserialized);
 429   }
 430 }
 431
 432 TEST_F(TemplateURLServiceSyncTest, UniquifyKeyword) {
 433   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
 434   // Create a key that conflicts with something in the model.
 435   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key1"),
 436                                                      "http://new.com", "xyz"));
 437   base::string16 new_keyword = model()->UniquifyKeyword(*turl, false);
 438   EXPECT_EQ(ASCIIToUTF16("new.com"), new_keyword);
 439   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
 440   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("new.com"), "http://new.com",
 441                                      "xyz"));
 442
 443   // Test a second collision. This time it should be resolved by actually
 444   // modifying the original keyword, since the autogenerated keyword is already
 445   // used.
 446   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://new.com"));
 447   new_keyword = model()->UniquifyKeyword(*turl, false);
 448   EXPECT_EQ(ASCIIToUTF16("key1_"), new_keyword);
 449   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
 450   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1_"), "http://new.com"));
 451
 452   // Test a third collision. This should collide on both the autogenerated
 453   // keyword and the first uniquification attempt.
 454   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://new.com"));
 455   new_keyword = model()->UniquifyKeyword(*turl, false);
 456   EXPECT_EQ(ASCIIToUTF16("key1__"), new_keyword);
 457   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
 458
 459   // If we force the method, it should uniquify the keyword even if it is
 460   // currently unique, and skip the host-based autogenerated keyword.
 461   turl.reset(
 462       CreateTestTemplateURL(ASCIIToUTF16("unique"), "http://unique.com"));
 463   new_keyword = model()->UniquifyKeyword(*turl, true);
 464   EXPECT_EQ(ASCIIToUTF16("unique_"), new_keyword);
 465   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
 466 }
 467
 468 TEST_F(TemplateURLServiceSyncTest, IsLocalTemplateURLBetter) {
 469   // Test some edge cases of this function.
 470   const struct {
 471     time_t local_time;
 472     time_t sync_time;
 473     bool local_is_default;
 474     bool local_created_by_policy;
 475     bool expected_result;
 476   } test_cases[] = {
 477     // Sync is better by timestamp but local is Default.
 478     {10, 100, true, false, true},
 479     // Sync is better by timestamp but local is Create by Policy.
 480     {10, 100, false, true, true},
 481     // Tie. Sync wins.
 482     {100, 100, false, false, false},
 483   };
 484
 485   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
 486     TemplateURL* local_turl = CreateTestTemplateURL(
 487         ASCIIToUTF16("localkey"), "www.local.com", "localguid",
 488         test_cases[i].local_time, true, test_cases[i].local_created_by_policy);
 489     model()->Add(local_turl);
 490     if (test_cases[i].local_is_default)
 491       model()->SetUserSelectedDefaultSearchProvider(local_turl);
 492
 493     scoped_ptr<TemplateURL> sync_turl(CreateTestTemplateURL(
 494           ASCIIToUTF16("synckey"), "www.sync.com", "syncguid",
 495           test_cases[i].sync_time));
 496     EXPECT_EQ(test_cases[i].expected_result,
 497         model()->IsLocalTemplateURLBetter(local_turl, sync_turl.get()));
 498
 499     // Undo the changes.
 500     if (test_cases[i].local_is_default)
 501       model()->SetUserSelectedDefaultSearchProvider(NULL);
 502     model()->Remove(local_turl);
 503   }
 504 }
 505
 506 TEST_F(TemplateURLServiceSyncTest, ResolveSyncKeywordConflict) {
 507   // This tests cases where neither the sync nor the local TemplateURL are
 508   // marked safe_for_autoreplace.
 509
 510   // Create a keyword that conflicts, and make it older.  Sync keyword is
 511   // uniquified, and a syncer::SyncChange is added.
 512   base::string16 original_turl_keyword = ASCIIToUTF16("key1");
 513   TemplateURL* original_turl = CreateTestTemplateURL(original_turl_keyword,
 514       "http://key1.com", std::string(), 9000);
 515   model()->Add(original_turl);
 516   scoped_ptr<TemplateURL> sync_turl(CreateTestTemplateURL(original_turl_keyword,
 517       "http://new.com", "remote", 8999));
 518   syncer::SyncChangeList changes;
 519   model()->ResolveSyncKeywordConflict(sync_turl.get(), original_turl, &changes);
 520   EXPECT_NE(original_turl_keyword, sync_turl->keyword());
 521   EXPECT_EQ(original_turl_keyword, original_turl->keyword());
 522   ASSERT_EQ(1U, changes.size());
 523   EXPECT_EQ("remote", GetGUID(changes[0].sync_data()));
 524   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
 525   changes.clear();
 526   model()->Remove(original_turl);
 527
 528   // Sync is newer.  Original TemplateURL keyword is uniquified.  A SyncChange
 529   // is added (which in a normal run would be deleted by PruneSyncChanges() when
 530   // the local GUID doesn't appear in the sync GUID list).  Also ensure that
 531   // this does not change the safe_for_autoreplace flag or the TemplateURLID in
 532   // the original.
 533   original_turl = CreateTestTemplateURL(original_turl_keyword,
 534                                         "http://key1.com", "local", 9000);
 535   model()->Add(original_turl);
 536   TemplateURLID original_id = original_turl->id();
 537   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
 538                                         std::string(), 9001));
 539   model()->ResolveSyncKeywordConflict(sync_turl.get(), original_turl, &changes);
 540   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
 541   EXPECT_NE(original_turl_keyword, original_turl->keyword());
 542   EXPECT_FALSE(original_turl->safe_for_autoreplace());
 543   EXPECT_EQ(original_id, original_turl->id());
 544   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(original_turl_keyword));
 545   ASSERT_EQ(1U, changes.size());
 546   EXPECT_EQ("local", GetGUID(changes[0].sync_data()));
 547   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
 548   changes.clear();
 549   model()->Remove(original_turl);
 550
 551   // Equal times. Same result as above. Sync left alone, original uniquified so
 552   // sync_turl can fit.
 553   original_turl = CreateTestTemplateURL(original_turl_keyword,
 554                                         "http://key1.com", "local2", 9000);
 555   model()->Add(original_turl);
 556   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
 557                                         std::string(), 9000));
 558   model()->ResolveSyncKeywordConflict(sync_turl.get(), original_turl, &changes);
 559   EXPECT_EQ(original_turl_keyword, sync_turl->keyword());
 560   EXPECT_NE(original_turl_keyword, original_turl->keyword());
 561   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(original_turl_keyword));
 562   ASSERT_EQ(1U, changes.size());
 563   EXPECT_EQ("local2", GetGUID(changes[0].sync_data()));
 564   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
 565   changes.clear();
 566   model()->Remove(original_turl);
 567
 568   // Sync is newer, but original TemplateURL is created by policy, so it wins.
 569   // Sync keyword is uniquified, and a syncer::SyncChange is added.
 570   original_turl = CreateTestTemplateURL(original_turl_keyword,
 571       "http://key1.com", std::string(), 9000, false, true);
 572   model()->Add(original_turl);
 573   sync_turl.reset(CreateTestTemplateURL(original_turl_keyword, "http://new.com",
 574                                         "remote2", 9999));
 575   model()->ResolveSyncKeywordConflict(sync_turl.get(), original_turl, &changes);
 576   EXPECT_NE(original_turl_keyword, sync_turl->keyword());
 577   EXPECT_EQ(original_turl_keyword, original_turl->keyword());
 578   EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(sync_turl->keyword()));
 579   ASSERT_EQ(1U, changes.size());
 580   EXPECT_EQ("remote2", GetGUID(changes[0].sync_data()));
 581   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
 582   changes.clear();
 583   model()->Remove(original_turl);
 584 }
 585
 586 TEST_F(TemplateURLServiceSyncTest, StartSyncEmpty) {
 587   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
 588       syncer::SEARCH_ENGINES, syncer::SyncDataList(),
 589       PassProcessor(), CreateAndPassSyncErrorFactory());
 590
 591   EXPECT_EQ(0U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 592   EXPECT_EQ(0U, processor()->change_list_size());
 593   EXPECT_EQ(0, merge_result.num_items_added());
 594   EXPECT_EQ(0, merge_result.num_items_modified());
 595   EXPECT_EQ(0, merge_result.num_items_deleted());
 596   EXPECT_EQ(0, merge_result.num_items_before_association());
 597   EXPECT_EQ(0, merge_result.num_items_after_association());
 598 }
 599
 600 TEST_F(TemplateURLServiceSyncTest, MergeIntoEmpty) {
 601   syncer::SyncDataList initial_data = CreateInitialSyncData();
 602
 603   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
 604       syncer::SEARCH_ENGINES, initial_data,
 605       PassProcessor(), CreateAndPassSyncErrorFactory());
 606
 607   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 608   // We expect the model to have accepted all of the initial sync data. Search
 609   // through the model using the GUIDs to ensure that they're present.
 610   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
 611       iter != initial_data.end(); ++iter) {
 612     std::string guid = GetGUID(*iter);
 613     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
 614   }
 615
 616   EXPECT_EQ(0U, processor()->change_list_size());
 617
 618   // Locally the three new TemplateURL's should have been added.
 619   EXPECT_EQ(3, merge_result.num_items_added());
 620   EXPECT_EQ(0, merge_result.num_items_modified());
 621   EXPECT_EQ(0, merge_result.num_items_deleted());
 622   EXPECT_EQ(0, merge_result.num_items_before_association());
 623   EXPECT_EQ(3, merge_result.num_items_after_association());
 624 }
 625
 626 TEST_F(TemplateURLServiceSyncTest, MergeInAllNewData) {
 627   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("abc.com"), "http://abc.com",
 628                                      "abc"));
 629   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("def.com"), "http://def.com",
 630                                      "def"));
 631   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("xyz.com"), "http://xyz.com",
 632                                      "xyz"));
 633   syncer::SyncDataList initial_data = CreateInitialSyncData();
 634
 635   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
 636       syncer::SEARCH_ENGINES, initial_data,
 637       PassProcessor(), CreateAndPassSyncErrorFactory());
 638
 639   EXPECT_EQ(6U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 640   // We expect the model to have accepted all of the initial sync data. Search
 641   // through the model using the GUIDs to ensure that they're present.
 642   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
 643       iter != initial_data.end(); ++iter) {
 644     std::string guid = GetGUID(*iter);
 645     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
 646   }
 647   // All the original TemplateURLs should also remain in the model.
 648   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("abc.com")));
 649   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("def.com")));
 650   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("xyz.com")));
 651   // Ensure that Sync received the expected changes.
 652   EXPECT_EQ(3U, processor()->change_list_size());
 653   EXPECT_TRUE(processor()->contains_guid("abc"));
 654   EXPECT_TRUE(processor()->contains_guid("def"));
 655   EXPECT_TRUE(processor()->contains_guid("xyz"));
 656
 657   // Locally the three new TemplateURL's should have been added.
 658   EXPECT_EQ(3, merge_result.num_items_added());
 659   EXPECT_EQ(0, merge_result.num_items_modified());
 660   EXPECT_EQ(0, merge_result.num_items_deleted());
 661   EXPECT_EQ(3, merge_result.num_items_before_association());
 662   EXPECT_EQ(6, merge_result.num_items_after_association());
 663 }
 664
 665 TEST_F(TemplateURLServiceSyncTest, MergeSyncIsTheSame) {
 666   // The local data is the same as the sync data merged in. i.e. - There have
 667   // been no changes since the last time we synced. Even the last_modified
 668   // timestamps are the same.
 669   syncer::SyncDataList initial_data = CreateInitialSyncData();
 670   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
 671       iter != initial_data.end(); ++iter) {
 672     TemplateURL* converted = Deserialize(*iter);
 673     model()->Add(converted);
 674   }
 675
 676   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
 677       syncer::SEARCH_ENGINES, initial_data,
 678       PassProcessor(), CreateAndPassSyncErrorFactory());
 679
 680   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 681   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
 682       iter != initial_data.end(); ++iter) {
 683     std::string guid = GetGUID(*iter);
 684     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
 685   }
 686   EXPECT_EQ(0U, processor()->change_list_size());
 687
 688   // Locally everything should remain the same.
 689   EXPECT_EQ(0, merge_result.num_items_added());
 690   EXPECT_EQ(0, merge_result.num_items_modified());
 691   EXPECT_EQ(0, merge_result.num_items_deleted());
 692   EXPECT_EQ(3, merge_result.num_items_before_association());
 693   EXPECT_EQ(3, merge_result.num_items_after_association());
 694 }
 695
 696 TEST_F(TemplateURLServiceSyncTest, MergeUpdateFromSync) {
 697   // The local data is the same as the sync data merged in, but timestamps have
 698   // changed. Ensure the right fields are merged in.
 699   syncer::SyncDataList initial_data;
 700   TemplateURL* turl1 = CreateTestTemplateURL(ASCIIToUTF16("abc.com"),
 701                                              "http://abc.com", "abc", 9000);
 702   model()->Add(turl1);
 703   TemplateURL* turl2 = CreateTestTemplateURL(ASCIIToUTF16("xyz.com"),
 704                                              "http://xyz.com", "xyz", 9000);
 705   model()->Add(turl2);
 706
 707   scoped_ptr<TemplateURL> turl1_newer(CreateTestTemplateURL(
 708       ASCIIToUTF16("abc.com"), "http://abc.ca", "abc", 9999));
 709   initial_data.push_back(
 710       TemplateURLService::CreateSyncDataFromTemplateURL(*turl1_newer));
 711
 712   scoped_ptr<TemplateURL> turl2_older(CreateTestTemplateURL(
 713       ASCIIToUTF16("xyz.com"), "http://xyz.ca", "xyz", 8888));
 714   initial_data.push_back(
 715       TemplateURLService::CreateSyncDataFromTemplateURL(*turl2_older));
 716
 717   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
 718       syncer::SEARCH_ENGINES, initial_data,
 719       PassProcessor(), CreateAndPassSyncErrorFactory());
 720
 721   // Both were local updates, so we expect the same count.
 722   EXPECT_EQ(2U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 723
 724   // Check that the first replaced the initial abc TemplateURL.
 725   EXPECT_EQ(turl1, model()->GetTemplateURLForGUID("abc"));
 726   EXPECT_EQ("http://abc.ca", turl1->url());
 727
 728   // Check that the second produced an upstream update to the xyz TemplateURL.
 729   EXPECT_EQ(1U, processor()->change_list_size());
 730   ASSERT_TRUE(processor()->contains_guid("xyz"));
 731   syncer::SyncChange change = processor()->change_for_guid("xyz");
 732   EXPECT_TRUE(change.change_type() == syncer::SyncChange::ACTION_UPDATE);
 733   EXPECT_EQ("http://xyz.com", GetURL(change.sync_data()));
 734
 735   // Locally only the older item should have been modified.
 736   EXPECT_EQ(0, merge_result.num_items_added());
 737   EXPECT_EQ(1, merge_result.num_items_modified());
 738   EXPECT_EQ(0, merge_result.num_items_deleted());
 739   EXPECT_EQ(2, merge_result.num_items_before_association());
 740   EXPECT_EQ(2, merge_result.num_items_after_association());
 741 }
 742
 743 TEST_F(TemplateURLServiceSyncTest, MergeAddFromOlderSyncData) {
 744   // GUIDs all differ, so this is data to be added from Sync, but the timestamps
 745   // from Sync are older. Set up the local data so that one is a dupe, one has a
 746   // conflicting keyword, and the last has no conflicts (a clean ADD).
 747   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
 748                                      "aaa", 100));  // dupe
 749
 750   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"),
 751       "http://expected.com", "bbb", 100));  // keyword conflict
 752
 753   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("unique"),
 754                                      "http://unique.com", "ccc"));  // add
 755
 756   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
 757       syncer::SEARCH_ENGINES,
 758       CreateInitialSyncData(), PassProcessor(),
 759       CreateAndPassSyncErrorFactory());
 760
 761   // The dupe and conflict results in merges, as local values are always merged
 762   // with sync values if there is a keyword conflict. The unique keyword should
 763   // be added.
 764   EXPECT_EQ(4U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 765
 766   // The key1 duplicate results in the local copy winning. Ensure that Sync's
 767   // copy was not added, and the local copy is pushed upstream to Sync as an
 768   // update. The local copy should have received the sync data's GUID.
 769   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
 770   // Check changes for the UPDATE.
 771   ASSERT_TRUE(processor()->contains_guid("key1"));
 772   syncer::SyncChange key1_change = processor()->change_for_guid("key1");
 773   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key1_change.change_type());
 774   // The local sync_guid should no longer be found.
 775   EXPECT_FALSE(model()->GetTemplateURLForGUID("aaa"));
 776
 777   // The key2 keyword conflict results in a merge, with the values of the local
 778   // copy winning, so ensure it retains the original URL, and that an update to
 779   // the sync guid is pushed upstream to Sync.
 780   const TemplateURL* key2 = model()->GetTemplateURLForGUID("key2");
 781   ASSERT_TRUE(key2);
 782   EXPECT_EQ(ASCIIToUTF16("key2"), key2->keyword());
 783   EXPECT_EQ("http://expected.com", key2->url());
 784   // Check changes for the UPDATE.
 785   ASSERT_TRUE(processor()->contains_guid("key2"));
 786   syncer::SyncChange key2_change = processor()->change_for_guid("key2");
 787   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key2_change.change_type());
 788   EXPECT_EQ("key2", GetKeyword(key2_change.sync_data()));
 789   EXPECT_EQ("http://expected.com", GetURL(key2_change.sync_data()));
 790   // The local sync_guid should no longer be found.
 791   EXPECT_FALSE(model()->GetTemplateURLForGUID("bbb"));
 792
 793   // The last TemplateURL should have had no conflicts and was just added. It
 794   // should not have replaced the third local TemplateURL.
 795   EXPECT_TRUE(model()->GetTemplateURLForGUID("ccc"));
 796   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
 797
 798   // Two UPDATEs and one ADD.
 799   EXPECT_EQ(3U, processor()->change_list_size());
 800   // One ADDs should be pushed up to Sync.
 801   ASSERT_TRUE(processor()->contains_guid("ccc"));
 802   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
 803             processor()->change_for_guid("ccc").change_type());
 804
 805   // All the sync items had new guids, but only one doesn't conflict and is
 806   // added. The other two conflicting cases result in local modifications
 807   // to override the local guids but preserve the local data.
 808   EXPECT_EQ(1, merge_result.num_items_added());
 809   EXPECT_EQ(2, merge_result.num_items_modified());
 810   EXPECT_EQ(0, merge_result.num_items_deleted());
 811   EXPECT_EQ(3, merge_result.num_items_before_association());
 812   EXPECT_EQ(4, merge_result.num_items_after_association());
 813 }
 814
 815 TEST_F(TemplateURLServiceSyncTest, MergeAddFromNewerSyncData) {
 816   // GUIDs all differ, so Sync may overtake some entries, but the timestamps
 817   // from Sync are newer. Set up the local data so that one is a dupe, one has a
 818   // conflicting keyword, and the last has no conflicts (a clean ADD).
 819   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
 820                                      "aaa", 10));  // dupe
 821
 822   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"),
 823       "http://expected.com", "bbb", 10));  // keyword conflict
 824
 825   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("unique"),
 826                                      "http://unique.com", "ccc", 10));  // add
 827
 828   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
 829       syncer::SEARCH_ENGINES,
 830       CreateInitialSyncData(), PassProcessor(),
 831       CreateAndPassSyncErrorFactory());
 832
 833   // The dupe and keyword conflict results in merges. The unique keyword be
 834   // added to the model.
 835   EXPECT_EQ(4U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 836
 837   // The key1 duplicate results in Sync's copy winning. Ensure that Sync's
 838   // copy replaced the local copy.
 839   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
 840   EXPECT_FALSE(model()->GetTemplateURLForGUID("aaa"));
 841   EXPECT_FALSE(processor()->contains_guid("key1"));
 842   EXPECT_FALSE(processor()->contains_guid("aaa"));
 843
 844   // The key2 keyword conflict results in Sync's copy winning, so ensure it
 845   // retains the original keyword and is added. The local copy should be
 846   // removed.
 847   const TemplateURL* key2_sync = model()->GetTemplateURLForGUID("key2");
 848   ASSERT_TRUE(key2_sync);
 849   EXPECT_EQ(ASCIIToUTF16("key2"), key2_sync->keyword());
 850   EXPECT_FALSE(model()->GetTemplateURLForGUID("bbb"));
 851
 852   // The last TemplateURL should have had no conflicts and was just added. It
 853   // should not have replaced the third local TemplateURL.
 854   EXPECT_TRUE(model()->GetTemplateURLForGUID("ccc"));
 855   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
 856
 857   // One ADD.
 858   EXPECT_EQ(1U, processor()->change_list_size());
 859   // One ADDs should be pushed up to Sync.
 860   ASSERT_TRUE(processor()->contains_guid("ccc"));
 861   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
 862             processor()->change_for_guid("ccc").change_type());
 863
 864   // One of the sync items is added directly without conflict. The other two
 865   // conflict but are newer than the local items so are added while the local
 866   // is deleted.
 867   EXPECT_EQ(3, merge_result.num_items_added());
 868   EXPECT_EQ(0, merge_result.num_items_modified());
 869   EXPECT_EQ(2, merge_result.num_items_deleted());
 870   EXPECT_EQ(3, merge_result.num_items_before_association());
 871   EXPECT_EQ(4, merge_result.num_items_after_association());
 872 }
 873
 874 TEST_F(TemplateURLServiceSyncTest, ProcessChangesEmptyModel) {
 875   // We initially have no data.
 876   model()->MergeDataAndStartSyncing(
 877       syncer::SEARCH_ENGINES, syncer::SyncDataList(),
 878       PassProcessor(), CreateAndPassSyncErrorFactory());
 879
 880   // Set up a bunch of ADDs.
 881   syncer::SyncChangeList changes;
 882   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
 883       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1")));
 884   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
 885       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com", "key2")));
 886   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
 887       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key3")));
 888
 889   model()->ProcessSyncChanges(FROM_HERE, changes);
 890
 891   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 892   EXPECT_EQ(0U, processor()->change_list_size());
 893   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
 894   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
 895   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
 896 }
 897
 898 TEST_F(TemplateURLServiceSyncTest, ProcessChangesNoConflicts) {
 899   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
 900                                     CreateInitialSyncData(), PassProcessor(),
 901                                     CreateAndPassSyncErrorFactory());
 902
 903   // Process different types of changes, without conflicts.
 904   syncer::SyncChangeList changes;
 905   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
 906       CreateTestTemplateURL(ASCIIToUTF16("key4"), "http://key4.com", "key4")));
 907   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
 908       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
 909                             "key2")));
 910   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_DELETE,
 911       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key3")));
 912
 913   model()->ProcessSyncChanges(FROM_HERE, changes);
 914
 915   // Add one, remove one, update one, so the number shouldn't change.
 916   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 917   EXPECT_EQ(0U, processor()->change_list_size());
 918   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
 919   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
 920   const TemplateURL* turl = model()->GetTemplateURLForGUID("key2");
 921   EXPECT_TRUE(turl);
 922   EXPECT_EQ(ASCIIToUTF16("newkeyword"), turl->keyword());
 923   EXPECT_EQ("http://new.com", turl->url());
 924   EXPECT_FALSE(model()->GetTemplateURLForGUID("key3"));
 925   EXPECT_TRUE(model()->GetTemplateURLForGUID("key4"));
 926 }
 927
 928 TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithConflictsSyncWins) {
 929   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
 930                                     CreateInitialSyncData(), PassProcessor(),
 931                                     CreateAndPassSyncErrorFactory());
 932
 933   // Process different types of changes, with conflicts. Note that all this data
 934   // has a newer timestamp, so Sync will win in these scenarios.
 935   syncer::SyncChangeList changes;
 936   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
 937       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://new.com", "aaa")));
 938   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
 939       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key1")));
 940
 941   model()->ProcessSyncChanges(FROM_HERE, changes);
 942
 943   // Add one, update one, so we're up to 4.
 944   EXPECT_EQ(4U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 945   // Sync is always newer here, so it should always win.  We should create
 946   // SyncChanges for the changes to the local entities, since they're synced
 947   // too.
 948   EXPECT_EQ(2U, processor()->change_list_size());
 949   ASSERT_TRUE(processor()->contains_guid("key2"));
 950   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
 951             processor()->change_for_guid("key2").change_type());
 952   ASSERT_TRUE(processor()->contains_guid("key3"));
 953   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
 954             processor()->change_for_guid("key3").change_type());
 955
 956   // aaa conflicts with key2 and wins, forcing key2's keyword to update.
 957   EXPECT_TRUE(model()->GetTemplateURLForGUID("aaa"));
 958   EXPECT_EQ(model()->GetTemplateURLForGUID("aaa"),
 959             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key2")));
 960   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
 961   EXPECT_EQ(model()->GetTemplateURLForGUID("key2"),
 962             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key2.com")));
 963   // key1 update conflicts with key3 and wins, forcing key3's keyword to update.
 964   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
 965   EXPECT_EQ(model()->GetTemplateURLForGUID("key1"),
 966             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3")));
 967   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
 968   EXPECT_EQ(model()->GetTemplateURLForGUID("key3"),
 969             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3.com")));
 970 }
 971
 972 TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithConflictsLocalWins) {
 973   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
 974                                     CreateInitialSyncData(), PassProcessor(),
 975                                     CreateAndPassSyncErrorFactory());
 976
 977   // Process different types of changes, with conflicts. Note that all this data
 978   // has an older timestamp, so the local data will win in these scenarios.
 979   syncer::SyncChangeList changes;
 980   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
 981       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://new.com", "aaa",
 982                             10)));
 983   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
 984       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key1",
 985                             10)));
 986
 987   model()->ProcessSyncChanges(FROM_HERE, changes);
 988
 989   // Add one, update one, so we're up to 4.
 990   EXPECT_EQ(4U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
 991   // Local data wins twice so two updates are pushed up to Sync.
 992   EXPECT_EQ(2U, processor()->change_list_size());
 993
 994   // aaa conflicts with key2 and loses, forcing it's keyword to update.
 995   EXPECT_TRUE(model()->GetTemplateURLForGUID("aaa"));
 996   EXPECT_EQ(model()->GetTemplateURLForGUID("aaa"),
 997             model()->GetTemplateURLForKeyword(ASCIIToUTF16("new.com")));
 998   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
 999   EXPECT_EQ(model()->GetTemplateURLForGUID("key2"),
1000             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key2")));
1001   // key1 update conflicts with key3 and loses, forcing key1's keyword to
1002   // update.
1003   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
1004   EXPECT_EQ(model()->GetTemplateURLForGUID("key1"),
1005             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3.com")));
1006   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
1007   EXPECT_EQ(model()->GetTemplateURLForGUID("key3"),
1008             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3")));
1009
1010   ASSERT_TRUE(processor()->contains_guid("aaa"));
1011   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
1012             processor()->change_for_guid("aaa").change_type());
1013   ASSERT_TRUE(processor()->contains_guid("key1"));
1014   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
1015             processor()->change_for_guid("key1").change_type());
1016 }
1017
1018 TEST_F(TemplateURLServiceSyncTest, ProcessTemplateURLChange) {
1019   // Ensure that ProcessTemplateURLChange is called and pushes the correct
1020   // changes to Sync whenever local changes are made to TemplateURLs.
1021   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
1022                                     CreateInitialSyncData(), PassProcessor(),
1023                                     CreateAndPassSyncErrorFactory());
1024
1025   // Add a new search engine.
1026   TemplateURL* new_turl =
1027       CreateTestTemplateURL(ASCIIToUTF16("baidu"), "http://baidu.cn", "new");
1028   model()->Add(new_turl);
1029   EXPECT_EQ(1U, processor()->change_list_size());
1030   ASSERT_TRUE(processor()->contains_guid("new"));
1031   syncer::SyncChange change = processor()->change_for_guid("new");
1032   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change.change_type());
1033   EXPECT_EQ("baidu", GetKeyword(change.sync_data()));
1034   EXPECT_EQ("http://baidu.cn", GetURL(change.sync_data()));
1035
1036   // Change a keyword.
1037   TemplateURL* existing_turl = model()->GetTemplateURLForGUID("key1");
1038   model()->ResetTemplateURL(existing_turl, existing_turl->short_name(),
1039                             ASCIIToUTF16("k"), existing_turl->url());
1040   EXPECT_EQ(1U, processor()->change_list_size());
1041   ASSERT_TRUE(processor()->contains_guid("key1"));
1042   change = processor()->change_for_guid("key1");
1043   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
1044   EXPECT_EQ("k", GetKeyword(change.sync_data()));
1045
1046   // Remove an existing search engine.
1047   existing_turl = model()->GetTemplateURLForGUID("key2");
1048   model()->Remove(existing_turl);
1049   EXPECT_EQ(1U, processor()->change_list_size());
1050   ASSERT_TRUE(processor()->contains_guid("key2"));
1051   change = processor()->change_for_guid("key2");
1052   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change.change_type());
1053 }
1054
1055 TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithLocalExtensions) {
1056   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
1057                                     CreateInitialSyncData(), PassProcessor(),
1058                                     CreateAndPassSyncErrorFactory());
1059
1060   // Add some extension keywords locally.
1061   model()->RegisterOmniboxKeyword("extension1", "unittest", "keyword1",
1062                                   "http://extension1");
1063   TemplateURL* extension1 =
1064       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1"));
1065   ASSERT_TRUE(extension1);
1066   EXPECT_EQ(1U, processor()->change_list_size());
1067
1068   model()->RegisterOmniboxKeyword("extension2", "unittest", "keyword2",
1069                                   "http://extension2");
1070   TemplateURL* extension2 =
1071       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2"));
1072   ASSERT_TRUE(extension2);
1073   EXPECT_EQ(1U, processor()->change_list_size());
1074
1075   // Create some sync changes that will conflict with the extension keywords.
1076   syncer::SyncChangeList changes;
1077   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
1078     CreateTestTemplateURL(ASCIIToUTF16("keyword1"), "http://aaa.com",
1079                           std::string(), 100, true)));
1080   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
1081     CreateTestTemplateURL(ASCIIToUTF16("keyword2"), "http://bbb.com")));
1082   model()->ProcessSyncChanges(FROM_HERE, changes);
1083
1084   // The existing extension keywords should be uniquified.
1085   EXPECT_FALSE(model()->GetTemplateURLForHost("aaa.com") == NULL);
1086   EXPECT_EQ(model()->GetTemplateURLForHost("aaa.com"),
1087             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1")));
1088   TemplateURL* url_for_keyword2 =
1089       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2"));
1090   EXPECT_NE(extension2, url_for_keyword2);
1091   EXPECT_EQ("http://bbb.com", url_for_keyword2->url());
1092
1093   // Replaced extension keywords should be uniquified.
1094   EXPECT_EQ(extension1,
1095             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1_")));
1096   EXPECT_EQ(extension2,
1097             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2_")));
1098 }
1099
1100 TEST_F(TemplateURLServiceSyncTest, AutogeneratedKeywordMigrated) {
1101   // Create a couple of sync entries with autogenerated keywords.
1102   syncer::SyncDataList initial_data;
1103   scoped_ptr<TemplateURL> turl(
1104       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1"));
1105   initial_data.push_back(
1106       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
1107   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"),
1108       "{google:baseURL}search?q={searchTerms}", "key2"));
1109   initial_data.push_back(
1110       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
1111
1112   // Now try to sync the data locally.
1113   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1114       PassProcessor(), CreateAndPassSyncErrorFactory());
1115
1116   // Both entries should have been added, with explicit keywords.
1117   TemplateURL* key1 = model()->GetTemplateURLForHost("key1.com");
1118   ASSERT_FALSE(key1 == NULL);
1119   EXPECT_EQ(ASCIIToUTF16("key1.com"), key1->keyword());
1120   GURL google_url(model()->search_terms_data().GoogleBaseURLValue());
1121   TemplateURL* key2 = model()->GetTemplateURLForHost(google_url.host());
1122   ASSERT_FALSE(key2 == NULL);
1123   base::string16 google_keyword(net::StripWWWFromHost(google_url));
1124   EXPECT_EQ(google_keyword, key2->keyword());
1125
1126   // We should also have gotten some corresponding UPDATEs pushed upstream.
1127   EXPECT_GE(processor()->change_list_size(), 2U);
1128   ASSERT_TRUE(processor()->contains_guid("key1"));
1129   syncer::SyncChange key1_change = processor()->change_for_guid("key1");
1130   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key1_change.change_type());
1131   EXPECT_EQ("key1.com", GetKeyword(key1_change.sync_data()));
1132   ASSERT_TRUE(processor()->contains_guid("key2"));
1133   syncer::SyncChange key2_change = processor()->change_for_guid("key2");
1134   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key2_change.change_type());
1135   EXPECT_EQ(google_keyword, UTF8ToUTF16(GetKeyword(key2_change.sync_data())));
1136 }
1137
1138 TEST_F(TemplateURLServiceSyncTest, AutogeneratedKeywordConflicts) {
1139   // Sync brings in some autogenerated keywords, but the generated keywords we
1140   // try to create conflict with ones in the model.
1141   base::string16 google_keyword(net::StripWWWFromHost(GURL(
1142       model()->search_terms_data().GoogleBaseURLValue())));
1143   const std::string local_google_url =
1144       "{google:baseURL}1/search?q={searchTerms}";
1145   TemplateURL* google = CreateTestTemplateURL(google_keyword, local_google_url);
1146   model()->Add(google);
1147   TemplateURL* other =
1148       CreateTestTemplateURL(ASCIIToUTF16("other.com"), "http://other.com/foo");
1149   model()->Add(other);
1150   syncer::SyncDataList initial_data;
1151   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("sync1"),
1152       "{google:baseURL}2/search?q={searchTerms}", "sync1", 50));
1153   initial_data.push_back(
1154       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
1155   const std::string synced_other_url =
1156       "http://other.com/search?q={searchTerms}";
1157   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("sync2"),
1158       synced_other_url, "sync2", 150));
1159   initial_data.push_back(
1160       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
1161
1162   // Before we merge the data, grab the local sync_guids so we can ensure that
1163   // they've been replaced.
1164   const std::string local_google_guid = google->sync_guid();
1165   const std::string local_other_guid = other->sync_guid();
1166
1167   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1168       PassProcessor(), CreateAndPassSyncErrorFactory());
1169
1170   // In this case, the conflicts should be handled just like any other keyword
1171   // conflicts -- the later-modified TemplateURL is assumed to be authoritative.
1172   // Since the initial TemplateURLs were local only, they should be merged with
1173   // the sync TemplateURLs (GUIDs transferred over).
1174   EXPECT_FALSE(model()->GetTemplateURLForGUID(local_google_guid));
1175   ASSERT_TRUE(model()->GetTemplateURLForGUID("sync1"));
1176   EXPECT_EQ(google_keyword, model()->GetTemplateURLForGUID("sync1")->keyword());
1177   EXPECT_FALSE(model()->GetTemplateURLForGUID(local_other_guid));
1178   ASSERT_TRUE(model()->GetTemplateURLForGUID("sync2"));
1179   EXPECT_EQ(ASCIIToUTF16("other.com"),
1180             model()->GetTemplateURLForGUID("sync2")->keyword());
1181
1182   // Both synced URLs should have associated UPDATEs, since both needed their
1183   // keywords to be generated.
1184   EXPECT_EQ(processor()->change_list_size(), 2U);
1185   ASSERT_TRUE(processor()->contains_guid("sync1"));
1186   syncer::SyncChange sync1_change = processor()->change_for_guid("sync1");
1187   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, sync1_change.change_type());
1188   EXPECT_EQ(google_keyword, UTF8ToUTF16(GetKeyword(sync1_change.sync_data())));
1189   EXPECT_EQ(local_google_url, GetURL(sync1_change.sync_data()));
1190   ASSERT_TRUE(processor()->contains_guid("sync2"));
1191   syncer::SyncChange sync2_change = processor()->change_for_guid("sync2");
1192   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, sync2_change.change_type());
1193   EXPECT_EQ("other.com", GetKeyword(sync2_change.sync_data()));
1194   EXPECT_EQ(synced_other_url, GetURL(sync2_change.sync_data()));
1195 }
1196
1197 TEST_F(TemplateURLServiceSyncTest, TwoAutogeneratedKeywordsUsingGoogleBaseURL) {
1198   // Sync brings in two autogenerated keywords and both use Google base URLs.
1199   // We make the first older so that it will get renamed once before the second
1200   // and then again once after (when we resolve conflicts for the second).
1201   syncer::SyncDataList initial_data;
1202   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key1"),
1203       "{google:baseURL}1/search?q={searchTerms}", "key1", 50));
1204   initial_data.push_back(
1205       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
1206   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"),
1207       "{google:baseURL}2/search?q={searchTerms}", "key2"));
1208   initial_data.push_back(
1209       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
1210   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1211       PassProcessor(), CreateAndPassSyncErrorFactory());
1212
1213   // We should still have coalesced the updates to one each.
1214   base::string16 google_keyword(net::StripWWWFromHost(GURL(
1215       model()->search_terms_data().GoogleBaseURLValue())));
1216   TemplateURL* keyword1 =
1217       model()->GetTemplateURLForKeyword(google_keyword + ASCIIToUTF16("_"));
1218   ASSERT_FALSE(keyword1 == NULL);
1219   EXPECT_EQ("key1", keyword1->sync_guid());
1220   TemplateURL* keyword2 = model()->GetTemplateURLForKeyword(google_keyword);
1221   ASSERT_FALSE(keyword2 == NULL);
1222   EXPECT_EQ("key2", keyword2->sync_guid());
1223
1224   EXPECT_GE(processor()->change_list_size(), 2U);
1225   ASSERT_TRUE(processor()->contains_guid("key1"));
1226   syncer::SyncChange key1_change = processor()->change_for_guid("key1");
1227   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key1_change.change_type());
1228   EXPECT_EQ(keyword1->keyword(),
1229             base::UTF8ToUTF16(GetKeyword(key1_change.sync_data())));
1230   ASSERT_TRUE(processor()->contains_guid("key2"));
1231   syncer::SyncChange key2_change = processor()->change_for_guid("key2");
1232   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, key2_change.change_type());
1233   EXPECT_EQ(keyword2->keyword(),
1234             base::UTF8ToUTF16(GetKeyword(key2_change.sync_data())));
1235 }
1236
1237 TEST_F(TemplateURLServiceSyncTest, DuplicateEncodingsRemoved) {
1238   // Create a sync entry with duplicate encodings.
1239   syncer::SyncDataList initial_data;
1240
1241   TemplateURLData data;
1242   data.short_name = ASCIIToUTF16("test");
1243   data.SetKeyword(ASCIIToUTF16("keyword"));
1244   data.SetURL("http://test/%s");
1245   data.input_encodings.push_back("UTF-8");
1246   data.input_encodings.push_back("UTF-8");
1247   data.input_encodings.push_back("UTF-16");
1248   data.input_encodings.push_back("UTF-8");
1249   data.input_encodings.push_back("Big5");
1250   data.input_encodings.push_back("UTF-16");
1251   data.input_encodings.push_back("Big5");
1252   data.input_encodings.push_back("Windows-1252");
1253   data.date_created = Time::FromTimeT(100);
1254   data.last_modified = Time::FromTimeT(100);
1255   data.sync_guid = "keyword";
1256   scoped_ptr<TemplateURL> turl(new TemplateURL(data));
1257   initial_data.push_back(
1258       TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
1259
1260   // Now try to sync the data locally.
1261   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1262       PassProcessor(), CreateAndPassSyncErrorFactory());
1263
1264   // The entry should have been added, with duplicate encodings removed.
1265   TemplateURL* keyword =
1266       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword"));
1267   ASSERT_FALSE(keyword == NULL);
1268   EXPECT_EQ(4U, keyword->input_encodings().size());
1269
1270   // We should also have gotten a corresponding UPDATE pushed upstream.
1271   EXPECT_GE(processor()->change_list_size(), 1U);
1272   ASSERT_TRUE(processor()->contains_guid("keyword"));
1273   syncer::SyncChange keyword_change = processor()->change_for_guid("keyword");
1274   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, keyword_change.change_type());
1275   EXPECT_EQ("UTF-8;UTF-16;Big5;Windows-1252", keyword_change.sync_data().
1276       GetSpecifics().search_engine().input_encodings());
1277 }
1278
1279 TEST_F(TemplateURLServiceSyncTest, MergeTwoClientsBasic) {
1280   // Start off B with some empty data.
1281   model_b()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
1282                                       CreateInitialSyncData(), PassProcessor(),
1283                                       CreateAndPassSyncErrorFactory());
1284
1285   // Merge A and B. All of B's data should transfer over to A, which initially
1286   // has no data.
1287   scoped_ptr<syncer::SyncChangeProcessorWrapperForTest> delegate_b(
1288       new syncer::SyncChangeProcessorWrapperForTest(model_b()));
1289   model_a()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
1290       model_b()->GetAllSyncData(syncer::SEARCH_ENGINES),
1291       delegate_b.PassAs<syncer::SyncChangeProcessor>(),
1292       CreateAndPassSyncErrorFactory());
1293
1294   // They should be consistent.
1295   AssertEquals(model_a()->GetAllSyncData(syncer::SEARCH_ENGINES),
1296                model_b()->GetAllSyncData(syncer::SEARCH_ENGINES));
1297 }
1298
1299 TEST_F(TemplateURLServiceSyncTest, MergeTwoClientsDupesAndConflicts) {
1300   // Start off B with some empty data.
1301   model_b()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
1302                                       CreateInitialSyncData(), PassProcessor(),
1303                                       CreateAndPassSyncErrorFactory());
1304
1305   // Set up A so we have some interesting duplicates and conflicts.
1306   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key4"), "http://key4.com",
1307                                        "key4"));  // Added
1308   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com",
1309                                        "key2"));  // Merge - Copy of key2.
1310   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com",
1311                                        "key5", 10));  // Merge - Dupe of key3.
1312   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key6.com",
1313                                        "key6", 10));  // Conflict with key1
1314
1315   // Merge A and B.
1316   scoped_ptr<syncer::SyncChangeProcessorWrapperForTest> delegate_b(
1317       new syncer::SyncChangeProcessorWrapperForTest(model_b()));
1318   model_a()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
1319       model_b()->GetAllSyncData(syncer::SEARCH_ENGINES),
1320       delegate_b.PassAs<syncer::SyncChangeProcessor>(),
1321       CreateAndPassSyncErrorFactory());
1322
1323   // They should be consistent.
1324   AssertEquals(model_a()->GetAllSyncData(syncer::SEARCH_ENGINES),
1325                model_b()->GetAllSyncData(syncer::SEARCH_ENGINES));
1326 }
1327
1328 TEST_F(TemplateURLServiceSyncTest, StopSyncing) {
1329   syncer::SyncError error =
1330       model()->MergeDataAndStartSyncing(
1331           syncer::SEARCH_ENGINES,
1332           CreateInitialSyncData(),
1333           PassProcessor(),
1334           CreateAndPassSyncErrorFactory()).error();
1335   ASSERT_FALSE(error.IsSet());
1336   model()->StopSyncing(syncer::SEARCH_ENGINES);
1337
1338   syncer::SyncChangeList changes;
1339   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
1340       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
1341                             "key2")));
1342   error = model()->ProcessSyncChanges(FROM_HERE, changes);
1343   EXPECT_TRUE(error.IsSet());
1344
1345   // Ensure that the sync changes were not accepted.
1346   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
1347   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("newkeyword")));
1348 }
1349
1350 TEST_F(TemplateURLServiceSyncTest, SyncErrorOnInitialSync) {
1351   processor()->set_erroneous(true);
1352   syncer::SyncError error =
1353       model()->MergeDataAndStartSyncing(
1354           syncer::SEARCH_ENGINES,
1355           CreateInitialSyncData(),
1356           PassProcessor(),
1357           CreateAndPassSyncErrorFactory()).error();
1358   EXPECT_TRUE(error.IsSet());
1359
1360   // Ensure that if the initial merge was erroneous, then subsequence attempts
1361   // to push data into the local model are rejected, since the model was never
1362   // successfully associated with Sync in the first place.
1363   syncer::SyncChangeList changes;
1364   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
1365       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
1366                             "key2")));
1367   processor()->set_erroneous(false);
1368   error = model()->ProcessSyncChanges(FROM_HERE, changes);
1369   EXPECT_TRUE(error.IsSet());
1370
1371   // Ensure that the sync changes were not accepted.
1372   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
1373   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("newkeyword")));
1374 }
1375
1376 TEST_F(TemplateURLServiceSyncTest, SyncErrorOnLaterSync) {
1377   // Ensure that if the SyncProcessor succeeds in the initial merge, but fails
1378   // in future ProcessSyncChanges, we still return an error.
1379   syncer::SyncError error =
1380       model()->MergeDataAndStartSyncing(
1381           syncer::SEARCH_ENGINES,
1382           CreateInitialSyncData(),
1383           PassProcessor(),
1384           CreateAndPassSyncErrorFactory()).error();
1385   ASSERT_FALSE(error.IsSet());
1386
1387   syncer::SyncChangeList changes;
1388   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
1389       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
1390                             "key2")));
1391   processor()->set_erroneous(true);
1392   error = model()->ProcessSyncChanges(FROM_HERE, changes);
1393   EXPECT_TRUE(error.IsSet());
1394 }
1395
1396 TEST_F(TemplateURLServiceSyncTest, MergeTwiceWithSameSyncData) {
1397   // Ensure that a second merge with the same data as the first does not
1398   // actually update the local data.
1399   syncer::SyncDataList initial_data;
1400   initial_data.push_back(CreateInitialSyncData()[0]);
1401
1402   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
1403                                      "key1", 10));  // earlier
1404
1405   syncer::SyncError error =
1406       model()->MergeDataAndStartSyncing(
1407           syncer::SEARCH_ENGINES,
1408           initial_data,
1409           PassProcessor(),
1410           CreateAndPassSyncErrorFactory()).error();
1411   ASSERT_FALSE(error.IsSet());
1412
1413   // We should have updated the original TemplateURL with Sync's version.
1414   // Keep a copy of it so we can compare it after we re-merge.
1415   TemplateURL* key1_url = model()->GetTemplateURLForGUID("key1");
1416   ASSERT_TRUE(key1_url);
1417   scoped_ptr<TemplateURL> updated_turl(new TemplateURL(key1_url->data()));
1418   EXPECT_EQ(Time::FromTimeT(90), updated_turl->last_modified());
1419
1420   // Modify a single field of the initial data. This should not be updated in
1421   // the second merge, as the last_modified timestamp remains the same.
1422   scoped_ptr<TemplateURL> temp_turl(Deserialize(initial_data[0]));
1423   TemplateURLData data(temp_turl->data());
1424   data.short_name = ASCIIToUTF16("SomethingDifferent");
1425   temp_turl.reset(new TemplateURL(data));
1426   initial_data.clear();
1427   initial_data.push_back(
1428       TemplateURLService::CreateSyncDataFromTemplateURL(*temp_turl));
1429
1430   // Remerge the data again. This simulates shutting down and syncing again
1431   // at a different time, but the cloud data has not changed.
1432   model()->StopSyncing(syncer::SEARCH_ENGINES);
1433   sync_processor_wrapper_.reset(
1434       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
1435   error = model()->MergeDataAndStartSyncing(
1436       syncer::SEARCH_ENGINES,
1437       initial_data,
1438       PassProcessor(),
1439       CreateAndPassSyncErrorFactory()).error();
1440   ASSERT_FALSE(error.IsSet());
1441
1442   // Check that the TemplateURL was not modified.
1443   const TemplateURL* reupdated_turl = model()->GetTemplateURLForGUID("key1");
1444   ASSERT_TRUE(reupdated_turl);
1445   AssertEquals(*updated_turl, *reupdated_turl);
1446 }
1447
1448 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultGUIDArrivesFirst) {
1449   syncer::SyncDataList initial_data = CreateInitialSyncData();
1450   // The default search provider should support replacement.
1451   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key2"),
1452       "http://key2.com/{searchTerms}", "key2", 90));
1453   initial_data[1] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
1454   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1455       PassProcessor(), CreateAndPassSyncErrorFactory());
1456   model()->SetUserSelectedDefaultSearchProvider(
1457       model()->GetTemplateURLForGUID("key2"));
1458
1459   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1460   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
1461   ASSERT_TRUE(default_search);
1462
1463   // Change kSyncedDefaultSearchProviderGUID to a GUID that does not exist in
1464   // the model yet. Ensure that the default has not changed in any way.
1465   profile_a()->GetTestingPrefService()->SetString(
1466       prefs::kSyncedDefaultSearchProviderGUID, "newdefault");
1467
1468   ASSERT_EQ(default_search, model()->GetDefaultSearchProvider());
1469
1470   // Bring in a random new search engine with a different GUID. Ensure that
1471   // it doesn't change the default.
1472   syncer::SyncChangeList changes1;
1473   changes1.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
1474       CreateTestTemplateURL(ASCIIToUTF16("random"), "http://random.com",
1475                             "random")));
1476   model()->ProcessSyncChanges(FROM_HERE, changes1);
1477
1478   EXPECT_EQ(4U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1479   ASSERT_EQ(default_search, model()->GetDefaultSearchProvider());
1480
1481   // Finally, bring in the expected entry with the right GUID. Ensure that
1482   // the default has changed to the new search engine.
1483   syncer::SyncChangeList changes2;
1484   changes2.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
1485       CreateTestTemplateURL(ASCIIToUTF16("new"), "http://new.com/{searchTerms}",
1486                             "newdefault")));
1487   model()->ProcessSyncChanges(FROM_HERE, changes2);
1488
1489   EXPECT_EQ(5U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1490   ASSERT_NE(default_search, model()->GetDefaultSearchProvider());
1491   ASSERT_EQ("newdefault", model()->GetDefaultSearchProvider()->sync_guid());
1492 }
1493
1494 TEST_F(TemplateURLServiceSyncTest, DefaultGuidDeletedBeforeNewDSPArrives) {
1495   syncer::SyncDataList initial_data;
1496   // The default search provider should support replacement.
1497   scoped_ptr<TemplateURL> turl1(CreateTestTemplateURL(ASCIIToUTF16("key1"),
1498       "http://key1.com/{searchTerms}", "key1", 90));
1499   // Create a second default search provider for the
1500   // FindNewDefaultSearchProvider method to find.
1501   TemplateURLData data;
1502   data.short_name = ASCIIToUTF16("unittest");
1503   data.SetKeyword(ASCIIToUTF16("key2"));
1504   data.SetURL("http://key2.com/{searchTerms}");
1505   data.favicon_url = GURL("http://favicon.url");
1506   data.safe_for_autoreplace = false;
1507   data.date_created = Time::FromTimeT(100);
1508   data.last_modified = Time::FromTimeT(100);
1509   data.created_by_policy = false;
1510   data.prepopulate_id = 999999;
1511   data.sync_guid = "key2";
1512   data.show_in_default_list = true;
1513   scoped_ptr<TemplateURL> turl2(new TemplateURL(data));
1514   initial_data.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(
1515       *turl1));
1516   initial_data.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(
1517       *turl2));
1518   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1519       PassProcessor(), CreateAndPassSyncErrorFactory());
1520   model()->SetUserSelectedDefaultSearchProvider(
1521       model()->GetTemplateURLForGUID("key1"));
1522   ASSERT_EQ("key1", model()->GetDefaultSearchProvider()->sync_guid());
1523
1524   EXPECT_EQ(2U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1525   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
1526   ASSERT_TRUE(default_search);
1527
1528   // Change kSyncedDefaultSearchProviderGUID to a GUID that does not exist in
1529   // the model yet. Ensure that the default has not changed in any way.
1530   profile_a()->GetTestingPrefService()->SetString(
1531       prefs::kSyncedDefaultSearchProviderGUID, "newdefault");
1532
1533   ASSERT_EQ("key1", model()->GetDefaultSearchProvider()->sync_guid());
1534   EXPECT_EQ("newdefault", profile_a()->GetTestingPrefService()->GetString(
1535       prefs::kSyncedDefaultSearchProviderGUID));
1536
1537   // Simulate a situation where an ACTION_DELETE on the default arrives before
1538   // the new default search provider entry. This should fail to delete the
1539   // target entry, and instead send up an "undelete" to the server, after
1540   // further uniquifying the keyword to avoid infinite sync loops. The synced
1541   // default GUID should not be changed so that when the expected default entry
1542   // arrives, it can still be set as the default.
1543   syncer::SyncChangeList changes1;
1544   changes1.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_DELETE,
1545                                           turl1.release()));
1546   model()->ProcessSyncChanges(FROM_HERE, changes1);
1547
1548   EXPECT_TRUE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1_")));
1549   EXPECT_EQ(2U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1550   EXPECT_EQ("key1", model()->GetDefaultSearchProvider()->sync_guid());
1551   EXPECT_EQ("newdefault", profile_a()->GetTestingPrefService()->GetString(
1552       prefs::kSyncedDefaultSearchProviderGUID));
1553   syncer::SyncChange undelete = processor()->change_for_guid("key1");
1554   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, undelete.change_type());
1555   EXPECT_EQ("key1_",
1556             undelete.sync_data().GetSpecifics().search_engine().keyword());
1557
1558   // Finally, bring in the expected entry with the right GUID. Ensure that
1559   // the default has changed to the new search engine.
1560   syncer::SyncChangeList changes2;
1561   changes2.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
1562       CreateTestTemplateURL(ASCIIToUTF16("new"), "http://new.com/{searchTerms}",
1563                             "newdefault")));
1564   model()->ProcessSyncChanges(FROM_HERE, changes2);
1565
1566   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1567   EXPECT_EQ("newdefault", model()->GetDefaultSearchProvider()->sync_guid());
1568   EXPECT_EQ("newdefault", profile_a()->GetTestingPrefService()->GetString(
1569       prefs::kSyncedDefaultSearchProviderGUID));
1570 }
1571
1572 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultArrivesAfterStartup) {
1573   // Start with the default set to something in the model before we start
1574   // syncing.
1575   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"),
1576                                      "http://thewhat.com/{searchTerms}",
1577                                      "initdefault"));
1578   model()->SetUserSelectedDefaultSearchProvider(
1579       model()->GetTemplateURLForGUID("initdefault"));
1580
1581   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
1582   ASSERT_TRUE(default_search);
1583
1584   // Set kSyncedDefaultSearchProviderGUID to something that is not yet in
1585   // the model but is expected in the initial sync. Ensure that this doesn't
1586   // change our default since we're not quite syncing yet.
1587   profile_a()->GetTestingPrefService()->SetString(
1588       prefs::kSyncedDefaultSearchProviderGUID, "key2");
1589
1590   EXPECT_EQ(default_search, model()->GetDefaultSearchProvider());
1591
1592   // Now sync the initial data, which will include the search engine entry
1593   // destined to become the new default.
1594   syncer::SyncDataList initial_data = CreateInitialSyncData();
1595   // The default search provider should support replacement.
1596   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key2"),
1597       "http://key2.com/{searchTerms}", "key2", 90));
1598   initial_data[1] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
1599
1600   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1601       PassProcessor(), CreateAndPassSyncErrorFactory());
1602
1603   // Ensure that the new default has been set.
1604   EXPECT_EQ(4U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1605   ASSERT_NE(default_search, model()->GetDefaultSearchProvider());
1606   ASSERT_EQ("key2", model()->GetDefaultSearchProvider()->sync_guid());
1607 }
1608
1609 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultAlreadySetOnStartup) {
1610   // Start with the default set to something in the model before we start
1611   // syncing.
1612   const char kGUID[] = "initdefault";
1613   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"),
1614                                      "http://thewhat.com/{searchTerms}",
1615                                      kGUID));
1616   model()->SetUserSelectedDefaultSearchProvider(
1617       model()->GetTemplateURLForGUID(kGUID));
1618
1619   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
1620   ASSERT_TRUE(default_search);
1621
1622   // Set kSyncedDefaultSearchProviderGUID to the current default.
1623   profile_a()->GetTestingPrefService()->SetString(
1624       prefs::kSyncedDefaultSearchProviderGUID, kGUID);
1625
1626   EXPECT_EQ(default_search, model()->GetDefaultSearchProvider());
1627
1628   // Now sync the initial data.
1629   syncer::SyncDataList initial_data = CreateInitialSyncData();
1630   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1631       PassProcessor(), CreateAndPassSyncErrorFactory());
1632
1633   // Ensure that the new entries were added and the default has not changed.
1634   EXPECT_EQ(4U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1635   ASSERT_EQ(default_search, model()->GetDefaultSearchProvider());
1636 }
1637
1638 TEST_F(TemplateURLServiceSyncTest, SyncWithManagedDefaultSearch) {
1639   // First start off with a few entries and make sure we can set an unmanaged
1640   // default search provider.
1641   syncer::SyncDataList initial_data = CreateInitialSyncData();
1642   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1643       PassProcessor(), CreateAndPassSyncErrorFactory());
1644   model()->SetUserSelectedDefaultSearchProvider(
1645       model()->GetTemplateURLForGUID("key2"));
1646
1647   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1648   ASSERT_FALSE(model()->is_default_search_managed());
1649   ASSERT_TRUE(model()->GetDefaultSearchProvider());
1650
1651   // Change the default search provider to a managed one.
1652   const char kName[] = "manageddefault";
1653   const char kSearchURL[] = "http://manageddefault.com/search?t={searchTerms}";
1654   const char kIconURL[] = "http://manageddefault.com/icon.jpg";
1655   const char kEncodings[] = "UTF-16;UTF-32";
1656   const char kAlternateURL[] =
1657       "http://manageddefault.com/search#t={searchTerms}";
1658   const char kSearchTermsReplacementKey[] = "espv";
1659   test_util_a_->SetManagedDefaultSearchPreferences(true, kName, kName,
1660       kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL,
1661       kSearchTermsReplacementKey);
1662   const TemplateURL* dsp_turl = model()->GetDefaultSearchProvider();
1663
1664   EXPECT_TRUE(model()->is_default_search_managed());
1665
1666   // Add a new entry from Sync. It should still sync in despite the default
1667   // being managed.
1668   syncer::SyncChangeList changes;
1669   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
1670       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"),
1671                             "http://new.com/{searchTerms}",
1672                             "newdefault")));
1673   model()->ProcessSyncChanges(FROM_HERE, changes);
1674
1675   EXPECT_EQ(4U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1676
1677   // Change kSyncedDefaultSearchProviderGUID to point to the new entry and
1678   // ensure that the DSP remains managed.
1679   profile_a()->GetTestingPrefService()->SetString(
1680       prefs::kSyncedDefaultSearchProviderGUID,
1681       "newdefault");
1682
1683   EXPECT_EQ(dsp_turl, model()->GetDefaultSearchProvider());
1684   EXPECT_TRUE(model()->is_default_search_managed());
1685
1686   // Go unmanaged. Ensure that the DSP changes to the expected pending entry
1687   // from Sync.
1688   const TemplateURL* expected_default =
1689       model()->GetTemplateURLForGUID("newdefault");
1690   test_util_a_->RemoveManagedDefaultSearchPreferences();
1691
1692   EXPECT_EQ(expected_default, model()->GetDefaultSearchProvider());
1693 }
1694
1695 TEST_F(TemplateURLServiceSyncTest, SyncMergeDeletesDefault) {
1696   // If the value from Sync is a duplicate of the local default and is newer, it
1697   // should safely replace the local value and set as the new default.
1698   TemplateURL* default_turl = CreateTestTemplateURL(ASCIIToUTF16("key1"),
1699       "http://key1.com/{searchTerms}", "whateverguid", 10);
1700   model()->Add(default_turl);
1701   model()->SetUserSelectedDefaultSearchProvider(default_turl);
1702
1703   syncer::SyncDataList initial_data = CreateInitialSyncData();
1704   // The key1 entry should be a duplicate of the default.
1705   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("key1"),
1706       "http://key1.com/{searchTerms}", "key1", 90));
1707   initial_data[0] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
1708
1709   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1710       PassProcessor(), CreateAndPassSyncErrorFactory());
1711
1712   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1713   EXPECT_FALSE(model()->GetTemplateURLForGUID("whateverguid"));
1714   EXPECT_EQ(model()->GetDefaultSearchProvider(),
1715             model()->GetTemplateURLForGUID("key1"));
1716 }
1717
1718 TEST_F(TemplateURLServiceSyncTest, LocalDefaultWinsConflict) {
1719   // We expect that the local default always wins keyword conflict resolution.
1720   const base::string16 keyword(ASCIIToUTF16("key1"));
1721   const std::string url("http://whatever.com/{searchTerms}");
1722   TemplateURL* default_turl = CreateTestTemplateURL(keyword,
1723                                                     url,
1724                                                     "whateverguid",
1725                                                     10);
1726   model()->Add(default_turl);
1727   model()->SetUserSelectedDefaultSearchProvider(default_turl);
1728
1729   syncer::SyncDataList initial_data = CreateInitialSyncData();
1730   // The key1 entry should be different from the default but conflict in the
1731   // keyword.
1732   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(keyword,
1733       "http://key1.com/{searchTerms}", "key1", 90));
1734   initial_data[0] = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
1735
1736   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1737       PassProcessor(), CreateAndPassSyncErrorFactory());
1738
1739   // Since the local default was not yet synced, it should be merged with the
1740   // conflicting TemplateURL. However, its values should have been preserved
1741   // since it would have won conflict resolution due to being the default.
1742   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
1743   const TemplateURL* winner = model()->GetTemplateURLForGUID("key1");
1744   ASSERT_TRUE(winner);
1745   EXPECT_EQ(model()->GetDefaultSearchProvider(), winner);
1746   EXPECT_EQ(keyword, winner->keyword());
1747   EXPECT_EQ(url, winner->url());
1748   ASSERT_TRUE(processor()->contains_guid("key1"));
1749   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
1750             processor()->change_for_guid("key1").change_type());
1751   EXPECT_EQ(url, GetURL(processor()->change_for_guid("key1").sync_data()));
1752
1753   // There is no loser, as the two were merged together. The local sync_guid
1754   // should no longer be found in the model.
1755   const TemplateURL* loser = model()->GetTemplateURLForGUID("whateverguid");
1756   ASSERT_FALSE(loser);
1757 }
1758
1759 TEST_F(TemplateURLServiceSyncTest, DeleteBogusData) {
1760   // Create a couple of bogus entries to sync.
1761   syncer::SyncDataList initial_data;
1762   scoped_ptr<TemplateURL> turl(
1763       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1"));
1764   initial_data.push_back(
1765       CreateCustomSyncData(*turl, false, std::string(), turl->sync_guid()));
1766   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
1767   initial_data.push_back(
1768       CreateCustomSyncData(*turl, false, turl->url(), std::string()));
1769
1770   // Now try to sync the data locally.
1771   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1772       PassProcessor(), CreateAndPassSyncErrorFactory());
1773
1774   // Nothing should have been added, and both bogus entries should be marked for
1775   // deletion.
1776   EXPECT_EQ(0U, model()->GetTemplateURLs().size());
1777   EXPECT_EQ(2U, processor()->change_list_size());
1778   ASSERT_TRUE(processor()->contains_guid("key1"));
1779   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
1780             processor()->change_for_guid("key1").change_type());
1781   ASSERT_TRUE(processor()->contains_guid(std::string()));
1782   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
1783             processor()->change_for_guid(std::string()).change_type());
1784 }
1785
1786 TEST_F(TemplateURLServiceSyncTest, PreSyncDeletes) {
1787   model()->pre_sync_deletes_.insert("key1");
1788   model()->pre_sync_deletes_.insert("key2");
1789   model()->pre_sync_deletes_.insert("aaa");
1790   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("whatever"),
1791       "http://key1.com", "bbb"));
1792   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
1793       syncer::SEARCH_ENGINES,
1794       CreateInitialSyncData(), PassProcessor(),
1795       CreateAndPassSyncErrorFactory());
1796
1797   // We expect the model to have GUIDs {bbb, key3} after our initial merge.
1798   EXPECT_TRUE(model()->GetTemplateURLForGUID("bbb"));
1799   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
1800   syncer::SyncChange change = processor()->change_for_guid("key1");
1801   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change.change_type());
1802   change = processor()->change_for_guid("key2");
1803   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change.change_type());
1804   // "aaa" should have been pruned out on account of not being from Sync.
1805   EXPECT_FALSE(processor()->contains_guid("aaa"));
1806   // The set of pre-sync deletes should be cleared so they're not reused if
1807   // MergeDataAndStartSyncing gets called again.
1808   EXPECT_TRUE(model()->pre_sync_deletes_.empty());
1809
1810   // Those sync items deleted via pre-sync-deletes should not get added. The
1811   // remaining sync item (key3) should though.
1812   EXPECT_EQ(1, merge_result.num_items_added());
1813   EXPECT_EQ(0, merge_result.num_items_modified());
1814   EXPECT_EQ(0, merge_result.num_items_deleted());
1815   EXPECT_EQ(1, merge_result.num_items_before_association());
1816   EXPECT_EQ(2, merge_result.num_items_after_association());
1817 }
1818
1819 TEST_F(TemplateURLServiceSyncTest, PreSyncUpdates) {
1820   const char* kNewKeyword = "somethingnew";
1821   // Fetch the prepopulate search engines so we know what they are.
1822   size_t default_search_provider_index = 0;
1823   ScopedVector<TemplateURLData> prepop_turls =
1824       TemplateURLPrepopulateData::GetPrepopulatedEngines(
1825           profile_a()->GetTestingPrefService(), &default_search_provider_index);
1826
1827   // We have to prematurely exit this test if for some reason this machine does
1828   // not have any prepopulate TemplateURLs.
1829   ASSERT_FALSE(prepop_turls.empty());
1830
1831   // Create a copy of the first TemplateURL with a really old timestamp and a
1832   // new keyword. Add it to the model.
1833   TemplateURLData data_copy(*prepop_turls[0]);
1834   data_copy.last_modified = Time::FromTimeT(10);
1835   base::string16 original_keyword = data_copy.keyword();
1836   data_copy.SetKeyword(ASCIIToUTF16(kNewKeyword));
1837   // Set safe_for_autoreplace to false so our keyword survives.
1838   data_copy.safe_for_autoreplace = false;
1839   model()->Add(new TemplateURL(data_copy));
1840
1841   // Merge the prepopulate search engines.
1842   base::Time pre_merge_time = base::Time::Now();
1843   base::RunLoop().RunUntilIdle();
1844   test_util_a_->ResetModel(true);
1845
1846   // The newly added search engine should have been safely merged, with an
1847   // updated time.
1848   TemplateURL* added_turl = model()->GetTemplateURLForKeyword(
1849       ASCIIToUTF16(kNewKeyword));
1850   ASSERT_TRUE(added_turl);
1851   base::Time new_timestamp = added_turl->last_modified();
1852   EXPECT_GE(new_timestamp, pre_merge_time);
1853   std::string sync_guid = added_turl->sync_guid();
1854
1855   // Bring down a copy of the prepopulate engine from Sync with the old values,
1856   // including the old timestamp and the same GUID. Ensure that it loses
1857   // conflict resolution against the local value, and an update is sent to the
1858   // server. The new timestamp should be preserved.
1859   syncer::SyncDataList initial_data;
1860   data_copy.SetKeyword(original_keyword);
1861   data_copy.sync_guid = sync_guid;
1862   scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data_copy));
1863   initial_data.push_back(
1864       TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
1865
1866   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
1867       syncer::SEARCH_ENGINES,
1868       initial_data, PassProcessor(), CreateAndPassSyncErrorFactory());
1869
1870   ASSERT_EQ(added_turl, model()->GetTemplateURLForKeyword(
1871       ASCIIToUTF16(kNewKeyword)));
1872   EXPECT_EQ(new_timestamp, added_turl->last_modified());
1873   syncer::SyncChange change = processor()->change_for_guid(sync_guid);
1874   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
1875   EXPECT_EQ(kNewKeyword,
1876             change.sync_data().GetSpecifics().search_engine().keyword());
1877   EXPECT_EQ(new_timestamp, base::Time::FromInternalValue(
1878       change.sync_data().GetSpecifics().search_engine().last_modified()));
1879
1880   // All the sync data is old, so nothing should change locally.
1881   EXPECT_EQ(0, merge_result.num_items_added());
1882   EXPECT_EQ(0, merge_result.num_items_modified());
1883   EXPECT_EQ(0, merge_result.num_items_deleted());
1884   EXPECT_EQ(static_cast<int>(prepop_turls.size()),
1885             merge_result.num_items_before_association());
1886   EXPECT_EQ(static_cast<int>(prepop_turls.size()),
1887             merge_result.num_items_after_association());
1888 }
1889
1890 TEST_F(TemplateURLServiceSyncTest, SyncBaseURLs) {
1891   // Verify that bringing in a remote TemplateURL that uses Google base URLs
1892   // causes it to get a local keyword that matches the local base URL.
1893   test_util_a_->SetGoogleBaseURL(GURL("http://google.com/"));
1894   syncer::SyncDataList initial_data;
1895   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(
1896       ASCIIToUTF16("google.co.uk"), "{google:baseURL}search?q={searchTerms}",
1897       "guid"));
1898   initial_data.push_back(
1899       TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
1900   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES, initial_data,
1901       PassProcessor(), CreateAndPassSyncErrorFactory());
1902   TemplateURL* synced_turl = model()->GetTemplateURLForGUID("guid");
1903   ASSERT_TRUE(synced_turl);
1904   EXPECT_EQ(ASCIIToUTF16("google.com"), synced_turl->keyword());
1905   EXPECT_EQ(0U, processor()->change_list_size());
1906
1907   // Remote updates to this URL's keyword should be silently ignored.
1908   syncer::SyncChangeList changes;
1909   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
1910       CreateTestTemplateURL(ASCIIToUTF16("google.de"),
1911           "{google:baseURL}search?q={searchTerms}", "guid")));
1912   model()->ProcessSyncChanges(FROM_HERE, changes);
1913   EXPECT_EQ(ASCIIToUTF16("google.com"), synced_turl->keyword());
1914   EXPECT_EQ(0U, processor()->change_list_size());
1915
1916   // A local change to the Google base URL should update the keyword and
1917   // generate a sync change.
1918   test_util_a_->SetGoogleBaseURL(GURL("http://google.co.in/"));
1919   EXPECT_EQ(ASCIIToUTF16("google.co.in"), synced_turl->keyword());
1920   EXPECT_EQ(1U, processor()->change_list_size());
1921   ASSERT_TRUE(processor()->contains_guid("guid"));
1922   syncer::SyncChange change(processor()->change_for_guid("guid"));
1923   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
1924   EXPECT_EQ("google.co.in", GetKeyword(change.sync_data()));
1925 }
1926
1927 TEST_F(TemplateURLServiceSyncTest, MergeInSyncTemplateURL) {
1928   // An enumeration used to indicate which TemplateURL test value is expected
1929   // for a particular test result.
1930   enum ExpectedTemplateURL {
1931     LOCAL,
1932     SYNC,
1933     BOTH,
1934     NEITHER,
1935   };
1936
1937   // Sets up and executes a MergeInSyncTemplateURL test given a number of
1938   // expected start and end states:
1939   //  * |conflict_winner| denotes which TemplateURL should win the
1940   //    conflict.
1941   //  * |synced_at_start| denotes which of the TemplateURLs should known
1942   //    to Sync.
1943   //  * |update_sent| denotes which TemplateURL should have an
1944   //    ACTION_UPDATE sent to the server after the merge.
1945   //  * |turl_uniquified| denotes which TemplateURL should have its
1946   //    keyword updated after the merge.
1947   //  * |present_in_model| denotes which TemplateURL should be found in
1948   //    the model after the merge.
1949   //  * If |keywords_conflict| is true, the TemplateURLs are set up with
1950   //    the same keyword.
1951   const struct {
1952     ExpectedTemplateURL conflict_winner;
1953     ExpectedTemplateURL synced_at_start;
1954     ExpectedTemplateURL update_sent;
1955     ExpectedTemplateURL turl_uniquified;
1956     ExpectedTemplateURL present_in_model;
1957     bool keywords_conflict;
1958     int merge_results[3];  // in Added, Modified, Deleted order.
1959   } test_cases[] = {
1960     // Both are synced and the new sync entry is better: Local is uniquified and
1961     // UPDATE sent. Sync is added.
1962     {SYNC, BOTH, LOCAL, LOCAL, BOTH, true, {1, 1, 0}},
1963     // Both are synced and the local entry is better: Sync is uniquified and
1964     // added to the model. An UPDATE is sent for it.
1965     {LOCAL, BOTH, SYNC, SYNC, BOTH, true, {1, 1, 0}},
1966     // Local was not known to Sync and the new sync entry is better: Sync is
1967     // added. Local is removed. No updates.
1968     {SYNC, SYNC, NEITHER, NEITHER, SYNC, true, {1, 0, 1}},
1969     // Local was not known to sync and the local entry is better: Local is
1970     // updated with sync GUID, Sync is not added. UPDATE sent for Sync.
1971     {LOCAL, SYNC, SYNC, NEITHER, SYNC, true, {0, 1, 0}},
1972     // No conflicting keyword. Both should be added with their original
1973     // keywords, with no updates sent. Note that MergeDataAndStartSyncing is
1974     // responsible for creating the ACTION_ADD for the local TemplateURL.
1975     {NEITHER, SYNC, NEITHER, NEITHER, BOTH, false, {1, 0, 0}},
1976   };
1977
1978   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
1979     // Assert all the valid states of ExpectedTemplateURLs.
1980     ASSERT_FALSE(test_cases[i].conflict_winner == BOTH);
1981     ASSERT_FALSE(test_cases[i].synced_at_start == NEITHER);
1982     ASSERT_FALSE(test_cases[i].synced_at_start == LOCAL);
1983     ASSERT_FALSE(test_cases[i].update_sent == BOTH);
1984     ASSERT_FALSE(test_cases[i].turl_uniquified == BOTH);
1985     ASSERT_FALSE(test_cases[i].present_in_model == NEITHER);
1986
1987     const base::string16 local_keyword = ASCIIToUTF16("localkeyword");
1988     const base::string16 sync_keyword = test_cases[i].keywords_conflict ?
1989         local_keyword : ASCIIToUTF16("synckeyword");
1990     const std::string local_url = "www.localurl.com";
1991     const std::string sync_url = "www.syncurl.com";
1992     const time_t local_last_modified = 100;
1993     const time_t sync_last_modified =
1994         test_cases[i].conflict_winner == SYNC ? 110 : 90;
1995     const std::string local_guid = "local_guid";
1996     const std::string sync_guid = "sync_guid";
1997
1998     // Initialize expectations.
1999     base::string16 expected_local_keyword = local_keyword;
2000     base::string16 expected_sync_keyword = sync_keyword;
2001
2002     // Create the data and run the actual test.
2003     TemplateURL* local_turl = CreateTestTemplateURL(
2004         local_keyword, local_url, local_guid, local_last_modified);
2005     model()->Add(local_turl);
2006     scoped_ptr<TemplateURL> sync_turl(CreateTestTemplateURL(
2007         sync_keyword, sync_url, sync_guid, sync_last_modified));
2008
2009     SyncDataMap sync_data;
2010     if (test_cases[i].synced_at_start == SYNC ||
2011         test_cases[i].synced_at_start == BOTH) {
2012       sync_data[sync_turl->sync_guid()] =
2013           TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl);
2014     }
2015     if (test_cases[i].synced_at_start == BOTH) {
2016       sync_data[local_turl->sync_guid()] =
2017           TemplateURLService::CreateSyncDataFromTemplateURL(*local_turl);
2018     }
2019     SyncDataMap initial_data;
2020     initial_data[local_turl->sync_guid()] =
2021         TemplateURLService::CreateSyncDataFromTemplateURL(*local_turl);
2022
2023     syncer::SyncChangeList change_list;
2024     syncer::SyncMergeResult merge_result(syncer::SEARCH_ENGINES);
2025     model()->MergeInSyncTemplateURL(sync_turl.get(),
2026                                     sync_data,
2027                                     &change_list,
2028                                     &initial_data,
2029                                     &merge_result);
2030
2031     // Verify the merge results were set appropriately.
2032     EXPECT_EQ(test_cases[i].merge_results[0], merge_result.num_items_added());
2033     EXPECT_EQ(test_cases[i].merge_results[1],
2034               merge_result.num_items_modified());
2035     EXPECT_EQ(test_cases[i].merge_results[2], merge_result.num_items_deleted());
2036
2037     // Check for expected updates, if any.
2038     std::string expected_update_guid;
2039     if (test_cases[i].update_sent == LOCAL)
2040       expected_update_guid = local_guid;
2041     else if (test_cases[i].update_sent == SYNC)
2042       expected_update_guid = sync_guid;
2043     if (!expected_update_guid.empty()) {
2044       ASSERT_EQ(1U, change_list.size());
2045       EXPECT_EQ(expected_update_guid, GetGUID(change_list[0].sync_data()));
2046       EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
2047                 change_list[0].change_type());
2048     } else {
2049       EXPECT_EQ(0U, change_list.size());
2050     }
2051
2052     // Adjust the expectations based on the expectation enums.
2053     if (test_cases[i].turl_uniquified == LOCAL) {
2054       DCHECK(test_cases[i].keywords_conflict);
2055       expected_local_keyword = ASCIIToUTF16("localkeyword_");
2056     }
2057     if (test_cases[i].turl_uniquified == SYNC) {
2058       DCHECK(test_cases[i].keywords_conflict);
2059       expected_sync_keyword = ASCIIToUTF16("localkeyword_");
2060     }
2061
2062     // Check for TemplateURLs expected in the model. Note that this is checked
2063     // by GUID rather than the initial pointer, as a merge could occur (the
2064     // Sync TemplateURL overtakes the local one). Also remove the present
2065     // TemplateURL when done so the next test case starts with a clean slate.
2066     if (test_cases[i].present_in_model == LOCAL ||
2067         test_cases[i].present_in_model == BOTH) {
2068       ASSERT_TRUE(model()->GetTemplateURLForGUID(local_guid));
2069       EXPECT_EQ(expected_local_keyword, local_turl->keyword());
2070       EXPECT_EQ(local_url, local_turl->url());
2071       EXPECT_EQ(local_last_modified, local_turl->last_modified().ToTimeT());
2072       model()->Remove(model()->GetTemplateURLForGUID(local_guid));
2073     }
2074     if (test_cases[i].present_in_model == SYNC ||
2075         test_cases[i].present_in_model == BOTH) {
2076       ASSERT_TRUE(model()->GetTemplateURLForGUID(sync_guid));
2077       EXPECT_EQ(expected_sync_keyword, sync_turl->keyword());
2078       EXPECT_EQ(sync_url, sync_turl->url());
2079       EXPECT_EQ(sync_last_modified, sync_turl->last_modified().ToTimeT());
2080       model()->Remove(model()->GetTemplateURLForGUID(sync_guid));
2081     }
2082   }  // for
2083 }
2084
2085 TEST_F(TemplateURLServiceSyncTest, MergePrepopulatedEngine) {
2086   scoped_ptr<TemplateURLData> default_turl(
2087       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
2088
2089   // Merge with an initial list containing a prepopulated engine with a wrong
2090   // URL.
2091   syncer::SyncDataList list;
2092   scoped_ptr<TemplateURL> sync_turl(CopyTemplateURL(default_turl.get(),
2093       "http://wrong.url.com?q={searchTerms}", "default"));
2094   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
2095   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
2096       syncer::SEARCH_ENGINES, list, PassProcessor(),
2097       CreateAndPassSyncErrorFactory());
2098
2099   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
2100   EXPECT_TRUE(result_turl);
2101   EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
2102   EXPECT_EQ(default_turl->short_name, result_turl->short_name());
2103   EXPECT_EQ(default_turl->url(), result_turl->url());
2104 }
2105
2106 TEST_F(TemplateURLServiceSyncTest, AddPrepopulatedEngine) {
2107   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
2108       syncer::SEARCH_ENGINES, syncer::SyncDataList(), PassProcessor(),
2109       CreateAndPassSyncErrorFactory());
2110
2111   scoped_ptr<TemplateURLData> default_turl(
2112       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
2113   TemplateURL* sync_turl = CopyTemplateURL(default_turl.get(),
2114       "http://wrong.url.com?q={searchTerms}", "default");
2115
2116   // Add a prepopulated engine with a wrong URL.
2117   syncer::SyncChangeList changes;
2118   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
2119                                          sync_turl));
2120   model()->ProcessSyncChanges(FROM_HERE, changes);
2121
2122   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
2123   EXPECT_TRUE(result_turl);
2124   EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
2125   EXPECT_EQ(default_turl->short_name, result_turl->short_name());
2126   EXPECT_EQ(default_turl->url(), result_turl->url());
2127 }
2128
2129 TEST_F(TemplateURLServiceSyncTest, UpdatePrepopulatedEngine) {
2130   scoped_ptr<TemplateURLData> default_turl(
2131       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
2132
2133   TemplateURLData data = *default_turl;
2134   data.SetURL("http://old.wrong.url.com?q={searchTerms}");
2135   data.sync_guid = "default";
2136   model()->Add(new TemplateURL(data));
2137
2138   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
2139       syncer::SEARCH_ENGINES, syncer::SyncDataList(), PassProcessor(),
2140       CreateAndPassSyncErrorFactory());
2141
2142   TemplateURL* sync_turl = CopyTemplateURL(default_turl.get(),
2143       "http://new.wrong.url.com?q={searchTerms}", "default");
2144
2145   // Update the engine in the model, which is prepopulated, with a new one.
2146   // Both have wrong URLs, but it should still get corrected.
2147   syncer::SyncChangeList changes;
2148   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
2149                                          sync_turl));
2150   model()->ProcessSyncChanges(FROM_HERE, changes);
2151
2152   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
2153   EXPECT_TRUE(result_turl);
2154   EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
2155   EXPECT_EQ(default_turl->short_name, result_turl->short_name());
2156   EXPECT_EQ(default_turl->url(), result_turl->url());
2157 }
2158
2159 TEST_F(TemplateURLServiceSyncTest, MergeEditedPrepopulatedEngine) {
2160   scoped_ptr<TemplateURLData> default_turl(
2161       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
2162
2163   TemplateURLData data(*default_turl);
2164   data.safe_for_autoreplace = false;
2165   data.SetKeyword(ASCIIToUTF16("new_kw"));
2166   data.short_name = ASCIIToUTF16("my name");
2167   data.SetURL("http://wrong.url.com?q={searchTerms}");
2168   data.date_created = Time::FromTimeT(50);
2169   data.last_modified = Time::FromTimeT(50);
2170   data.sync_guid = "default";
2171   model()->Add(new TemplateURL(data));
2172
2173   data.date_created = Time::FromTimeT(100);
2174   data.last_modified = Time::FromTimeT(100);
2175   scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data));
2176   syncer::SyncDataList list;
2177   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
2178   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
2179       syncer::SEARCH_ENGINES, list, PassProcessor(),
2180       CreateAndPassSyncErrorFactory());
2181
2182   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
2183   EXPECT_TRUE(result_turl);
2184   EXPECT_EQ(ASCIIToUTF16("new_kw"), result_turl->keyword());
2185   EXPECT_EQ(ASCIIToUTF16("my name"), result_turl->short_name());
2186   EXPECT_EQ(default_turl->url(), result_turl->url());
2187 }
2188
2189 TEST_F(TemplateURLServiceSyncTest, MergeNonEditedPrepopulatedEngine) {
2190   scoped_ptr<TemplateURLData> default_turl(
2191       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
2192
2193   TemplateURLData data(*default_turl);
2194   data.safe_for_autoreplace = true;  // Can be replaced with built-in values.
2195   data.SetKeyword(ASCIIToUTF16("new_kw"));
2196   data.short_name = ASCIIToUTF16("my name");
2197   data.SetURL("http://wrong.url.com?q={searchTerms}");
2198   data.date_created = Time::FromTimeT(50);
2199   data.last_modified = Time::FromTimeT(50);
2200   data.sync_guid = "default";
2201   model()->Add(new TemplateURL(data));
2202
2203   data.date_created = Time::FromTimeT(100);
2204   data.last_modified = Time::FromTimeT(100);
2205   scoped_ptr<TemplateURL> sync_turl(new TemplateURL(data));
2206   syncer::SyncDataList list;
2207   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
2208   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
2209       syncer::SEARCH_ENGINES, list, PassProcessor(),
2210       CreateAndPassSyncErrorFactory());
2211
2212   const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
2213   EXPECT_TRUE(result_turl);
2214   EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
2215   EXPECT_EQ(default_turl->short_name, result_turl->short_name());
2216   EXPECT_EQ(default_turl->url(), result_turl->url());
2217 }
2218
2219 TEST_F(TemplateURLServiceSyncTest, GUIDUpdatedOnDefaultSearchChange) {
2220   const char kGUID[] = "initdefault";
2221   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"),
2222                                      "http://thewhat.com/{searchTerms}",
2223                                      kGUID));
2224   model()->SetUserSelectedDefaultSearchProvider(
2225       model()->GetTemplateURLForGUID(kGUID));
2226
2227   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
2228   ASSERT_TRUE(default_search);
2229
2230   const char kNewGUID[] = "newdefault";
2231   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"),
2232                                      "http://thewhat.com/{searchTerms}",
2233                                      kNewGUID));
2234   model()->SetUserSelectedDefaultSearchProvider(
2235       model()->GetTemplateURLForGUID(kNewGUID));
2236
2237   EXPECT_EQ(kNewGUID, profile_a()->GetTestingPrefService()->GetString(
2238       prefs::kSyncedDefaultSearchProviderGUID));
2239 }