Add search_terms_replacement_key field to TemplateURL.

This CL is the first step in removing the hardcoded "espv" parameter used by instant-extended to detect when to perform search term replacement in the omnibox.
The search_terms_replacement_key has beed added to prepopulated_engines, TemplateURL, policy, web_database, prefs, and sync.

BUG=161602

Review URL: https://chromiumcodereview.appspot.com/11552020

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@175014 0039d316-1c4b-4281-b951-d872f2087c98

16 files changed, 198 insertions, 35 deletions

diff --git a/chrome/browser/policy/configuration_policy_handler.cc b/chrome/browser/policy/configuration_policy_handler.cc
index 68536d3..5587cae 100644
--- a/chrome/browser/policy/configuration_policy_handler.cc
+++ b/chrome/browser/policy/configuration_policy_handler.cc
@@ -92,6 +92,9 @@ const DefaultSearchSimplePolicyHandlerEntry kDefaultSearchPolicyMap[] = {
   { key::kDefaultSearchProviderAlternateURLs,
     prefs::kDefaultSearchProviderAlternateURLs,
     Value::TYPE_LIST },
+  { key::kDefaultSearchProviderSearchTermsReplacementKey,
+    prefs::kDefaultSearchProviderSearchTermsReplacementKey,
+    Value::TYPE_STRING },
 };
 
 // List of entries determining which proxy policies can be specified, depending
@@ -825,6 +828,8 @@ void DefaultSearchPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
     prefs->SetString(prefs::kDefaultSearchProviderInstantURL, std::string());
     prefs->SetValue(prefs::kDefaultSearchProviderAlternateURLs,
                     new ListValue());
+    prefs->SetString(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
+                     std::string());
   } else {
     // The search URL is required.  The other entries are optional.  Just make
     // sure that they are all specified via policy, so that the regular prefs
@@ -842,6 +847,8 @@ void DefaultSearchPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
       EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderKeyword);
       EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderInstantURL);
       EnsureListPrefExists(prefs, prefs::kDefaultSearchProviderAlternateURLs);
+      EnsureStringPrefExists(prefs,
+          prefs::kDefaultSearchProviderSearchTermsReplacementKey);
 
       // For the name and keyword, default to the host if not specified.  If
       // there is no host (file: URLs?  Not sure), use "_" to guarantee that the
diff --git a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
index ccd9a05..0600465 100644
--- a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
@@ -567,6 +567,7 @@ class ConfigurationPolicyPrefStoreDefaultSearchTest
   static const char* const kIconURL;
   static const char* const kName;
   static const char* const kKeyword;
+  static const char* const kReplacementKey;
 
   // Build a default search policy by setting search-related keys in |policy| to
   // reasonable values. You can update any of the keys after calling this
@@ -586,6 +587,8 @@ const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kName =
     "MyName";
 const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kKeyword =
     "MyKeyword";
+const char* const
+    ConfigurationPolicyPrefStoreDefaultSearchTest::kReplacementKey = "espv";
 
 void ConfigurationPolicyPrefStoreDefaultSearchTest::
     BuildDefaultSearchPolicy(PolicyMap* policy) {
@@ -608,6 +611,9 @@ void ConfigurationPolicyPrefStoreDefaultSearchTest::
               POLICY_SCOPE_USER, encodings);
   policy->Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, default_alternate_urls_.DeepCopy());
+  policy->Set(key::kDefaultSearchProviderSearchTermsReplacementKey,
+              POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              base::Value::CreateStringValue(kReplacementKey));
 }
 
 // Checks that if the policy for default search is valid, i.e. there's a
@@ -647,6 +653,11 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
                              &value));
   EXPECT_TRUE(base::ListValue().Equals(value));
+
+  EXPECT_TRUE(
+      store_->GetValue(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
+      &value));
+  EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 }
 
 // Checks that for a fully defined search policy, all elements have been
@@ -679,6 +690,11 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
   EXPECT_TRUE(store_->GetValue(
       prefs::kDefaultSearchProviderAlternateURLs, &value));
   EXPECT_TRUE(default_alternate_urls_.Equals(value));
