Implemented 'Reset Search engines' feature.

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 <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 131 matching lines @@
     prepopulated_url->safe_for_autoreplace = false;
     prepopulated_url->SetKeyword(original_turl->keyword());
     prepopulated_url->short_name = original_turl->short_name();
   }
   prepopulated_url->id = original_turl->id();
   prepopulated_url->sync_guid = original_turl->sync_guid();
   prepopulated_url->date_created = original_turl->date_created();
   prepopulated_url->last_modified = original_turl->last_modified();
 }
 
 // Loads engines from prepopulate data and merges them in with the existing

[Peter Kasting, 2013/05/22 21:22:57]

Nit: While here, please fix this comment: "Merges the provided prepopulated
engines with the provided existing engines. ..."

[vasilii, 2013/05/23 17:03:42]

Done.

 // 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.  Note that this function will take
 // ownership of |prepopulated_urls| and will clear the vector.
 void MergeEnginesFromPrepopulateData(
     Profile* profile,
     WebDataService* service,
     ScopedVector<TemplateURL>* prepopulated_urls,
     size_t default_search_index,
     TemplateURLService::TemplateURLVector* template_urls,
@@ skipping 92 matching lines @@
     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(KEYWORDS_RESULT, result.GetType());
   DCHECK(new_resource_keyword_version);
 
-  *new_resource_keyword_version = 0;
   WDKeywordsResult keyword_result = reinterpret_cast<
       const WDResult<WDKeywordsResult>*>(&result)->GetValue();
 
   for (KeywordTable::Keywords::iterator i(keyword_result.keywords.begin());
        i != keyword_result.keywords.end(); ++i) {
     // Fix any duplicate encodings in the local database.  Note that we don't
     // adjust the last_modified time of this keyword; this way, we won't later
     // overwrite any changes on the sync server that happened to this keyword
     // since the last time we synced.  Instead, we also run a de-duping pass on
     // the server-provided data in
     // TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData() and
     // update the server with the merged, de-duped results at that time.  We
     // still fix here, though, to correct problems in clients that have disabled
     // search engine sync, since in that case that code will never be reached.
     if (DeDupeEncodings(&i->input_encodings) && service)
       service->UpdateKeyword(*i);
     template_urls->push_back(new TemplateURL(profile, *i));
   }
 
   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);
   }
 
+  *new_resource_keyword_version = keyword_result.builtin_keyword_version;
+  GetSearchProvidersUsingLoadedEngines(service, profile, template_urls,
+                                       default_search_provider,
+                                       new_resource_keyword_version,
+                                       removed_keyword_guids);
+}
+
+void GetSearchProvidersUsingLoadedEngines(
+    WebDataService* service,
+    Profile* profile,
+    TemplateURLService::TemplateURLVector* template_urls,
+    TemplateURL** default_search_provider,
+    int* new_resource_keyword_version,
+    std::set<std::string>* removed_keyword_guids) {
+  DCHECK(service == NULL || BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(template_urls);
+  DCHECK(default_search_provider);
+  DCHECK(new_resource_keyword_version);
+
   ScopedVector<TemplateURL> prepopulated_urls;
   size_t default_search_index;
   TemplateURLPrepopulateData::GetPrepopulatedEngines(profile,
       &prepopulated_urls.get(), &default_search_index);
   RemoveDuplicatePrepopulateIDs(service, prepopulated_urls,
                                 *default_search_provider, template_urls,
                                 removed_keyword_guids);
 
   const int resource_keyword_version =
       TemplateURLPrepopulateData::GetDataVersion(
           profile ? profile->GetPrefs() : NULL);
-  if (keyword_result.builtin_keyword_version != resource_keyword_version) {
+  if (*new_resource_keyword_version != resource_keyword_version) {
     MergeEnginesFromPrepopulateData(profile, service, &prepopulated_urls,
         default_search_index, template_urls, default_search_provider,
         removed_keyword_guids);
     *new_resource_keyword_version = resource_keyword_version;
+  } else {
+    *new_resource_keyword_version = 0;
   }
 }
 
 bool DeDupeEncodings(std::vector<std::string>* encodings) {
   std::vector<std::string> deduped_encodings;
   std::set<std::string> encoding_set;
   for (std::vector<std::string>::const_iterator i(encodings->begin());
        i != encodings->end(); ++i) {
     if (encoding_set.insert(*i).second)
       deduped_encodings.push_back(*i);
   }
   encodings->swap(deduped_encodings);
   return encodings->size() != deduped_encodings.size();
 }