Ensure post-sync TemplateURL of prepopulated engines use built-in version.

chrome/browser/search_engines/template_url_service_sync_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
@@ skipping 207 matching lines @@
 
   // 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.
   syncer::SyncDataList CreateInitialSyncData() const;
 
   // Syntactic sugar.
   TemplateURL* Deserialize(const syncer::SyncData& sync_data);
 
+  // Creates a new TemplateURL copying the fields of |turl| but replacing
+  // the |url| and |guid| and initializing the date_created and last_modified
+  // timestamps to |last_mod|. The caller owns the returned TemplateURL*.
+  TemplateURL* CopyTemplateURL(const TemplateURL* turl,
+                               const std::string& url,
+                               const std::string& guid,
+                               time_t last_mod = 100);

[Peter Kasting, 2013/02/04 20:35:32]

Google style guide bans default arguments

[beaudoin, 2013/02/04 22:33:40]

I got the idea from CreateTestTemplateURL above. :/  Should I correct this
everywhere?

I've removed this one as it's not really needed.

[Peter Kasting, 2013/02/04 23:52:29]

I wouldn't bother trying to fix existing usage, especially because
CreateTestTemplateURL() in particular is widely called.

+
  protected:
   // We keep two TemplateURLServices to test syncing between them.
   TemplateURLServiceTestUtil test_util_a_;
   scoped_ptr<TestingProfile> profile_b_;
   scoped_ptr<TemplateURLService> model_b_;
 
   // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
   scoped_ptr<TestChangeProcessor> sync_processor_;
   scoped_ptr<SyncChangeProcessorDelegate> sync_processor_delegate_;
 
@@ skipping 116 matching lines @@
   return list;
 }
 
 TemplateURL* TemplateURLServiceSyncTest::Deserialize(
     const syncer::SyncData& sync_data) {
   syncer::SyncChangeList dummy;
   return TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(NULL,
       NULL, sync_data, &dummy);
 }
 
+TemplateURL* TemplateURLServiceSyncTest::CopyTemplateURL(
+    const TemplateURL* turl,
+    const std::string& url,
+    const std::string& guid,
+    time_t last_mod) {
+  TemplateURLData data (turl->data());
+  data.SetURL(url);
+  data.date_created = Time::FromTimeT(last_mod);
+  data.last_modified = Time::FromTimeT(last_mod);
+  data.sync_guid = guid;
+  return new TemplateURL(NULL, data);
+}
 
 // Actual tests ---------------------------------------------------------------
 
 TEST_F(TemplateURLServiceSyncTest, SerializeDeserialize) {
   // Create a TemplateURL and convert it into a sync specific type.
   scoped_ptr<TemplateURL> turl(
       CreateTestTemplateURL(
           ASCIIToUTF16("unittest"), "http://www.unittest.com/"));
   syncer::SyncData sync_data =
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl);
@@ skipping 1309 matching lines @@
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   ASSERT_FALSE(model()->is_default_search_managed());
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 
   // Change the default search provider to a managed one.
   const char kName[] = "manageddefault";
   const char kSearchURL[] = "http://manageddefault.com/search?t={searchTerms}";
   const char kIconURL[] = "http://manageddefault.com/icon.jpg";
   const char kEncodings[] = "UTF-16;UTF-32";
+  const char kAlternateURL[] =
+      "http://manageddefault.com/search#t={searchTerms}";
+  const char kSearchTermsReplacementKey[] = "espv";
   test_util_a_.SetManagedDefaultSearchPreferences(true, kName, kName,
-      kSearchURL, std::string(), kIconURL, kEncodings);
+      kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL,
+      kSearchTermsReplacementKey);
   const TemplateURL* dsp_turl = model()->GetDefaultSearchProvider();
 
   EXPECT_TRUE(model()->is_default_search_managed());
 
   // Add a new entry from Sync. It should still sync in despite the default
   // being managed.
   syncer::SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"),
                             "http://new.com/{searchTerms}",
@@ skipping 403 matching lines @@
     if (test_cases[i].present_in_model == SYNC ||
         test_cases[i].present_in_model == BOTH) {
       ASSERT_TRUE(model()->GetTemplateURLForGUID(sync_guid));
       EXPECT_EQ(expected_sync_keyword, sync_turl->keyword());
       EXPECT_EQ(sync_url, sync_turl->url());
       EXPECT_EQ(sync_last_modified, sync_turl->last_modified().ToTimeT());
       model()->Remove(model()->GetTemplateURLForGUID(sync_guid));
     }
   }  // for
 }
