Add search_terms_replacement_key field to TemplateURL.

chrome/browser/policy/configuration_policy_pref_store_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 <string>
 
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_store_observer_mock.h"
 #include "chrome/browser/policy/configuration_policy_handler.h"
@@ skipping 549 matching lines @@
     default_alternate_urls_.AppendString(
         "http://www.google.com/search#q={searchTerms}");
   }
 
  protected:
   static const char* const kSearchURL;
   static const char* const kSuggestURL;
   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
   // method.
   void BuildDefaultSearchPolicy(PolicyMap* policy);
 
   base::ListValue default_alternate_urls_;
 };
 
 const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kSearchURL =
     "http://test.com/search?t={searchTerms}";
 const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kSuggestURL =
     "http://test.com/sugg?={searchTerms}";
 const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kIconURL =
     "http://test.com/icon.jpg";
 const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kName =
     "MyName";
 const char* const ConfigurationPolicyPrefStoreDefaultSearchTest::kKeyword =
     "MyKeyword";
+const char* const
+    ConfigurationPolicyPrefStoreDefaultSearchTest::kReplacementKey = "espv";
 
 void ConfigurationPolicyPrefStoreDefaultSearchTest::
     BuildDefaultSearchPolicy(PolicyMap* policy) {
   base::ListValue* encodings = new base::ListValue();
   encodings->AppendString("UTF-16");
   encodings->AppendString("UTF-8");
   policy->Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
   policy->Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, base::Value::CreateStringValue(kSearchURL));
   policy->Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, base::Value::CreateStringValue(kName));
   policy->Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, base::Value::CreateStringValue(kKeyword));
   policy->Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, base::Value::CreateStringValue(kSuggestURL));
   policy->Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, base::Value::CreateStringValue(kIconURL));
   policy->Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
               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
 // search URL, that all the elements have been given proper defaults.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
   PolicyMap policy;
   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateStringValue(kSearchURL));
@@ skipping 19 matching lines @@
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderInstantURL,
                                &value));
   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
 
   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
 // read properly.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
   PolicyMap policy;
   BuildDefaultSearchPolicy(&policy);
   provider_.UpdateChromePolicy(policy);
 
   const base::Value* value = NULL;
@@ skipping 12 matching lines @@
 
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
   EXPECT_TRUE(base::StringValue(kIconURL).Equals(value));
 
   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
   EXPECT_TRUE(base::StringValue("UTF-16;UTF-8").Equals(value));
 
   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
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
   PolicyMap policy;
   BuildDefaultSearchPolicy(&policy);
   policy.Erase(key::kDefaultSearchProviderSearchURL);
   provider_.UpdateChromePolicy(policy);
 
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   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
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
   PolicyMap policy;
   BuildDefaultSearchPolicy(&policy);
   const char* const bad_search_url = "http://test.com/noSearchTerms";
   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER,
              base::Value::CreateStringValue(bad_search_url));
   provider_.UpdateChromePolicy(policy);
 
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   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
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Disabled) {
   PolicyMap policy;
   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false));
   provider_.UpdateChromePolicy(policy);
 
@@ skipping 309 matching lines @@
   policy.Set(key::kDefaultJavaScriptSetting, POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER,
              base::Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
   provider_.UpdateChromePolicy(policy);
   EXPECT_TRUE(store_->GetValue(prefs::kManagedDefaultJavaScriptSetting,
                                &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_ALLOW).Equals(value));
 }
 
 }  // namespace policy