+
+  EXPECT_TRUE(
+      store_->GetValue(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
+      &value));
+  EXPECT_TRUE(base::StringValue(kReplacementKey).Equals(value));
 }
 
 // Checks that if the default search policy is missing, that no elements of the
@@ -697,6 +713,8 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
                                 NULL));
+  EXPECT_FALSE(store_->GetValue(
+      prefs::kDefaultSearchProviderSearchTermsReplacementKey, NULL));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
@@ -718,6 +736,8 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
                                 NULL));
+  EXPECT_FALSE(store_->GetValue(
+      prefs::kDefaultSearchProviderSearchTermsReplacementKey, NULL));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
diff --git a/chrome/browser/policy/policy_browsertest.cc b/chrome/browser/policy/policy_browsertest.cc
index 86cbac3..1bec8bd 100644
--- a/chrome/browser/policy/policy_browsertest.cc
+++ b/chrome/browser/policy/policy_browsertest.cc
@@ -659,6 +659,7 @@ IN_PROC_BROWSER_TEST_F(PolicyTest, DefaultSearchProvider) {
   const std::string kAlternateURL0(
       "http://search.example/search#q={searchTerms}");
   const std::string kAlternateURL1("http://search.example/#q={searchTerms}");
+  const std::string kSearchTermsReplacementKey("zekey");
 
   TemplateURLService* service = TemplateURLServiceFactory::GetForProfile(
       browser()->profile());
@@ -670,7 +671,9 @@ IN_PROC_BROWSER_TEST_F(PolicyTest, DefaultSearchProvider) {
   EXPECT_FALSE(
     default_search->alternate_urls().size() == 2 &&
     default_search->alternate_urls()[0] == kAlternateURL0 &&
-    default_search->alternate_urls()[1] == kAlternateURL1);
+    default_search->alternate_urls()[1] == kAlternateURL1 &&
+    default_search->search_terms_replacement_key() ==
+        kSearchTermsReplacementKey);
 
   // Override the default search provider using policies.
   PolicyMap policies;
@@ -685,6 +688,9 @@ IN_PROC_BROWSER_TEST_F(PolicyTest, DefaultSearchProvider) {
   alternate_urls->AppendString(kAlternateURL1);
   policies.Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER, alternate_urls);
+  policies.Set(key::kDefaultSearchProviderSearchTermsReplacementKey,
+               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+               base::Value::CreateStringValue(kSearchTermsReplacementKey));
   provider_.UpdateChromePolicy(policies);
   default_search = service->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
@@ -693,6 +699,8 @@ IN_PROC_BROWSER_TEST_F(PolicyTest, DefaultSearchProvider) {
   EXPECT_EQ(2U, default_search->alternate_urls().size());
   EXPECT_EQ(kAlternateURL0, default_search->alternate_urls()[0]);
   EXPECT_EQ(kAlternateURL1, default_search->alternate_urls()[1]);
+  EXPECT_EQ(kSearchTermsReplacementKey,
+            default_search->search_terms_replacement_key());
 
   // Verify that searching from the omnibox uses kSearchURL.
   chrome::FocusLocationBar(browser());
diff --git a/chrome/browser/search_engines/prepopulated_engines.json b/chrome/browser/search_engines/prepopulated_engines.json
index 232f571..15a9862 100644
--- a/chrome/browser/search_engines/prepopulated_engines.json
+++ b/chrome/browser/search_engines/prepopulated_engines.json
@@ -26,7 +26,7 @@
 
     // Increment this if you change the data in ways that mean users with
     // existing data should get a new version.
-    "kCurrentDataVersion": 49
+    "kCurrentDataVersion": 50
   },
 
   // The following engines are included in country lists and are added to the
@@ -855,6 +855,7 @@
         "{google:baseURL}search#q={searchTerms}",
         "{google:baseURL}webhp#q={searchTerms}"
       ],
+      "search_terms_replacement_key": "{google:instantExtendedEnabledKey}",
       "type": "SEARCH_ENGINE_GOOGLE",
       "id": 1
     },
