Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(526)

Unified Diff: chrome/browser/search_engines/template_url_service_sync_unittest.cc

Issue 7566036: Implement SyncableServices in TemplateURLService. Add related unittests. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: Recommitting patch. Repaired memory leaks and adjusted unittests to reflect changes. Created 9 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: chrome/browser/search_engines/template_url_service_sync_unittest.cc
===================================================================
--- chrome/browser/search_engines/template_url_service_sync_unittest.cc (revision 0)
+++ chrome/browser/search_engines/template_url_service_sync_unittest.cc (revision 0)
@@ -0,0 +1,982 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/memory/scoped_ptr.h"
+#include "base/string_util.h"
+#include "base/time.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/search_engines/template_url.h"
+#include "chrome/browser/search_engines/template_url_service.h"
+#include "chrome/browser/sync/protocol/search_engine_specifics.pb.h"
+#include "chrome/test/base/testing_browser_process_test.h"
+#include "chrome/test/base/testing_profile.h"
+
+using base::Time;
+
+namespace {
+
+// Extract the GUID from a search engine SyncData.
+std::string GetGUID(const SyncData& sync_data) {
+ return sync_data.GetSpecifics().GetExtension(
+ sync_pb::search_engine).sync_guid();
+}
+
+// Extract the keyword from a search engine SyncData.
+std::string GetURL(const SyncData& sync_data) {
+ return sync_data.GetSpecifics().GetExtension(
+ sync_pb::search_engine).url();
+}
+
+// Extract the keyword from a search engine SyncData.
+std::string GetKeyword(const SyncData& sync_data) {
+ return sync_data.GetSpecifics().GetExtension(
+ sync_pb::search_engine).keyword();
+}
+
+// Dummy SyncChangeProcessor used to help review what SyncChanges are pushed
+// back up to Sync.
+class TestChangeProcessor : public SyncChangeProcessor {
+ public:
+ TestChangeProcessor() : erroneous_(false) {
+ }
+ virtual ~TestChangeProcessor() { }
+
+ // Store a copy of all the changes passed in so we can examine them later.
+ virtual SyncError ProcessSyncChanges(
+ const tracked_objects::Location& from_here,
+ const SyncChangeList& change_list) {
+ if (erroneous_)
+ return SyncError(FROM_HERE, "Some error.", syncable::SEARCH_ENGINES);
+
+ change_map_.erase(change_map_.begin(), change_map_.end());
+ for (SyncChangeList::const_iterator iter = change_list.begin();
+ iter != change_list.end(); ++iter) {
+ change_map_[GetGUID(iter->sync_data())] = *iter;
+ }
+
+ return SyncError();
+ }
+
+ bool ContainsGUID(const std::string& guid) {
+ return change_map_.find(guid) != change_map_.end();
+ }
+
+ SyncChange GetChangeByGUID(const std::string& guid) {
+ DCHECK(ContainsGUID(guid));
+ return change_map_[guid];
+ }
+
+ int change_list_size() { return change_map_.size(); }
+
+ void set_erroneous(bool erroneous) { erroneous_ = erroneous; }
+
+ private:
+ // Track the changes received in ProcessSyncChanges.
+ std::map<std::string, SyncChange> change_map_;
+ bool erroneous_;
+
+ DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor);
+};
+
+class TemplateURLServiceSyncTest : public TestingBrowserProcessTest {
+ public:
+ typedef TemplateURLService::SyncDataMap SyncDataMap;
+
+ TemplateURLServiceSyncTest() {}
+
+ virtual void SetUp() {
+ profile_a_.reset(new TestingProfile);
+ model_a_.reset(new TemplateURLService(profile_a_.get()));
+ model_a_->Load();
+ profile_b_.reset(new TestingProfile);
+ model_b_.reset(new TemplateURLService(profile_b_.get()));
+ model_b_->Load();
+ }
+
+ virtual void TearDown() { }
+
+ TemplateURLService* model() { return model_a_.get(); }
+ // For readability, we redefine an accessor for Model A for use in tests that
+ // involve syncing two models.
+ TemplateURLService* model_a() { return model_a_.get(); }
+ TemplateURLService* model_b() { return model_b_.get(); }
+ TestChangeProcessor* processor() { return &processor_; }
+
+ // Create a TemplateURL with some test values. The caller owns the returned
+ // TemplateURL*.
+ TemplateURL* CreateTestTemplateURL() const {
+ TemplateURL* turl = new TemplateURL();
+ turl->SetURL("http://www.unittest.com/", 0, 0);
+ turl->set_keyword(ASCIIToUTF16("unittest"));
+ turl->set_short_name(ASCIIToUTF16("unittest"));
+ turl->set_safe_for_autoreplace(true);
+ GURL favicon_url("http://favicon.url");
+ turl->SetFaviconURL(favicon_url);
+ turl->set_date_created(Time::FromTimeT(100));
+ turl->set_last_modified(Time::FromTimeT(100));
+ turl->SetPrepopulateId(999999);
+ return turl;
+ }
+
+ // Convenience helpers for creating TemplateURLs with specific fields.
+ TemplateURL* CreateTestTemplateURL(std::string keyword,
+ std::string url) const {
+ TemplateURL* turl = CreateTestTemplateURL();
+ turl->set_keyword(UTF8ToUTF16(keyword));
+ turl->SetURL(url, 0, 0);
+ return turl;
+ }
+
+ TemplateURL* CreateTestTemplateURL(std::string keyword,
+ std::string url,
+ std::string guid) const {
+ TemplateURL* turl = CreateTestTemplateURL(keyword, url);
+ if (!guid.empty())
+ turl->set_sync_guid(guid);
+ return turl;
+ }
+
+ TemplateURL* CreateTestTemplateURL(std::string keyword,
+ std::string url,
+ std::string guid,
+ time_t last_mod) const {
+ TemplateURL* turl = CreateTestTemplateURL(keyword, url, guid);
+ turl->set_last_modified(Time::FromTimeT(last_mod));
+ return turl;
+ }
+
+ // Verifies the two TemplateURLs are equal.
+ // TODO(stevet): Share this with TemplateURLServiceTest.
+ void AssertEquals(const TemplateURL& expected,
+ const TemplateURL& actual) const {
+ ASSERT_TRUE(TemplateURLRef::SameUrlRefs(expected.url(), actual.url()));
+ ASSERT_TRUE(TemplateURLRef::SameUrlRefs(expected.suggestions_url(),
+ actual.suggestions_url()));
+ ASSERT_EQ(expected.keyword(), actual.keyword());
+ ASSERT_EQ(expected.short_name(), actual.short_name());
+ ASSERT_EQ(JoinString(expected.input_encodings(), ';'),
+ JoinString(actual.input_encodings(), ';'));
+ ASSERT_TRUE(expected.GetFaviconURL() == actual.GetFaviconURL());
+ ASSERT_EQ(expected.id(), actual.id());
+ ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace());
+ ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list());
+ ASSERT_TRUE(expected.date_created() == actual.date_created());
+ ASSERT_TRUE(expected.last_modified() == actual.last_modified());
+ }
+
+ // Expect that two SyncDataLists have equal contents, in terms of the
+ // sync_guid, keyword, and url fields.
+ void AssertEquals(const SyncDataList& data1,
+ const SyncDataList& data2) const {
+ SyncDataMap map1 = TemplateURLService::CreateGUIDToSyncDataMap(data1);
+ SyncDataMap map2 = TemplateURLService::CreateGUIDToSyncDataMap(data2);
+
+ for (SyncDataMap::const_iterator iter1 = map1.begin();
+ iter1 != map1.end(); iter1++) {
+ SyncDataMap::iterator iter2 = map2.find(iter1->first);
+ if (iter2 != map2.end()) {
+ ASSERT_EQ(GetKeyword(iter1->second), GetKeyword(iter2->second));
+ ASSERT_EQ(GetURL(iter1->second), GetURL(iter2->second));
+ map2.erase(iter2);
+ }
+ }
+ EXPECT_EQ(0U, map2.size());
+ }
+
+ // Convenience helper for creating SyncChanges. Takes ownership of |turl|.
+ SyncChange CreateTestSyncChange(SyncChange::SyncChangeType type,
+ TemplateURL* turl) const {
+ // We take control of the TemplateURL so make sure it's cleaned up after
+ // we create data out of it.
+ scoped_ptr<TemplateURL> scoped_turl(turl);
+ return SyncChange(
+ type, TemplateURLService::CreateSyncDataFromTemplateURL(*scoped_turl));
+ }
+
+ // Helper that creates some initial sync data. We cheat a little by specifying
+ // GUIDs for easy identification later. We also make the last_modified times
+ // slightly older than CreateTestTemplateURL's default, to test conflict
+ // resolution.
+ SyncDataList CreateInitialSyncData() const {
+ SyncDataList list;
+
+ scoped_ptr<TemplateURL> turl(
+ CreateTestTemplateURL("key1", "http://key1.com", "key1", 90));
+ list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
+ turl.reset(CreateTestTemplateURL("key2", "http://key2.com", "key2", 90));
+ list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
+ turl.reset(CreateTestTemplateURL("key3", "http://key3.com", "key3", 90));
+ list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
+
+ return list;
+ }
+
+ protected:
+ // We keep two TemplateURLServices to test syncing between them.
+ scoped_ptr<TestingProfile> profile_a_;
+ scoped_ptr<TemplateURLService> model_a_;
+ scoped_ptr<TestingProfile> profile_b_;
+ scoped_ptr<TemplateURLService> model_b_;
+
+ // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
+ TestChangeProcessor processor_;
+
+ DISALLOW_COPY_AND_ASSIGN(TemplateURLServiceSyncTest);
+};
+
+} // namespace
+
+TEST_F(TemplateURLServiceSyncTest, SerializeDeserialize) {
+ // Create a TemplateURL and convert it into a sync specific type.
+ scoped_ptr<TemplateURL> turl(CreateTestTemplateURL());
+ SyncData sync_data = TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
+ // Convert the specifics back to a TemplateURL.
+ scoped_ptr<TemplateURL> deserialized(
+ TemplateURLService::CreateTemplateURLFromSyncData(sync_data));
+ EXPECT_TRUE(deserialized.get());
+ // Ensure that the original and the deserialized TURLs are equal in values.
+ AssertEquals(*turl, *deserialized);
+}
+
+TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataBasic) {
+ model()->Add(CreateTestTemplateURL("key1", "http://key1.com"));
+ model()->Add(CreateTestTemplateURL("key2", "http://key2.com"));
+ model()->Add(CreateTestTemplateURL("key3", "http://key3.com"));
+ SyncDataList all_sync_data =
+ model()->GetAllSyncData(syncable::SEARCH_ENGINES);
+
+ EXPECT_EQ(3U, all_sync_data.size());
+
+ for (SyncDataList::const_iterator iter = all_sync_data.begin();
+ iter != all_sync_data.end(); ++iter) {
+ std::string guid = GetGUID(*iter);
+ const TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
+ scoped_ptr<TemplateURL> deserialized(
+ TemplateURLService::CreateTemplateURLFromSyncData(*iter));
+ AssertEquals(*service_turl, *deserialized);
+ }
+}
+
+TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataNoExtensions) {
+ model()->Add(CreateTestTemplateURL("key1", "http://key1.com"));
+ model()->Add(CreateTestTemplateURL("key2", "http://key2.com"));
+ model()->Add(CreateTestTemplateURL(
+ "key3", "chrome-extension://blahblahblah"));
+ SyncDataList all_sync_data =
+ model()->GetAllSyncData(syncable::SEARCH_ENGINES);
+
+ EXPECT_EQ(2U, all_sync_data.size());
+
+ for (SyncDataList::const_iterator iter = all_sync_data.begin();
+ iter != all_sync_data.end(); ++iter) {
+ std::string guid = GetGUID(*iter);
+ const TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
+ scoped_ptr<TemplateURL> deserialized(
+ TemplateURLService::CreateTemplateURLFromSyncData(*iter));
+ AssertEquals(*service_turl, *deserialized);
+ }
+}
+
+TEST_F(TemplateURLServiceSyncTest, UniquifyKeyword) {
+ model()->Add(CreateTestTemplateURL("key1", "http://key1.com"));
+ // Create a key that conflicts with something in the model.
+ scoped_ptr<TemplateURL> turl(CreateTestTemplateURL("key1",
+ "http://new.com",
+ "xyz"));
+ string16 new_keyword = model()->UniquifyKeyword(*turl);
+
+ EXPECT_EQ(UTF8ToUTF16("new.com"), new_keyword);
+ EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
+
+ turl->set_keyword(new_keyword);
+ model()->Add(turl.release());
+ // Test a second collision. This time it should be resolved by actually
+ // modifying the original keyword, since the autogenerated keyword is already
+ // used.
+ turl.reset(CreateTestTemplateURL("key1", "http://new.com"));
+ new_keyword = model()->UniquifyKeyword(*turl);
+
+ EXPECT_EQ(UTF8ToUTF16("key1_"), new_keyword);
+ EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
+
+ turl->set_keyword(new_keyword);
+ model()->Add(turl.release());
+ // Test a third collision. This should collide on both the autogenerated
+ // keyword and the first uniquification attempt.
+ turl.reset(CreateTestTemplateURL("key1", "http://new.com"));
+ new_keyword = model()->UniquifyKeyword(*turl);
+
+ EXPECT_EQ(UTF8ToUTF16("key1__"), new_keyword);
+ EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(new_keyword));
+}
+
+TEST_F(TemplateURLServiceSyncTest, ResolveSyncKeywordConflict) {
+ TemplateURL* original_turl =
+ CreateTestTemplateURL("key1", "http://key1.com", std::string(), 9000);
+ string16 original_turl_keyword = original_turl->keyword();
+ model()->Add(original_turl);
+
+ // Create a key that does not conflict with something in the model.
+ scoped_ptr<TemplateURL> sync_turl(CreateTestTemplateURL("unique",
+ "http://new.com"));
+ string16 sync_keyword = sync_turl->keyword();
+ SyncChangeList changes;
+
+ // No conflict, no TURLs changed, no changes.
+ EXPECT_FALSE(model()->ResolveSyncKeywordConflict(sync_turl.get(), changes));
+ EXPECT_EQ(original_turl_keyword, original_turl->keyword());
+ EXPECT_EQ(sync_keyword, sync_turl->keyword());
+ EXPECT_EQ(0U, changes.size());
+
+ // Change sync keyword to something that conflicts, and make it older.
+ // Conflict, sync keyword is uniquified, and a SyncChange is added.
+ sync_turl->set_keyword(original_turl->keyword());
+ sync_turl->set_last_modified(Time::FromTimeT(8999));
+ EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(), changes));
+ EXPECT_NE(sync_keyword, sync_turl->keyword());
+ EXPECT_EQ(original_turl_keyword, original_turl->keyword());
+ EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(sync_turl->keyword()));
+ EXPECT_EQ(1U, changes.size());
+ changes.clear();
+
+ // Sync is newer. Original TemplateURL keyword is uniquified, no SyncChange
+ // is added.
+ sync_turl->set_keyword(original_turl->keyword());
+ sync_keyword = sync_turl->keyword();
+ sync_turl->set_last_modified(Time::FromTimeT(9001));
+ EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(), changes));
+ EXPECT_EQ(sync_keyword, sync_turl->keyword());
+ EXPECT_NE(original_turl_keyword, original_turl->keyword());
+ EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(sync_turl->keyword()));
+ EXPECT_EQ(0U, changes.size());
+
+ // Equal times. Same result as above. Sync left alone, original uniquified so
+ // sync_turl can fit.
+ sync_turl->set_keyword(original_turl->keyword());
+ sync_keyword = sync_turl->keyword();
+ // Note that we have to reset original_turl's last_modified time as it was
+ // modified above.
+ original_turl->set_last_modified(Time::FromTimeT(9000));
+ sync_turl->set_last_modified(Time::FromTimeT(9000));
+ EXPECT_TRUE(model()->ResolveSyncKeywordConflict(sync_turl.get(), changes));
+ EXPECT_EQ(sync_keyword, sync_turl->keyword());
+ EXPECT_NE(original_turl_keyword, original_turl->keyword());
+ EXPECT_EQ(NULL, model()->GetTemplateURLForKeyword(sync_turl->keyword()));
+ EXPECT_EQ(0U, changes.size());
+}
+
+TEST_F(TemplateURLServiceSyncTest, FindDuplicateOfSyncTemplateURL) {
+ TemplateURL* original_turl =
+ CreateTestTemplateURL("key1", "http://key1.com");
+ model()->Add(original_turl);
+
+ // No matches at all.
+ scoped_ptr<TemplateURL> sync_turl(
+ CreateTestTemplateURL("key2", "http://key2.com"));
+ EXPECT_EQ(NULL, model()->FindDuplicateOfSyncTemplateURL(*sync_turl));
+
+ // URL matches, but not keyword. No dupe.
+ sync_turl->SetURL("http://key1.com", 0 , 0);
+ EXPECT_EQ(NULL, model()->FindDuplicateOfSyncTemplateURL(*sync_turl));
+
+ // Keyword matches, but not URL. No dupe.
+ sync_turl->SetURL("http://key2.com", 0 , 0);
+ sync_turl->set_keyword(UTF8ToUTF16("key1"));
+ EXPECT_EQ(NULL, model()->FindDuplicateOfSyncTemplateURL(*sync_turl));
+
+ // Duplicate.
+ sync_turl->SetURL("http://key1.com", 0 , 0);
+ const TemplateURL* dupe_turl =
+ model()->FindDuplicateOfSyncTemplateURL(*sync_turl);
+ ASSERT_TRUE(dupe_turl);
+ EXPECT_EQ(dupe_turl->keyword(), sync_turl->keyword());
+ EXPECT_EQ(dupe_turl->url()->url(), sync_turl->url()->url());
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeSyncAndLocalURLDuplicates) {
+ TemplateURL* original_turl =
+ CreateTestTemplateURL("key1", "http://key1.com", std::string(), 9000);
+ model()->Add(original_turl);
+ TemplateURL* sync_turl =
+ CreateTestTemplateURL("key1", "http://key1.com", std::string(), 9001);
+ SyncChangeList changes;
+
+ // The sync TemplateURL is newer. It should replace the original TemplateURL.
+ // Note that MergeSyncAndLocalURLDuplicates takes ownership of sync_turl.
+ model()->MergeSyncAndLocalURLDuplicates(sync_turl, original_turl, changes);
+ const TemplateURL* result =
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("key1"));
+ ASSERT_TRUE(result);
+ EXPECT_EQ(9001, result->last_modified().ToTimeT());
+ EXPECT_EQ(0U, changes.size());
+
+ // The sync TemplateURL is older. The existing TemplateURL should win and a
+ // SyncChange should be added to the list.
+ TemplateURL* sync_turl2 =
+ CreateTestTemplateURL("key1", "http://key1.com", std::string(), 8999);
+ model()->MergeSyncAndLocalURLDuplicates(sync_turl2, sync_turl, changes);
+ result = model()->GetTemplateURLForKeyword(UTF8ToUTF16("key1"));
+ ASSERT_TRUE(result);
+ EXPECT_EQ(9001, result->last_modified().ToTimeT());
+ EXPECT_EQ(1U, changes.size());
+}
+
+TEST_F(TemplateURLServiceSyncTest, StartSyncEmpty) {
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ SyncDataList(), // Empty.
+ processor());
+
+ EXPECT_EQ(0U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+ EXPECT_EQ(0, processor()->change_list_size());
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeIntoEmpty) {
+ SyncDataList initial_data = CreateInitialSyncData();
+
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ initial_data,
+ processor());
+
+ EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+ // We expect the model to have accepted all of the initial sync data. Search
+ // through the model using the GUIDs to ensure that they're present.
+ for (SyncDataList::const_iterator iter = initial_data.begin();
+ iter != initial_data.end(); ++iter) {
+ std::string guid = GetGUID(*iter);
+ EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
+ }
+
+ EXPECT_EQ(0, processor()->change_list_size());
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeInAllNewData) {
+ model()->Add(CreateTestTemplateURL(
+ "google.com", "http://google.com", "abc"));
+ model()->Add(CreateTestTemplateURL("yahoo.com", "http://yahoo.com", "def"));
+ model()->Add(CreateTestTemplateURL("bing.com", "http://bing.com", "xyz"));
+ SyncDataList initial_data = CreateInitialSyncData();
+
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ initial_data,
+ processor());
+
+ EXPECT_EQ(6U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+ // We expect the model to have accepted all of the initial sync data. Search
+ // through the model using the GUIDs to ensure that they're present.
+ for (SyncDataList::const_iterator iter = initial_data.begin();
+ iter != initial_data.end(); ++iter) {
+ std::string guid = GetGUID(*iter);
+ EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
+ }
+ // All the original TemplateURLs should also remain in the model.
+ EXPECT_TRUE(model()->GetTemplateURLForKeyword(UTF8ToUTF16("google.com")));
+ EXPECT_TRUE(model()->GetTemplateURLForKeyword(UTF8ToUTF16("yahoo.com")));
+ EXPECT_TRUE(model()->GetTemplateURLForKeyword(UTF8ToUTF16("bing.com")));
+ // Ensure that Sync received the expected changes.
+ EXPECT_EQ(3, processor()->change_list_size());
+ EXPECT_TRUE(processor()->ContainsGUID("abc"));
+ EXPECT_TRUE(processor()->ContainsGUID("def"));
+ EXPECT_TRUE(processor()->ContainsGUID("xyz"));
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeSyncIsTheSame) {
+ // The local data is the same as the sync data merged in. i.e. - There have
+ // been no changes since the last time we synced. Even the last_modified
+ // timestamps are the same.
+ SyncDataList initial_data = CreateInitialSyncData();
+ for (SyncDataList::const_iterator iter = initial_data.begin();
+ iter != initial_data.end(); ++iter) {
+ TemplateURL* converted =
+ TemplateURLService::CreateTemplateURLFromSyncData(*iter);
+ model()->Add(converted);
+ }
+
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ initial_data,
+ processor());
+
+ EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+ for (SyncDataList::const_iterator iter = initial_data.begin();
+ iter != initial_data.end(); ++iter) {
+ std::string guid = GetGUID(*iter);
+ EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
+ }
+ EXPECT_EQ(0, processor()->change_list_size());
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeUpdateFromSync) {
+ // The local data is the same as the sync data merged in, but timestamps have
+ // changed. Ensure the right fields are merged in.
+ SyncDataList initial_data;
+ TemplateURL* turl1 = CreateTestTemplateURL(
+ "google.com", "http://google.com", "abc", 9000);
+ model()->Add(turl1);
+ TemplateURL* turl2 = CreateTestTemplateURL(
+ "bing.com", "http://bing.com", "xyz", 9000);
+ model()->Add(turl2);
+
+ TemplateURL turl1_newer(*turl1);
+ turl1_newer.set_last_modified(Time::FromTimeT(9999));
+ turl1_newer.SetURL("http://google.ca", 0, 0);
+ initial_data.push_back(
+ TemplateURLService::CreateSyncDataFromTemplateURL(turl1_newer));
+
+ TemplateURL turl2_older(*turl2);
+ turl2_older.set_last_modified(Time::FromTimeT(8888));
+ turl2_older.SetURL("http://bing.ca", 0, 0);
+ initial_data.push_back(
+ TemplateURLService::CreateSyncDataFromTemplateURL(turl2_older));
+
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ initial_data,
+ processor());
+
+ // Both were local updates, so we expect the same count.
+ EXPECT_EQ(2U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+
+ // Check that the first replaced the initial Google TemplateURL.
+ EXPECT_EQ(turl1, model()->GetTemplateURLForGUID("abc"));
+ EXPECT_EQ("http://google.ca", turl1->url()->url());
+
+ // Check that the second produced an upstream update to the Bing TemplateURL.
+ EXPECT_EQ(1, processor()->change_list_size());
+ ASSERT_TRUE(processor()->ContainsGUID("xyz"));
+ SyncChange change = processor()->GetChangeByGUID("xyz");
+ EXPECT_TRUE(change.change_type() == SyncChange::ACTION_UPDATE);
+ EXPECT_EQ("http://bing.com", GetURL(change.sync_data()));
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeAddFromOlderSyncData) {
+ // GUIDs all differ, so this is data to be added from Sync, but the timestamps
+ // from Sync are older. Set up the local data so that one is a dupe, one has a
+ // conflicting keyword, and the last has no conflicts (a clean ADD).
+ SyncDataList initial_data = CreateInitialSyncData();
+ TemplateURL* turl = TemplateURLService::CreateTemplateURLFromSyncData(
+ initial_data.at(0));
+ ASSERT_TRUE(turl);
+ turl->set_sync_guid("aaa");
+ turl->set_last_modified(Time::FromTimeT(100));
+ model()->Add(turl); // dupe
+
+ turl = TemplateURLService::CreateTemplateURLFromSyncData(
+ initial_data.at(1));
+ ASSERT_TRUE(turl);
+ turl->SetURL("http://expected.com", 0, 0);
+ turl->set_sync_guid("bbb");
+ turl->set_last_modified(Time::FromTimeT(100));
+ model()->Add(turl); // keyword conflict
+
+ model()->Add(CreateTestTemplateURL(
+ "unique", "http://unique.com", "ccc")); // add
+
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ initial_data,
+ processor());
+
+ // The dupe results in a merge. The other two should be added to the model.
+ EXPECT_EQ(5U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+
+ // The key1 duplicate results in the local copy winning. Ensure that Sync's
+ // copy was not added, and the local copy is pushed upstream to Sync as an
+ // update. The local copy should have received the sync data's GUID.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
+ // Check changes for the UPDATE.
+ ASSERT_TRUE(processor()->ContainsGUID("key1"));
+ SyncChange key1_change = processor()->GetChangeByGUID("key1");
+ EXPECT_EQ(SyncChange::ACTION_UPDATE, key1_change.change_type());
+ EXPECT_FALSE(model()->GetTemplateURLForGUID("aaa"));
+
+ // The key2 keyword conflict results in the local copy winning, so ensure it
+ // retains the original keyword, and that an update to the sync copy is pushed
+ // upstream to Sync. Both TemplateURLs should be found locally, however.
+ const TemplateURL* key2 = model()->GetTemplateURLForGUID("bbb");
+ EXPECT_TRUE(key2);
+ EXPECT_EQ(UTF8ToUTF16("key2"), key2->keyword());
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
+ // Check changes for the UPDATE.
+ ASSERT_TRUE(processor()->ContainsGUID("key2"));
+ SyncChange key2_change = processor()->GetChangeByGUID("key2");
+ EXPECT_EQ(SyncChange::ACTION_UPDATE, key2_change.change_type());
+ EXPECT_EQ("key2.com", GetKeyword(key2_change.sync_data()));
+
+ // The last TemplateURL should have had no conflicts and was just added. It
+ // should not have replaced the third local TemplateURL.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("ccc"));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
+
+ // Two UPDATEs and two ADDs.
+ EXPECT_EQ(4, processor()->change_list_size());
+ // Two ADDs should be pushed up to Sync.
+ ASSERT_TRUE(processor()->ContainsGUID("bbb"));
+ EXPECT_EQ(SyncChange::ACTION_ADD,
+ processor()->GetChangeByGUID("bbb").change_type());
+ ASSERT_TRUE(processor()->ContainsGUID("ccc"));
+ EXPECT_EQ(SyncChange::ACTION_ADD,
+ processor()->GetChangeByGUID("ccc").change_type());
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeAddFromNewerSyncData) {
+ // GUIDs all differ, so this is data to be added from Sync, but the timestamps
+ // from Sync are newer. Set up the local data so that one is a dupe, one has a
+ // conflicting keyword, and the last has no conflicts (a clean ADD).
+ SyncDataList initial_data = CreateInitialSyncData();
+ TemplateURL* turl = TemplateURLService::CreateTemplateURLFromSyncData(
+ initial_data.at(0));
+ ASSERT_TRUE(turl);
+ turl->set_sync_guid("aaa");
+ turl->set_last_modified(Time::FromTimeT(10));
+ model()->Add(turl); // dupe
+
+ turl = TemplateURLService::CreateTemplateURLFromSyncData(
+ initial_data.at(1));
+ ASSERT_TRUE(turl);
+ turl->SetURL("http://expected.com", 0, 0);
+ turl->set_sync_guid("bbb");
+ turl->set_last_modified(Time::FromTimeT(10));
+ model()->Add(turl); // keyword conflict
+
+ model()->Add(CreateTestTemplateURL(
+ "unique", "http://unique.com", "ccc", 10)); // add
+
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ initial_data,
+ processor());
+
+ // The dupe results in a merge. The other two should be added to the model.
+ EXPECT_EQ(5U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+
+ // The key1 duplicate results in Sync's copy winning. Ensure that Sync's
+ // copy replaced the local copy.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
+ EXPECT_FALSE(model()->GetTemplateURLForGUID("aaa"));
+
+ // The key2 keyword conflict results in Sync's copy winning, so ensure it
+ // retains the original keyword. The local copy should get a uniquified
+ // keyword. Both TemplateURLs should be found locally.
+ const TemplateURL* key2_sync = model()->GetTemplateURLForGUID("key2");
+ EXPECT_TRUE(key2_sync);
+ EXPECT_EQ(UTF8ToUTF16("key2"), key2_sync->keyword());
+ const TemplateURL* key2_local = model()->GetTemplateURLForGUID("bbb");
+ EXPECT_TRUE(key2_local);
+ EXPECT_EQ(UTF8ToUTF16("expected.com"), key2_local->keyword());
+
+ // The last TemplateURL should have had no conflicts and was just added. It
+ // should not have replaced the third local TemplateURL.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("ccc"));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
+
+ // Two ADDs.
+ EXPECT_EQ(2, processor()->change_list_size());
+ // Two ADDs should be pushed up to Sync.
+ ASSERT_TRUE(processor()->ContainsGUID("bbb"));
+ EXPECT_EQ(SyncChange::ACTION_ADD,
+ processor()->GetChangeByGUID("bbb").change_type());
+ ASSERT_TRUE(processor()->ContainsGUID("ccc"));
+ EXPECT_EQ(SyncChange::ACTION_ADD,
+ processor()->GetChangeByGUID("ccc").change_type());
+}
+
+TEST_F(TemplateURLServiceSyncTest, ProcessChangesEmptyModel) {
+ // We initially have no data.
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ SyncDataList(),
+ processor());
+
+ // Set up a bunch of ADDs.
+ SyncChangeList changes;
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_ADD,
+ CreateTestTemplateURL("key1", "http://key1.com", "key1")));
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_ADD,
+ CreateTestTemplateURL("key2", "http://key2.com", "key2")));
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_ADD,
+ CreateTestTemplateURL("key3", "http://key3.com", "key3")));
+
+ model()->ProcessSyncChanges(FROM_HERE, changes);
+
+ EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+ EXPECT_EQ(0, processor()->change_list_size());
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
+}
+
+TEST_F(TemplateURLServiceSyncTest, ProcessChangesNoConflicts) {
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+
+ // Process different types of changes, without conflicts.
+ SyncChangeList changes;
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_ADD,
+ CreateTestTemplateURL("key4", "http://key4.com", "key4")));
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_UPDATE,
+ CreateTestTemplateURL("newkeyword", "http://new.com", "key2")));
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_DELETE,
+ CreateTestTemplateURL("key3", "http://key3.com", "key3")));
+
+ model()->ProcessSyncChanges(FROM_HERE, changes);
+
+ // Add one, remove one, update one, so the number shouldn't change.
+ EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+ EXPECT_EQ(0, processor()->change_list_size());
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
+ const TemplateURL* turl = model()->GetTemplateURLForGUID("key2");
+ EXPECT_TRUE(turl);
+ EXPECT_EQ(UTF8ToUTF16("newkeyword"), turl->keyword());
+ EXPECT_EQ("http://new.com", turl->url()->url());
+ EXPECT_FALSE(model()->GetTemplateURLForGUID("key3"));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key4"));
+}
+
+TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithConflictsSyncWins) {
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+
+ // Process different types of changes, with conflicts. Note that all this data
+ // has a newer timestamp, so Sync will win in these scenarios.
+ SyncChangeList changes;
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_ADD,
+ CreateTestTemplateURL("key2", "http://new.com", "aaa")));
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_UPDATE,
+ CreateTestTemplateURL("key3", "http://key3.com", "key1")));
+
+ model()->ProcessSyncChanges(FROM_HERE, changes);
+
+ // Add one, update one, so we're up to 4.
+ EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+ // Sync is always newer here, so it should always win (i.e. - local changes,
+ // nothing pushed to Sync).
+ EXPECT_EQ(0, processor()->change_list_size());
+
+ // aaa conflicts with key2 and wins, forcing key2's keyword to update.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("aaa"));
+ EXPECT_EQ(model()->GetTemplateURLForGUID("aaa"),
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("key2")));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
+ EXPECT_EQ(model()->GetTemplateURLForGUID("key2"),
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("key2.com")));
+ // key1 update conflicts with key3 and wins, forcing key3's keyword to update.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
+ EXPECT_EQ(model()->GetTemplateURLForGUID("key1"),
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("key3")));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
+ EXPECT_EQ(model()->GetTemplateURLForGUID("key3"),
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("key3.com")));
+}
+
+TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithConflictsLocalWins) {
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+
+ // Process different types of changes, with conflicts. Note that all this data
+ // has an older timestamp, so the local data will win in these scenarios.
+ SyncChangeList changes;
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_ADD,
+ CreateTestTemplateURL("key2", "http://new.com", "aaa", 10)));
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_UPDATE,
+ CreateTestTemplateURL("key3", "http://key3.com", "key1", 10)));
+
+ model()->ProcessSyncChanges(FROM_HERE, changes);
+
+ // Add one, update one, so we're up to 4.
+ EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
+ // Local data wins twice so two updates are pushed up to Sync.
+ EXPECT_EQ(2, processor()->change_list_size());
+
+ // aaa conflicts with key2 and loses, forcing it's keyword to update.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("aaa"));
+ EXPECT_EQ(model()->GetTemplateURLForGUID("aaa"),
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("new.com")));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
+ EXPECT_EQ(model()->GetTemplateURLForGUID("key2"),
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("key2")));
+ // key1 update conflicts with key3 and loses, forcing key1's keyword to
+ // update.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
+ EXPECT_EQ(model()->GetTemplateURLForGUID("key1"),
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("key3.com")));
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
+ EXPECT_EQ(model()->GetTemplateURLForGUID("key3"),
+ model()->GetTemplateURLForKeyword(UTF8ToUTF16("key3")));
+
+ ASSERT_TRUE(processor()->ContainsGUID("aaa"));
+ EXPECT_EQ(SyncChange::ACTION_UPDATE,
+ processor()->GetChangeByGUID("aaa").change_type());
+ ASSERT_TRUE(processor()->ContainsGUID("key1"));
+ EXPECT_EQ(SyncChange::ACTION_UPDATE,
+ processor()->GetChangeByGUID("key1").change_type());
+}
+
+TEST_F(TemplateURLServiceSyncTest, ProcessTemplateURLChange) {
+ // Ensure that ProcessTemplateURLChange is called and pushes the correct
+ // changes to Sync whenever local changes are made to TemplateURLs.
+ model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+
+ // Add a new search engine.
+ TemplateURL* new_turl =
+ CreateTestTemplateURL("baidu", "http://baidu.cn", "new");
+ model()->Add(new_turl);
+ EXPECT_EQ(1, processor()->change_list_size());
+ ASSERT_TRUE(processor()->ContainsGUID("new"));
+ SyncChange change = processor()->GetChangeByGUID("new");
+ EXPECT_EQ(SyncChange::ACTION_ADD, change.change_type());
+ EXPECT_EQ("baidu", GetKeyword(change.sync_data()));
+ EXPECT_EQ("http://baidu.cn", GetURL(change.sync_data()));
+
+ // Change a keyword.
+ const TemplateURL* existing_turl = model()->GetTemplateURLForGUID("key1");
+ model()->ResetTemplateURL(existing_turl,
+ existing_turl->short_name(),
+ UTF8ToUTF16("k"),
+ existing_turl->url()->url());
+ EXPECT_EQ(1, processor()->change_list_size());
+ ASSERT_TRUE(processor()->ContainsGUID("key1"));
+ change = processor()->GetChangeByGUID("key1");
+ EXPECT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
+ EXPECT_EQ("k", GetKeyword(change.sync_data()));
+
+ // Remove an existing search engine.
+ existing_turl = model()->GetTemplateURLForGUID("key2");
+ model()->Remove(existing_turl);
+ EXPECT_EQ(1, processor()->change_list_size());
+ ASSERT_TRUE(processor()->ContainsGUID("key2"));
+ change = processor()->GetChangeByGUID("key2");
+ EXPECT_EQ(SyncChange::ACTION_DELETE, change.change_type());
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeTwoClientsBasic) {
+ // Start off B with some empty data.
+ model_b()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+
+ // Merge A and B. All of B's data should transfer over to A, which initially
+ // has no data.
+ model_a()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ model_b()->GetAllSyncData(syncable::SEARCH_ENGINES),
+ model_b());
+
+ // They should be consistent.
+ AssertEquals(model_a()->GetAllSyncData(syncable::SEARCH_ENGINES),
+ model_b()->GetAllSyncData(syncable::SEARCH_ENGINES));
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeTwoClientsDupesAndConflicts) {
+ // Start off B with some empty data.
+ model_b()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+
+ // Set up A so we have some interesting duplicates and conflicts.
+ model_a()->Add(CreateTestTemplateURL(
+ "key4", "http://key4.com", "key4")); // Added
+ model_a()->Add(CreateTestTemplateURL(
+ "key2", "http://key2.com", "key2")); // Merge - Copy of key2.
+ model_a()->Add(CreateTestTemplateURL(
+ "key3", "http://key3.com", "key5", 10)); // Merge - Dupe of key3.
+ model_a()->Add(CreateTestTemplateURL(
+ "key1", "http://key6.com", "key6", 10)); // Keyword conflict with key1
+
+ // Merge A and B.
+ model_a()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ model_b()->GetAllSyncData(syncable::SEARCH_ENGINES),
+ model_b());
+
+ // They should be consistent.
+ AssertEquals(model_a()->GetAllSyncData(syncable::SEARCH_ENGINES),
+ model_b()->GetAllSyncData(syncable::SEARCH_ENGINES));
+}
+
+TEST_F(TemplateURLServiceSyncTest, StopSyncing) {
+ SyncError error = model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+ ASSERT_FALSE(error.IsSet());
+ model()->StopSyncing(syncable::SEARCH_ENGINES);
+
+ SyncChangeList changes;
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_UPDATE,
+ CreateTestTemplateURL("newkeyword", "http://new.com", "key2")));
+ error = model()->ProcessSyncChanges(FROM_HERE, changes);
+ EXPECT_TRUE(error.IsSet());
+
+ // Ensure that the sync changes were not accepted.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
+ EXPECT_FALSE(model()->GetTemplateURLForKeyword(UTF8ToUTF16("newkeyword")));
+}
+
+TEST_F(TemplateURLServiceSyncTest, SyncErrorOnInitialSync) {
+ processor()->set_erroneous(true);
+ SyncError error = model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+ EXPECT_TRUE(error.IsSet());
+
+ // Ensure that if the initial merge was erroneous, then subsequence attempts
+ // to push data into the local model are rejected, since the model was never
+ // successfully associated with Sync in the first place.
+ SyncChangeList changes;
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_UPDATE,
+ CreateTestTemplateURL("newkeyword", "http://new.com", "key2")));
+ processor()->set_erroneous(false);
+ error = model()->ProcessSyncChanges(FROM_HERE, changes);
+ EXPECT_TRUE(error.IsSet());
+
+ // Ensure that the sync changes were not accepted.
+ EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
+ EXPECT_FALSE(model()->GetTemplateURLForKeyword(UTF8ToUTF16("newkeyword")));
+}
+
+TEST_F(TemplateURLServiceSyncTest, SyncErrorOnLaterSync) {
+ // Ensure that if the SyncProcessor succeeds in the initial merge, but fails
+ // in future ProcessSyncChanges, we still return an error.
+ SyncError error = model()->MergeDataAndStartSyncing(
+ syncable::SEARCH_ENGINES,
+ CreateInitialSyncData(),
+ processor());
+ ASSERT_FALSE(error.IsSet());
+
+ SyncChangeList changes;
+ changes.push_back(CreateTestSyncChange(
+ SyncChange::ACTION_UPDATE,
+ CreateTestTemplateURL("newkeyword", "http://new.com", "key2")));
+ processor()->set_erroneous(true);
+ error = model()->ProcessSyncChanges(FROM_HERE, changes);
+ EXPECT_TRUE(error.IsSet());
+}
Property changes on: chrome\browser\search_engines\template_url_service_sync_unittest.cc
___________________________________________________________________
Added: svn:eol-style
+ LF

Powered by Google App Engine
This is Rietveld 408576698