Add search_terms_replacement_key field to TemplateURL.

chrome/browser/search_engines/template_url_service.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/template_url_service.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
@@ skipping 66 matching lines @@
   return (url1 != NULL) && (url2 != NULL) &&
       (url1->short_name() == url2->short_name()) &&
       url1->HasSameKeywordAs(*url2) &&
       (url1->url() == url2->url()) &&
       (url1->suggestions_url() == url2->suggestions_url()) &&
       (url1->instant_url() == url2->instant_url()) &&
       (url1->favicon_url() == url2->favicon_url()) &&
       (url1->safe_for_autoreplace() == url2->safe_for_autoreplace()) &&
       (url1->show_in_default_list() == url2->show_in_default_list()) &&
       (url1->input_encodings() == url2->input_encodings()) &&
-      (url1->alternate_urls() == url2->alternate_urls());
+      (url1->alternate_urls() == url2->alternate_urls()) &&
+      (url1->search_terms_replacement_key() ==
+          url2->search_terms_replacement_key());
 }
 
 const char kFirstPotentialEngineHistogramName[] =
     "Search.FirstPotentialEngineCalled";
 
 // Values for an enumerated histogram used to track whenever
 // FirstPotentialDefaultEngine is called, and from where.
 enum FirstPotentialEngineCaller {
   FIRST_POTENTIAL_CALLSITE_FIND_NEW_DSP,
   FIRST_POTENTIAL_CALLSITE_FIND_NEW_DSP_PROCESSING_SYNC_CHANGES,
@@ skipping 1192 matching lines @@
   se_specifics->set_date_created(turl.date_created().ToInternalValue());
   se_specifics->set_input_encodings(JoinString(turl.input_encodings(), ';'));
   se_specifics->set_show_in_default_list(turl.show_in_default_list());
   se_specifics->set_suggestions_url(turl.suggestions_url());
   se_specifics->set_prepopulate_id(turl.prepopulate_id());
   se_specifics->set_instant_url(turl.instant_url());
   se_specifics->set_last_modified(turl.last_modified().ToInternalValue());
   se_specifics->set_sync_guid(turl.sync_guid());
   for (size_t i = 0; i < turl.alternate_urls().size(); ++i)
     se_specifics->add_alternate_urls(turl.alternate_urls()[i]);
+  se_specifics->set_search_terms_replacement_key(
+      turl.search_terms_replacement_key());
 
   return syncer::SyncData::CreateLocalData(se_specifics->sync_guid(),
-                                   se_specifics->keyword(),
-                                   specifics);
+                                           se_specifics->keyword(),
+                                           specifics);
 }
 
 // static
 TemplateURL* TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
     Profile* profile,
     TemplateURL* existing_turl,
     const syncer::SyncData& sync_data,
     syncer::SyncChangeList* change_list) {
   DCHECK(change_list);
 
@@ skipping 39 matching lines @@
   // GetSearchProvidersUsingKeywordResult(), since otherwise we'd never correct
   // local problems for clients which have disabled search engine sync.
   bool deduped = DeDupeEncodings(&data.input_encodings);
   data.date_created = base::Time::FromInternalValue(specifics.date_created());
   data.last_modified = base::Time::FromInternalValue(specifics.last_modified());
   data.prepopulate_id = specifics.prepopulate_id();
   data.sync_guid = specifics.sync_guid();
   data.alternate_urls.clear();
   for (int i = 0; i < specifics.alternate_urls_size(); ++i)
     data.alternate_urls.push_back(specifics.alternate_urls(i));
+  data.search_terms_replacement_key = specifics.search_terms_replacement_key();
 
   TemplateURL* turl = new TemplateURL(profile, data);
   DCHECK(!turl->IsExtensionKeyword());
   if (reset_keyword || deduped) {
     if (reset_keyword)
       turl->ResetKeywordIfNecessary(true);
     syncer::SyncData sync_data = CreateSyncDataFromTemplateURL(*turl);
     change_list->push_back(
         syncer::SyncChange(FROM_HERE,
                            syncer::SyncChange::ACTION_UPDATE,
@@ skipping 243 matching lines @@
   std::string search_url;
   std::string suggest_url;
   std::string instant_url;
   std::string icon_url;
   std::string encodings;
   std::string short_name;
   std::string keyword;
   std::string id_string;
   std::string prepopulate_id;
   ListValue alternate_urls;
+  std::string search_terms_replacement_key;
   if (t_url) {
     DCHECK(!t_url->IsExtensionKeyword());
     enabled = true;
     search_url = t_url->url();
     suggest_url = t_url->suggestions_url();
     instant_url = t_url->instant_url();
     GURL icon_gurl = t_url->favicon_url();
     if (!icon_gurl.is_empty())
       icon_url = icon_gurl.spec();
     encodings = JoinString(t_url->input_encodings(), ';');
     short_name = UTF16ToUTF8(t_url->short_name());
     keyword = UTF16ToUTF8(t_url->keyword());
     id_string = base::Int64ToString(t_url->id());
     prepopulate_id = base::Int64ToString(t_url->prepopulate_id());
     for (size_t i = 0; i < t_url->alternate_urls().size(); ++i)
       alternate_urls.AppendString(t_url->alternate_urls()[i]);
+    search_terms_replacement_key = t_url->search_terms_replacement_key();
   }
   prefs->SetBoolean(prefs::kDefaultSearchProviderEnabled, enabled);
   prefs->SetString(prefs::kDefaultSearchProviderSearchURL, search_url);
   prefs->SetString(prefs::kDefaultSearchProviderSuggestURL, suggest_url);
   prefs->SetString(prefs::kDefaultSearchProviderInstantURL, instant_url);
   prefs->SetString(prefs::kDefaultSearchProviderIconURL, icon_url);
   prefs->SetString(prefs::kDefaultSearchProviderEncodings, encodings);
   prefs->SetString(prefs::kDefaultSearchProviderName, short_name);
   prefs->SetString(prefs::kDefaultSearchProviderKeyword, keyword);
   prefs->SetString(prefs::kDefaultSearchProviderID, id_string);
   prefs->SetString(prefs::kDefaultSearchProviderPrepopulateID, prepopulate_id);
   prefs->Set(prefs::kDefaultSearchProviderAlternateURLs, alternate_urls);
+  prefs->SetString(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
+      search_terms_replacement_key);
 }
 
 bool TemplateURLService::LoadDefaultSearchProviderFromPrefs(
     scoped_ptr<TemplateURL>* default_provider,
     bool* is_managed) {
   PrefService* prefs = GetPrefs();
   if (!prefs || !prefs->HasPrefPath(prefs::kDefaultSearchProviderSearchURL))
     return false;
 
   const PrefService::Preference* pref =
@@ skipping 30 matching lines @@
       prefs->GetString(prefs::kDefaultSearchProviderInstantURL);
   std::string icon_url =
       prefs->GetString(prefs::kDefaultSearchProviderIconURL);
   std::string encodings =
       prefs->GetString(prefs::kDefaultSearchProviderEncodings);
   std::string id_string = prefs->GetString(prefs::kDefaultSearchProviderID);
   std::string prepopulate_id =
       prefs->GetString(prefs::kDefaultSearchProviderPrepopulateID);
   const ListValue* alternate_urls =
       prefs->GetList(prefs::kDefaultSearchProviderAlternateURLs);
+  std::string search_terms_replacement_key = prefs->GetString(
+      prefs::kDefaultSearchProviderSearchTermsReplacementKey);
 
   TemplateURLData data;
   data.short_name = name;
   data.SetKeyword(keyword);
   data.SetURL(search_url);
   data.suggestions_url = suggest_url;
   data.instant_url = instant_url;
   data.favicon_url = GURL(icon_url);
   data.show_in_default_list = true;
   data.alternate_urls.clear();
   for (size_t i = 0; i < alternate_urls->GetSize(); ++i) {
     std::string alternate_url;
     if (alternate_urls->GetString(i, &alternate_url))
       data.alternate_urls.push_back(alternate_url);
   }
+  data.search_terms_replacement_key = search_terms_replacement_key;
   base::SplitString(encodings, ';', &data.input_encodings);
   if (!id_string.empty() && !*is_managed) {
     int64 value;
     base::StringToInt64(id_string, &value);
     data.id = value;
   }
   if (!prepopulate_id.empty() && !*is_managed) {
     int value;
     base::StringToInt(prepopulate_id, &value);
     data.prepopulate_id = value;
@@ skipping 809 matching lines @@
     // TODO(mpcomplete): If we allow editing extension keywords, then those
     // should be persisted to disk and synced.
     if (template_url->sync_guid().empty() &&
         !template_url->IsExtensionKeyword()) {
       template_url->data_.sync_guid = base::GenerateGUID();
       if (service_.get())
         service_->UpdateKeyword(template_url->data());
     }
   }
 }