diff --git a/chrome/browser/search_engines/prepopulated_engines_schema.json b/chrome/browser/search_engines/prepopulated_engines_schema.json
index 0838e22..ae0f1ad 100644
--- a/chrome/browser/search_engines/prepopulated_engines_schema.json
+++ b/chrome/browser/search_engines/prepopulated_engines_schema.json
@@ -23,9 +23,9 @@
       "optional": true
     },
     // If omitted, this engine does not support suggestions.
-    { "field": "suggest_url", "type": "string", "optional": true  },
+    { "field": "suggest_url", "type": "string", "optional": true },
     // If omitted, this engine does not support instant.
-    { "field": "instant_url", "type": "string", "optional": true  },
+    { "field": "instant_url", "type": "string", "optional": true },
     // A list of URL patterns that can be used, in addition to |search_url|,
     // to extract search terms from a URL.
     {
@@ -34,6 +34,14 @@
       "contents": { "type": "string" },
       "optional": true
     },
+    // A parameter that, if present in the query or ref parameters of a
+    // search_url or instant_url, causes Chrome to replace the URL with the
+    // search term.
+    {
+      "field": "search_terms_replacement_key",
+      "type": "string",
+      "optional": true
+    },
     {
       "field": "type",
       "type": "enum",
diff --git a/chrome/browser/search_engines/template_url.cc b/chrome/browser/search_engines/template_url.cc
index 43c8c38..9944621 100644
--- a/chrome/browser/search_engines/template_url.cc
+++ b/chrome/browser/search_engines/template_url.cc
@@ -58,6 +58,8 @@ const char kGoogleCursorPositionParameter[] = "google:cursorPosition";
 const char kGoogleInstantEnabledParameter[] = "google:instantEnabledParameter";
 const char kGoogleInstantExtendedEnabledParameter[] =
     "google:instantExtendedEnabledParameter";
+const char kGoogleInstantExtendedEnabledKey[] =
+    "google:instantExtendedEnabledKey";
 const char kGoogleOriginalQueryForSuggestionParameter[] =
     "google:originalQueryForSuggestion";
 const char kGoogleRLZParameter[] = "google:RLZ";
@@ -571,6 +573,8 @@ bool TemplateURLRef::ParseParameter(size_t start,
   } else if (parameter == kGoogleInstantExtendedEnabledParameter) {
     replacements->push_back(Replacement(GOOGLE_INSTANT_EXTENDED_ENABLED,
                                         start));
+  } else if (parameter == kGoogleInstantExtendedEnabledKey) {
+    url->insert(start, google_util::kInstantExtendedAPIParam);
   } else if (parameter == kGoogleOriginalQueryForSuggestionParameter) {
     replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION,
                                         start));
