Don't persist and sync omnibox extension keywords.

components/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/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 14 matching lines @@
 #include "sync/protocol/search_engine_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::Time;
 
 namespace {
 
+const char kOmniboxScheme[] = "omnibox";
+
 // Extract the GUID from a search engine syncer::SyncData.
 std::string GetGUID(const syncer::SyncData& sync_data) {
   return sync_data.GetSpecifics().search_engine().sync_guid();
 }
 
 // Extract the URL from a search engine syncer::SyncData.
 std::string GetURL(const syncer::SyncData& sync_data) {
   return sync_data.GetSpecifics().search_engine().url();
 }
 
@@ skipping 89 matching lines @@
         "Some error.",
         syncer::SEARCH_ENGINES);
 
   change_map_.erase(change_map_.begin(), change_map_.end());
   for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
       iter != change_list.end(); ++iter)
     change_map_[GetGUID(iter->sync_data())] = *iter;
   return syncer::SyncError();
 }
 
+class TestTemplateURLServiceClient : public TemplateURLServiceClient {
+ public:
+   ~TestTemplateURLServiceClient() override {}
+
+   void Shutdown() override {}
+   void SetOwner(TemplateURLService* owner) override {}
+   void DeleteAllSearchTermsForKeyword(TemplateURLID id) override {}
+   void SetKeywordSearchTermsForURL(
+       const GURL& url,
+       TemplateURLID id,
+       const base::string16& term) override {}
+   void AddKeywordGeneratedVisit(const GURL& url) override {}
+
+   void RestoreExtensionInfoIfNecessary(TemplateURL* template_url) override;
+};
+
+void TestTemplateURLServiceClient::RestoreExtensionInfoIfNecessary(
+    TemplateURL* template_url) {
+  const TemplateURLData& data = template_url->data();
+  GURL url(data.url());
+  if (url.SchemeIs(kOmniboxScheme)) {
+    const std::string& extension_id = url.host();
+    template_url->set_extension_info(make_scoped_ptr(
+        new TemplateURL::AssociatedExtensionInfo(
+            TemplateURL::OMNIBOX_API_EXTENSION, extension_id)));
+  }
+}
 
 }  // namespace
 
 
 // TemplateURLServiceSyncTest -------------------------------------------------
 
 class TemplateURLServiceSyncTest : public testing::Test {
  public:
   typedef TemplateURLService::SyncDataMap SyncDataMap;
 
@@ skipping 36 matching lines @@
       syncer::SyncChange::SyncChangeType type,
       TemplateURL* turl) const;
 
   // 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);
+  scoped_ptr<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 a default value of 100. The caller owns the returned
   // TemplateURL*.
   TemplateURL* CopyTemplateURL(const TemplateURLData* turl,
                                const std::string& url,
                                const std::string& guid);
 
  protected:
@@ skipping 117 matching lines @@
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com",
                                    "key2", 90));
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com",
                                    "key3", 90));
   list.push_back(TemplateURLService::CreateSyncDataFromTemplateURL(*turl));
 
   return list;
 }
 
-TemplateURL* TemplateURLServiceSyncTest::Deserialize(
+scoped_ptr<TemplateURL> TemplateURLServiceSyncTest::Deserialize(
     const syncer::SyncData& sync_data) {
   syncer::SyncChangeList dummy;
+  TestTemplateURLServiceClient client;
   return TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
-      NULL, SearchTermsData(), NULL, sync_data, &dummy);
+      &client, NULL, SearchTermsData(), NULL, sync_data, &dummy);
 }
 
 TemplateURL* TemplateURLServiceSyncTest::CopyTemplateURL(
     const TemplateURLData* turl,
     const std::string& url,
     const std::string& guid) {
   TemplateURLData data = *turl;
   data.SetURL(url);
   data.date_created = Time::FromTimeT(100);
   data.last_modified = Time::FromTimeT(100);
@@ skipping 31 matching lines @@
     std::string guid = GetGUID(*iter);
     const TemplateURL* service_turl = model()->GetTemplateURLForGUID(guid);
     scoped_ptr<TemplateURL> deserialized(Deserialize(*iter));
     AssertEquals(*service_turl, *deserialized);
   }
 }
 
 TEST_F(TemplateURLServiceSyncTest, GetAllSyncDataWithExtension) {
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com"));
-  model()->RegisterOmniboxKeyword("blahblahblah", "unittest", "key3",
-                                  "http://blahblahblah");
+  std::string fake_id("blahblahblah");
+  std::string fake_url = std::string(kOmniboxScheme) + "://" + fake_id;
+  model()->RegisterOmniboxKeyword(fake_id, "unittest", "key3", fake_url);
   syncer::SyncDataList all_sync_data =
       model()->GetAllSyncData(syncer::SEARCH_ENGINES);
 
-  EXPECT_EQ(3U, all_sync_data.size());
+  EXPECT_EQ(2U, all_sync_data.size());
 
   for (syncer::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(Deserialize(*iter));
     AssertEquals(*service_turl, *deserialized);
   }
 }
 