+
+TEST_F(TemplateURLServiceSyncTest, MergePrepopulatedEngine) {
+  scoped_ptr<TemplateURL> default_turl(
+      TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
+
+  // Merge with an initial list containing a prepopulated engine with a wrong
+  // URL.
+  syncer::SyncDataList list;
+  scoped_ptr<TemplateURL> sync_turl(CopyTemplateURL(default_turl.get(),
+      "http://wrong.url.com?q={searchTerms}", "default"));
+  list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
+  syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
+      syncer::SEARCH_ENGINES, list, PassProcessor(),
+      CreateAndPassSyncErrorFactory());
+
+  const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
+  EXPECT_TRUE(result_turl);
+  EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
+  EXPECT_EQ(default_turl->short_name(), result_turl->short_name());
+  EXPECT_EQ(default_turl->url(), result_turl->url());
+}
+
+TEST_F(TemplateURLServiceSyncTest, AddPrepopulatedEngine) {
+  syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
+      syncer::SEARCH_ENGINES, syncer::SyncDataList(), PassProcessor(),
+      CreateAndPassSyncErrorFactory());
+
+  scoped_ptr<TemplateURL> default_turl(
+      TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
+  TemplateURL* sync_turl = CopyTemplateURL(default_turl.get(),
+      "http://wrong.url.com?q={searchTerms}", "default");
+
+  // Add a prepopulated engine with a wrong URL.
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
+                                         sync_turl));
+  model()->ProcessSyncChanges(FROM_HERE, changes);
+
+  const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
+  EXPECT_TRUE(result_turl);
+  EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
+  EXPECT_EQ(default_turl->short_name(), result_turl->short_name());
+  EXPECT_EQ(default_turl->url(), result_turl->url());
+}
+
+TEST_F(TemplateURLServiceSyncTest, UpdatePrepopulatedEngine) {
+  scoped_ptr<TemplateURL> default_turl(
+      TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
+
+  TemplateURLData data(default_turl->data());
+  data.SetURL("http://old.wrong.url.com?q={searchTerms}");
+  data.sync_guid = "default";
+  model()->Add(new TemplateURL(NULL, data));
+
+  syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
+      syncer::SEARCH_ENGINES, syncer::SyncDataList(), PassProcessor(),
+      CreateAndPassSyncErrorFactory());
+
+  TemplateURL* sync_turl = CopyTemplateURL(default_turl.get(),
+      "http://new.wrong.url.com?q={searchTerms}", "default");
+
+  // Update the engine in the model, which is prepopulated, with a new one.
+  // Both have wrong URLs, but it should still get corrected.
+  syncer::SyncChangeList changes;
+  changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_UPDATE,
+                                         sync_turl));
+  model()->ProcessSyncChanges(FROM_HERE, changes);
+
+  const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
+  EXPECT_TRUE(result_turl);
+  EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
+  EXPECT_EQ(default_turl->short_name(), result_turl->short_name());
+  EXPECT_EQ(default_turl->url(), result_turl->url());
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeEditedPrepopulatedEngine) {
+  scoped_ptr<TemplateURL> default_turl(
+      TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
+
+  TemplateURLData data(default_turl->data());
+  data.safe_for_autoreplace = false;
+  data.SetKeyword(ASCIIToUTF16("new_kw"));
+  data.short_name = ASCIIToUTF16("my name");
+  data.SetURL("http://wrong.url.com?q={searchTerms}");
+  data.date_created = Time::FromTimeT(50);
+  data.last_modified = Time::FromTimeT(50);
+  data.sync_guid = "default";
+  model()->Add(new TemplateURL(NULL, data));
+
+  data.date_created = Time::FromTimeT(100);
+  data.last_modified = Time::FromTimeT(100);
+  scoped_ptr<TemplateURL> sync_turl(new TemplateURL(NULL, data));
+  syncer::SyncDataList list;
+  list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
+  syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
+      syncer::SEARCH_ENGINES, list, PassProcessor(),
+      CreateAndPassSyncErrorFactory());
+
+  const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
+  EXPECT_TRUE(result_turl);
+  EXPECT_EQ(ASCIIToUTF16("new_kw"), result_turl->keyword());
+  EXPECT_EQ(ASCIIToUTF16("my name"), result_turl->short_name());
+  EXPECT_EQ(default_turl->url(), result_turl->url());
+}
+
+TEST_F(TemplateURLServiceSyncTest, MergeNonEditedPrepopulatedEngine) {
+  scoped_ptr<TemplateURL> default_turl(
+      TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(NULL));
+
+  TemplateURLData data(default_turl->data());
+  data.safe_for_autoreplace = true;  // Can be replaced with built-in values.
+  data.SetKeyword(ASCIIToUTF16("new_kw"));
+  data.short_name = ASCIIToUTF16("my name");
+  data.SetURL("http://wrong.url.com?q={searchTerms}");
+  data.date_created = Time::FromTimeT(50);
+  data.last_modified = Time::FromTimeT(50);
+  data.sync_guid = "default";
+  model()->Add(new TemplateURL(NULL, data));
+
+  data.date_created = Time::FromTimeT(100);
+  data.last_modified = Time::FromTimeT(100);
+  scoped_ptr<TemplateURL> sync_turl(new TemplateURL(NULL, data));
+  syncer::SyncDataList list;
+  list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*sync_turl));
+  syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
+      syncer::SEARCH_ENGINES, list, PassProcessor(),
+      CreateAndPassSyncErrorFactory());
+
+  const TemplateURL* result_turl = model()->GetTemplateURLForGUID("default");
+  EXPECT_TRUE(result_turl);
+  EXPECT_EQ(default_turl->keyword(), result_turl->keyword());
+  EXPECT_EQ(default_turl->short_name(), result_turl->short_name());
+  EXPECT_EQ(default_turl->url(), result_turl->url());
+}