diff --git a/chrome/browser/search_engines/template_url.h b/chrome/browser/search_engines/template_url.h
index 6fba137..b5a3576 100644
--- a/chrome/browser/search_engines/template_url.h
+++ b/chrome/browser/search_engines/template_url.h
@@ -352,6 +352,10 @@ struct TemplateURLData {
   // search terms from a URL.
   std::vector<std::string> alternate_urls;
 
+  // A parameter that, if present in the query or ref parameters of a search_url
+  // or instant_url, causes Chrome to replace the URL with the search term.
+  std::string search_terms_replacement_key;
+
  private:
   // Private so we can enforce using the setters and thus enforce that these
   // fields are never empty.
@@ -427,6 +431,10 @@ class TemplateURL {
 
   const std::string& sync_guid() const { return data_.sync_guid; }
 
+  const std::string& search_terms_replacement_key() const {
+    return data_.search_terms_replacement_key;
+  }
+
   const TemplateURLRef& url_ref() const { return url_ref_; }
   const TemplateURLRef& suggestions_url_ref() const {
     return suggestions_url_ref_;
diff --git a/chrome/browser/search_engines/template_url_prepopulate_data.cc b/chrome/browser/search_engines/template_url_prepopulate_data.cc
index fa0fc4f4..b2a857b 100644
--- a/chrome/browser/search_engines/template_url_prepopulate_data.cc
+++ b/chrome/browser/search_engines/template_url_prepopulate_data.cc
@@ -1110,16 +1110,18 @@ int GetDataVersion(PrefService* prefs) {
       kCurrentDataVersion;
 }
 
-TemplateURL* MakePrepopulatedTemplateURL(Profile* profile,
-                                         const string16& name,
-                                         const string16& keyword,
-                                         const base::StringPiece& search_url,
-                                         const base::StringPiece& suggest_url,
-                                         const base::StringPiece& instant_url,
-                                         const ListValue& alternate_urls,
-                                         const base::StringPiece& favicon_url,
-                                         const base::StringPiece& encoding,
-                                         int id) {
+TemplateURL* MakePrepopulatedTemplateURL(
+    Profile* profile,
+    const string16& name,
+    const string16& keyword,
+    const base::StringPiece& search_url,
+    const base::StringPiece& suggest_url,
+    const base::StringPiece& instant_url,
+    const base::StringPiece& favicon_url,
+    const base::StringPiece& encoding,
+    const ListValue& alternate_urls,
+    const base::StringPiece& search_terms_replacement_key,
+    int id) {
 
   TemplateURLData data;
 
@@ -1128,12 +1130,6 @@ TemplateURL* MakePrepopulatedTemplateURL(Profile* profile,
   data.SetURL(search_url.as_string());
   data.suggestions_url = suggest_url.as_string();
   data.instant_url = instant_url.as_string();
-  for (size_t i = 0; i < alternate_urls.GetSize(); ++i) {
-    std::string alternate_url;
-    alternate_urls.GetString(i, &alternate_url);
-    DCHECK(!alternate_url.empty());
-    data.alternate_urls.push_back(alternate_url);
-  }
   data.favicon_url = GURL(favicon_url.as_string());
   data.show_in_default_list = true;
   data.safe_for_autoreplace = true;
@@ -1141,6 +1137,13 @@ TemplateURL* MakePrepopulatedTemplateURL(Profile* profile,
   data.date_created = base::Time();
   data.last_modified = base::Time();
   data.prepopulate_id = id;
+  for (size_t i = 0; i < alternate_urls.GetSize(); ++i) {
+    std::string alternate_url;
+    alternate_urls.GetString(i, &alternate_url);
+    DCHECK(!alternate_url.empty());
+    data.alternate_urls.push_back(alternate_url);
+  }
+  data.search_terms_replacement_key = search_terms_replacement_key.as_string();
   return new TemplateURL(profile, data);
 }
 
@@ -1177,12 +1180,15 @@ void GetPrepopulatedTemplateFromPrefs(Profile* profile,
       std::string instant_url;
       ListValue empty_list;
       const ListValue* alternate_urls = &empty_list;
+      std::string search_terms_replacement_key;
       engine->GetString("suggest_url", &suggest_url);
       engine->GetString("instant_url", &instant_url);
       engine->GetList("alternate_urls", &alternate_urls);
+      engine->GetString("search_terms_replacement_key",
+          &search_terms_replacement_key);
       t_urls->push_back(MakePrepopulatedTemplateURL(profile, name, keyword,
-          search_url, suggest_url, instant_url, *alternate_urls, favicon_url,
-          encoding, id));
+          search_url, suggest_url, instant_url, favicon_url, encoding,
+          *alternate_urls, search_terms_replacement_key, id));
     }
   }
 }
@@ -1200,8 +1206,8 @@ TemplateURL* MakePrepopulatedTemplateURLFromPrepopulateEngine(
 
   return MakePrepopulatedTemplateURL(profile, WideToUTF16(engine.name),
       WideToUTF16(engine.keyword), engine.search_url, engine.suggest_url,
-      engine.instant_url, alternate_urls,
-      engine.favicon_url, engine.encoding, engine.id);
+      engine.instant_url, engine.favicon_url, engine.encoding, alternate_urls,
+      engine.search_terms_replacement_key, engine.id);
 }
 
 void GetPrepopulatedEngines(Profile* profile,
diff --git a/chrome/browser/search_engines/template_url_prepopulate_data_unittest.cc b/chrome/browser/search_engines/template_url_prepopulate_data_unittest.cc
index a8b765c..b53013f 100644
--- a/chrome/browser/search_engines/template_url_prepopulate_data_unittest.cc
+++ b/chrome/browser/search_engines/template_url_prepopulate_data_unittest.cc
@@ -128,6 +128,7 @@ TEST(TemplateURLPrepopulateDataTest, ProvidersFromPrefs) {
   EXPECT_TRUE(t_urls[0]->suggestions_url().empty());
   EXPECT_TRUE(t_urls[0]->instant_url().empty());
   EXPECT_EQ(0u, t_urls[0]->alternate_urls().size());
+  EXPECT_TRUE(t_urls[0]->search_terms_replacement_key().empty());
 
   // Test the optional settings too.
   entry->SetString("suggest_url", "http://foo.com/suggest?q={searchTerms}");
@@ -135,6 +136,7 @@ TEST(TemplateURLPrepopulateDataTest, ProvidersFromPrefs) {
   ListValue* alternate_urls = new ListValue;
   alternate_urls->AppendString("http://foo.com/alternate?q={searchTerms}");
   entry->Set("alternate_urls", alternate_urls);
+  entry->SetString("search_terms_replacement_key", "espv");
   overrides = new ListValue;
   overrides->Append(entry->DeepCopy());
   prefs->SetUserPref(prefs::kSearchProviderOverrides, overrides);
@@ -156,6 +158,7 @@ TEST(TemplateURLPrepopulateDataTest, ProvidersFromPrefs) {
   ASSERT_EQ(1u, t_urls[0]->alternate_urls().size());
   EXPECT_EQ("http://foo.com/alternate?q={searchTerms}",
             t_urls[0]->alternate_urls()[0]);
+  EXPECT_EQ("espv", t_urls[0]->search_terms_replacement_key());
 
   // Test that subsequent providers are loaded even if an intermediate
   // provider has an incomplete configuration.
@@ -212,6 +215,7 @@ TEST(TemplateURLPrepopulateDataTest, ProvidersFromPrepopulated) {
     EXPECT_FALSE(t_urls[default_index]->alternate_urls()[i].empty());
   EXPECT_EQ(SEARCH_ENGINE_GOOGLE,
       TemplateURLPrepopulateData::GetEngineType(t_urls[default_index]->url()));
+  EXPECT_FALSE(t_urls[default_index]->search_terms_replacement_key().empty());
 }
 
 TEST(TemplateURLPrepopulateDataTest, GetEngineTypeBasic) {
diff --git a/chrome/browser/search_engines/template_url_service.cc b/chrome/browser/search_engines/template_url_service.cc
index 9730a09..576bc50 100644
--- a/chrome/browser/search_engines/template_url_service.cc
+++ b/chrome/browser/search_engines/template_url_service.cc
@@ -80,7 +80,9 @@ bool TemplateURLsHaveSamePrefs(const TemplateURL* url1,
       (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[] =
@@ -1246,10 +1248,12 @@ syncer::SyncData TemplateURLService::CreateSyncDataFromTemplateURL(
   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
@@ -1309,6 +1313,7 @@ TemplateURL* TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData(
   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());
@@ -1572,6 +1577,7 @@ void TemplateURLService::SaveDefaultSearchProviderToPrefs(
   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;
@@ -1588,6 +1594,7 @@ void TemplateURLService::SaveDefaultSearchProviderToPrefs(
     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);
@@ -1600,6 +1607,8 @@ void TemplateURLService::SaveDefaultSearchProviderToPrefs(
   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(
@@ -1650,6 +1659,8 @@ bool TemplateURLService::LoadDefaultSearchProviderFromPrefs(
       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;
@@ -1665,6 +1676,7 @@ bool TemplateURLService::LoadDefaultSearchProviderFromPrefs(
     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;
diff --git a/chrome/browser/search_engines/template_url_service_factory.cc b/chrome/browser/search_engines/template_url_service_factory.cc
index 4dd8d29..6a63158 100644
--- a/chrome/browser/search_engines/template_url_service_factory.cc
+++ b/chrome/browser/search_engines/template_url_service_factory.cc
@@ -80,6 +80,10 @@ void TemplateURLServiceFactory::RegisterUserPrefs(PrefServiceSyncable* prefs) {
                             PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kDefaultSearchProviderAlternateURLs,
                           PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterStringPref(
+      prefs::kDefaultSearchProviderSearchTermsReplacementKey,
+      std::string(),
+      PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
 bool TemplateURLServiceFactory::ServiceRedirectedInIncognito() const {
diff --git a/chrome/browser/webdata/keyword_table.cc b/chrome/browser/webdata/keyword_table.cc
index 0e2ea85..6e4b47e 100644
--- a/chrome/browser/webdata/keyword_table.cc
+++ b/chrome/browser/webdata/keyword_table.cc
@@ -64,6 +64,10 @@ const std::string ColumnsForVersion(int version, bool concatenated) {
     // Column added in version 47.
     columns.push_back("alternate_urls");
   }
+  if (version >= 49) {
+    // Column added in version 49.
+    columns.push_back("search_terms_replacement_key");
+  }
 
   return JoinString(columns, std::string(concatenated ? " || " : ", "));
 }
@@ -109,6 +113,7 @@ void BindURLToStatement(const TemplateURLData& data,
   s->BindInt64(starting_column + 14, data.last_modified.ToTimeT());
   s->BindString(starting_column + 15, data.sync_guid);
   s->BindString(starting_column + 16, alternate_urls);
+  s->BindString(starting_column + 17, data.search_terms_replacement_key);
 }
 
 }  // anonymous namespace
@@ -139,7 +144,8 @@ bool KeywordTable::Init() {
                    "instant_url VARCHAR,"
                    "last_modified INTEGER DEFAULT 0,"
                    "sync_guid VARCHAR,"
-                   "alternate_urls VARCHAR)");
+                   "alternate_urls VARCHAR,"
+                   "search_terms_replacement_key VARCHAR)");
 }
 
 bool KeywordTable::IsSyncable() {
@@ -149,7 +155,7 @@ bool KeywordTable::IsSyncable() {
 bool KeywordTable::AddKeyword(const TemplateURLData& data) {
   DCHECK(data.id);
   std::string query("INSERT INTO keywords (" + GetKeywordColumns() +
-                    ") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
+                    ") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
   sql::Statement s(db_->GetUniqueStatement(query.c_str()));
   BindURLToStatement(data, &s, 0, 1);
 
@@ -192,8 +198,8 @@ bool KeywordTable::UpdateKeyword(const TemplateURLData& data) {
       "originating_url=?, date_created=?, usage_count=?, input_encodings=?, "
       "show_in_default_list=?, suggest_url=?, prepopulate_id=?, "
       "created_by_policy=?, instant_url=?, last_modified=?, sync_guid=?, "
-      "alternate_urls=? WHERE id=?"));
-  BindURLToStatement(data, &s, 17, 0);  // "17" binds id() as the last item.
+      "alternate_urls=?, search_terms_replacement_key=? WHERE id=?"));
+  BindURLToStatement(data, &s, 18, 0);  // "18" binds id() as the last item.
 
   return s.Run();
 }
@@ -365,6 +371,19 @@ bool KeywordTable::MigrateToVersion48RemoveKeywordsBackup() {
   return transaction.Commit();
 }
 
+bool KeywordTable::MigrateToVersion49AddSearchTermsReplacementKeyColumn() {
+  sql::Transaction transaction(db_);
+
+  // Fill the |search_terms_replacement_key| column with empty strings;
+  // See comments in MigrateToVersion47AddAlternateURLsColumn().
+  if (!transaction.Begin() ||
+      !db_->Execute("ALTER TABLE keywords ADD COLUMN "
+                    "search_terms_replacement_key VARCHAR DEFAULT ''"))
+    return false;
+
+  return transaction.Commit();
+}
+
 // static
 bool KeywordTable::GetKeywordDataFromStatement(const sql::Statement& s,
                                                TemplateURLData* data) {
@@ -406,6 +425,8 @@ bool KeywordTable::GetKeywordDataFromStatement(const sql::Statement& s,
     }
   }
 
+  data->search_terms_replacement_key = s.ColumnString(18);
+
   return true;
 }
 
diff --git a/chrome/browser/webdata/keyword_table.h b/chrome/browser/webdata/keyword_table.h
index 9242ea2..32a5c94 100644
--- a/chrome/browser/webdata/keyword_table.h
+++ b/chrome/browser/webdata/keyword_table.h
@@ -53,6 +53,10 @@ class Statement;
 //                          version 39.
 //   alternate_urls         See TemplateURLData::alternate_urls. This was added
 //                          in version 47.
+//   search_terms_replacement_key
+//                          See TemplateURLData::search_terms_replacement_key.
+//                          This was added in version 49.
+//
 //
 // This class also manages some fields in the |meta| table:
 //
@@ -113,6 +117,7 @@ class KeywordTable : public WebDatabaseTable {
   bool MigrateToVersion45RemoveLogoIDAndAutogenerateColumns();
   bool MigrateToVersion47AddAlternateURLsColumn();
   bool MigrateToVersion48RemoveKeywordsBackup();
+  bool MigrateToVersion49AddSearchTermsReplacementKeyColumn();
 
  private:
   FRIEND_TEST_ALL_PREFIXES(KeywordTableTest, GetTableContents);
diff --git a/chrome/browser/webdata/keyword_table_unittest.cc b/chrome/browser/webdata/keyword_table_unittest.cc
index d0ff9c0..9bec318 100644
--- a/chrome/browser/webdata/keyword_table_unittest.cc
+++ b/chrome/browser/webdata/keyword_table_unittest.cc
@@ -152,6 +152,7 @@ TEST_F(KeywordTableTest, GetTableContents) {
   keyword.sync_guid = "1234-5678-90AB-CDEF";
   keyword.alternate_urls.push_back("a_url1");
   keyword.alternate_urls.push_back("a_url2");
+  keyword.search_terms_replacement_key = "espv";
   EXPECT_TRUE(keyword_table->AddKeyword(keyword));
 
   keyword.SetKeyword(ASCIIToUTF16("url"));
@@ -162,10 +163,11 @@ TEST_F(KeywordTableTest, GetTableContents) {
   keyword.prepopulate_id = 5;
   keyword.sync_guid = "FEDC-BA09-8765-4321";
   keyword.alternate_urls.clear();
+  keyword.search_terms_replacement_key.clear();
   EXPECT_TRUE(keyword_table->AddKeyword(keyword));
 
   const char kTestContents[] = "1short_namekeywordhttp://favicon.url/"
-      "http://url/1001url20001234-5678-90AB-CDEF[\"a_url1\",\"a_url2\"]"
+      "http://url/1001url20001234-5678-90AB-CDEF[\"a_url1\",\"a_url2\"]espv"
       "2short_nameurlhttp://favicon.url/http://url/1http://originating.url/00"
       "Shift_JIS1url250http://instant2/0FEDC-BA09-8765-4321[]";
 
@@ -194,6 +196,7 @@ TEST_F(KeywordTableTest, GetTableContentsOrdering) {
   keyword.sync_guid = "1234-5678-90AB-CDEF";
   keyword.alternate_urls.push_back("a_url1");
   keyword.alternate_urls.push_back("a_url2");
+  keyword.search_terms_replacement_key = "espv";
   EXPECT_TRUE(keyword_table->AddKeyword(keyword));
 
   keyword.SetKeyword(ASCIIToUTF16("url"));
@@ -204,13 +207,14 @@ TEST_F(KeywordTableTest, GetTableContentsOrdering) {
   keyword.prepopulate_id = 5;
   keyword.sync_guid = "FEDC-BA09-8765-4321";
   keyword.alternate_urls.clear();
+  keyword.search_terms_replacement_key.clear();
   EXPECT_TRUE(keyword_table->AddKeyword(keyword));
 
   const char kTestContents[] = "1short_nameurlhttp://favicon.url/http://url/1"
       "http://originating.url/00Shift_JIS1url250http://instant2/0"
       "FEDC-BA09-8765-4321[]"
       "2short_namekeywordhttp://favicon.url/http://url/1001"
-      "url20001234-5678-90AB-CDEF[\"a_url1\",\"a_url2\"]";
+      "url20001234-5678-90AB-CDEF[\"a_url1\",\"a_url2\"]espv";
 
   std::string contents;
   EXPECT_TRUE(keyword_table->GetTableContents("keywords",
diff --git a/chrome/browser/webdata/web_database.cc b/chrome/browser/webdata/web_database.cc
index 02c1f80..fac52f5 100644
--- a/chrome/browser/webdata/web_database.cc
+++ b/chrome/browser/webdata/web_database.cc
@@ -21,7 +21,7 @@
 // corresponding changes must happen in the unit tests, and new migration test
 // added.  See |WebDatabaseMigrationTest::kCurrentTestedVersionNumber|.
 // static
-const int WebDatabase::kCurrentVersionNumber = 48;
+const int WebDatabase::kCurrentVersionNumber = 49;
 
 namespace {
 
@@ -357,6 +357,14 @@ sql::InitStatus WebDatabase::MigrateOldVersionsAsNeeded() {
       ChangeVersion(&meta_table_, 48, true);
       // FALL THROUGH
 
+    case 48:
+      if (!keyword_table_->
+          MigrateToVersion49AddSearchTermsReplacementKeyColumn())
+        return FailedMigrationTo(49);
+
+      ChangeVersion(&meta_table_, 49, true);
+      // FALL THROUGH
+
     // Add successive versions here.  Each should set the version number and
     // compatible version number as appropriate, then fall through to the next
     // case.
diff --git a/chrome/browser/webdata/web_database_migration_unittest.cc b/chrome/browser/webdata/web_database_migration_unittest.cc
index de4de08..57170c0 100644
--- a/chrome/browser/webdata/web_database_migration_unittest.cc
+++ b/chrome/browser/webdata/web_database_migration_unittest.cc
@@ -213,7 +213,7 @@ class WebDatabaseMigrationTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(WebDatabaseMigrationTest);
 };
 
-const int WebDatabaseMigrationTest::kCurrentTestedVersionNumber = 48;
+const int WebDatabaseMigrationTest::kCurrentTestedVersionNumber = 49;
 
 void WebDatabaseMigrationTest::LoadDatabase(const FilePath::StringType& file) {
   std::string contents;
@@ -2056,3 +2056,46 @@ TEST_F(WebDatabaseMigrationTest, MigrateVersion47ToCurrent) {
     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 }
+
+// Tests that the |search_terms_replacement_key| column is added to the keyword
+// table schema for a version 49 database.
+TEST_F(WebDatabaseMigrationTest, MigrateVersion48ToCurrent) {
+  ASSERT_NO_FATAL_FAILURE(
+      LoadDatabase(FILE_PATH_LITERAL("version_48.sql")));
+
+  // Verify pre-conditions.  These are expectations for version 48 of the
+  // database.
+  {
+    sql::Connection connection;
+    ASSERT_TRUE(connection.Open(GetDatabasePath()));
+    ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
+
+    sql::MetaTable meta_table;
+    ASSERT_TRUE(meta_table.Init(&connection, 48, 48));
+
+    ASSERT_FALSE(connection.DoesColumnExist("keywords",
+                                            "search_terms_replacement_key"));
+  }
+
+  // Load the database via the WebDatabase class and migrate the database to
+  // the current version.
+  {
+    WebDatabase db;
+    ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
+  }
+
+  // Verify post-conditions.  These are expectations for current version of the
+  // database.
+  {
+    sql::Connection connection;
+    ASSERT_TRUE(connection.Open(GetDatabasePath()));
+    ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
+
+    // Check version.
+    EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
+
+    // A new column should have been created.
+    EXPECT_TRUE(connection.DoesColumnExist("keywords",
+                                           "search_terms_replacement_key"));
+  }
+}