Ensure that TemplateURLs removed by prepopulate search engine merging is also removed from Sync.

chrome/browser/search_engines/util.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 "chrome/browser/search_engines/util.h"
 
 #include <set>
+#include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_prepopulate_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 13 matching lines @@
     // http://code.google.com/p/chromium/issues/detail?id=2573
     return string16();
   }
   return default_provider->short_name();
 }
 
 // Removes (and deletes) TemplateURLs from |urls| that have duplicate
 // prepopulate ids. Duplicate prepopulate ids are not allowed, but due to a
 // bug it was possible get dups. This step is only called when the version
 // number changes. Only pass in a non-NULL value for |service| if the removed
-// items should be removed from the DB.
+// items should be removed from the DB. If |removed_keyword_guids| is not NULL,
+// the Sync GUID of each item removed from the DB will be added to it.
 static void RemoveDuplicatePrepopulateIDs(
     std::vector<TemplateURL*>* template_urls,
-    WebDataService* service) {
+    WebDataService* service,
+    std::set<std::string>* removed_keyword_guids) {
   DCHECK(template_urls);
   DCHECK(service == NULL || BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::set<int> ids;
   for (std::vector<TemplateURL*>::iterator i = template_urls->begin();
        i != template_urls->end(); ) {
     int prepopulate_id = (*i)->prepopulate_id();
     if (prepopulate_id) {
       if (ids.find(prepopulate_id) != ids.end()) {
-        if (service)
+        if (service) {
           service->RemoveKeyword((*i)->id());
+          if (removed_keyword_guids)
+            removed_keyword_guids->insert((*i)->sync_guid());
+        }
         delete *i;
         i = template_urls->erase(i);
       } else {
         ids.insert(prepopulate_id);
         ++i;
       }
     } else {
       ++i;
     }
   }
 }
 
 // Returns the TemplateURL with id specified from the list of TemplateURLs.
 // If not found, returns NULL.
 TemplateURL* GetTemplateURLByID(
     const std::vector<TemplateURL*>& template_urls,
     int64 id) {
   for (std::vector<TemplateURL*>::const_iterator i = template_urls.begin();
        i != template_urls.end(); ++i) {
     if ((*i)->id() == id) {
       return *i;
     }
   }
   return NULL;
 }
 
 // Loads engines from prepopulate data and merges them in with the existing
 // engines.  This is invoked when the version of the prepopulate data changes.
+// If |removed_keyword_guids| is not NULL, the Sync GUID of each item removed
+// from the DB will be added to it.
 void MergeEnginesFromPrepopulateData(
     Profile* profile,
     WebDataService* service,
     std::vector<TemplateURL*>* template_urls,
-    TemplateURL** default_search_provider) {
+    TemplateURL** default_search_provider,
+    std::set<std::string>* removed_keyword_guids) {
   DCHECK(service == NULL || BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(template_urls);
   DCHECK(default_search_provider);
 
   // Create a map to hold all provided |template_urls| that originally came from
   // prepopulate data (i.e. have a non-zero prepopulate_id()).
   typedef std::map<int, TemplateURL*> IDMap;
   IDMap id_to_turl;
   for (std::vector<TemplateURL*>::iterator i(template_urls->begin());
        i != template_urls->end(); ++i) {
@@ skipping 57 matching lines @@
   // found in the prepopulate data.  Any remaining URLs that haven't been
   // user-edited or made default can be removed from the data store.
   for (IDMap::iterator i(id_to_turl.begin()); i != id_to_turl.end(); ++i) {
     const TemplateURL* template_url = i->second;
     if ((template_url->safe_for_autoreplace()) &&
         (template_url != *default_search_provider)) {
       std::vector<TemplateURL*>::iterator j =
           std::find(template_urls->begin(), template_urls->end(), template_url);
       DCHECK(j != template_urls->end());
       template_urls->erase(j);
-       if (service)
+       if (service) {
          service->RemoveKeyword(template_url->id());
+         if (removed_keyword_guids)
+           removed_keyword_guids->insert(template_url->sync_guid());
+       }
       delete template_url;
     }
   }
 }
 
 void GetSearchProvidersUsingKeywordResult(
     const WDTypedResult& result,
     WebDataService* service,
     Profile* profile,
     std::vector<TemplateURL*>* template_urls,
     TemplateURL** default_search_provider,
-    int* new_resource_keyword_version) {
+    int* new_resource_keyword_version,
+    std::set<std::string>* removed_keyword_guids) {
   DCHECK(service == NULL || BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(template_urls);
   DCHECK(template_urls->empty());
   DCHECK(default_search_provider);
   DCHECK(*default_search_provider == NULL);
   DCHECK_EQ(result.GetType(), KEYWORDS_RESULT);
   DCHECK(new_resource_keyword_version);
 
   *new_resource_keyword_version = 0;
   WDKeywordsResult keyword_result = reinterpret_cast<
       const WDResult<WDKeywordsResult>*>(&result)->GetValue();
 
   for (KeywordTable::Keywords::const_iterator i(
        keyword_result.keywords.begin()); i != keyword_result.keywords.end();
        ++i)
     template_urls->push_back(new TemplateURL(profile, *i));
 
   const int resource_keyword_version =
       TemplateURLPrepopulateData::GetDataVersion(
           profile ? profile->GetPrefs() : NULL);
   if (keyword_result.builtin_keyword_version != resource_keyword_version) {
     // There should never be duplicate TemplateURLs. We had a bug such that
     // duplicate TemplateURLs existed for one locale. As such we invoke
     // RemoveDuplicatePrepopulateIDs to nuke the duplicates.
-    RemoveDuplicatePrepopulateIDs(template_urls, service);
+    RemoveDuplicatePrepopulateIDs(template_urls, service,
+                                  removed_keyword_guids);
   }
 
   int64 default_search_provider_id = keyword_result.default_search_provider_id;
   if (default_search_provider_id) {
     *default_search_provider =
         GetTemplateURLByID(*template_urls, default_search_provider_id);
   }
 
   if (keyword_result.builtin_keyword_version != resource_keyword_version) {
     MergeEnginesFromPrepopulateData(profile, service, template_urls,
-                                    default_search_provider);
+                                    default_search_provider,
+                                    removed_keyword_guids);
     *new_resource_keyword_version = resource_keyword_version;
   }
 }
 
 bool DidDefaultSearchProviderChange(
     const WDTypedResult& result,
     Profile* profile,
     scoped_ptr<TemplateURL>* backup_default_search_provider) {
   DCHECK(backup_default_search_provider);
   DCHECK(!backup_default_search_provider->get());
   DCHECK_EQ(result.GetType(), KEYWORDS_RESULT);
 
   WDKeywordsResult keyword_result = reinterpret_cast<
       const WDResult<WDKeywordsResult>*>(&result)->GetValue();
 
   if (!keyword_result.did_default_search_provider_change)
     return false;
 
   if (keyword_result.backup_valid) {
     backup_default_search_provider->reset(new TemplateURL(profile,
         keyword_result.default_search_provider_backup));
   }
   return true;
 }
-