@@ skipping 251 matching lines @@
   EXPECT_EQ(6, merge_result.num_items_after_association());
 }
 
 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.
   syncer::SyncDataList initial_data = CreateInitialSyncData();
   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
-    TemplateURL* converted = Deserialize(*iter);
-    model()->Add(converted);
+    scoped_ptr<TemplateURL> converted(Deserialize(*iter));
+    model()->Add(converted.release());
   }
 
   syncer::SyncMergeResult merge_result = model()->MergeDataAndStartSyncing(
       syncer::SEARCH_ENGINES, initial_data,
       PassProcessor(), CreateAndPassSyncErrorFactory());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncer::SEARCH_ENGINES).size());
   for (syncer::SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
@@ skipping 372 matching lines @@
   model()->MergeDataAndStartSyncing(syncer::SEARCH_ENGINES,
                                     CreateInitialSyncData(), PassProcessor(),
                                     CreateAndPassSyncErrorFactory());
 
   // Add some extension keywords locally.
   model()->RegisterOmniboxKeyword("extension1", "unittest", "keyword1",
                                   "http://extension1");
   TemplateURL* extension1 =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1"));
   ASSERT_TRUE(extension1);
-  EXPECT_EQ(1U, processor()->change_list_size());
+  EXPECT_EQ(0U, processor()->change_list_size());
 
   model()->RegisterOmniboxKeyword("extension2", "unittest", "keyword2",
                                   "http://extension2");
   TemplateURL* extension2 =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2"));
   ASSERT_TRUE(extension2);
-  EXPECT_EQ(1U, processor()->change_list_size());
+  EXPECT_EQ(0U, processor()->change_list_size());
 
   // Create some sync changes that will conflict with the extension keywords.
   syncer::SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
     CreateTestTemplateURL(ASCIIToUTF16("keyword1"), "http://aaa.com",
                           std::string(), 100, true)));
   changes.push_back(CreateTestSyncChange(syncer::SyncChange::ACTION_ADD,
     CreateTestTemplateURL(ASCIIToUTF16("keyword2"), "http://bbb.com")));
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
-  // The existing extension keywords should be uniquified.
   EXPECT_FALSE(model()->GetTemplateURLForHost("aaa.com") == NULL);
-  EXPECT_EQ(model()->GetTemplateURLForHost("aaa.com"),
+  EXPECT_EQ(extension1,
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1")));
   TemplateURL* url_for_keyword2 =
       model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2"));
   EXPECT_NE(extension2, url_for_keyword2);
   EXPECT_EQ("http://bbb.com", url_for_keyword2->url());
 
-  // Replaced extension keywords should be uniquified.
   EXPECT_EQ(extension1,
-            model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1_")));
-  EXPECT_EQ(extension2,
-            model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2_")));
+            model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword1")));
+  EXPECT_EQ(model()->GetTemplateURLForHost("bbb.com"),
+            model()->GetTemplateURLForKeyword(ASCIIToUTF16("keyword2")));
 }
 
 TEST_F(TemplateURLServiceSyncTest, AutogeneratedKeywordMigrated) {
   // Create a couple of sync entries with autogenerated keywords.
   syncer::SyncDataList initial_data;
   scoped_ptr<TemplateURL> turl(
       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1"));
   initial_data.push_back(
       CreateCustomSyncData(*turl, true, turl->url(), turl->sync_guid()));
   turl.reset(CreateTestTemplateURL(ASCIIToUTF16("key2"),
@@ skipping 1124 matching lines @@
   const char kNewGUID[] = "newdefault";
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"),
                                      "http://thewhat.com/{searchTerms}",
                                      kNewGUID));
   model()->SetUserSelectedDefaultSearchProvider(
       model()->GetTemplateURLForGUID(kNewGUID));
 
   EXPECT_EQ(kNewGUID, profile_a()->GetTestingPrefService()->GetString(
       prefs::kSyncedDefaultSearchProviderGUID));
 }