Home | History | Annotate | Download | only in search_engines 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/memory/scoped_ptr.h"
      6 #include "chrome/browser/search_engines/default_search_manager.h"
      7 #include "chrome/browser/search_engines/default_search_policy_handler.h"
      8 #include "chrome/common/pref_names.h"
      9 #include "components/policy/core/browser/configuration_policy_pref_store.h"
     10 #include "components/policy/core/browser/configuration_policy_pref_store_test.h"
     11 #include "policy/policy_constants.h"
     12 
     13 namespace {
     14 // TODO(caitkp): Should we find a way to route this through DefaultSearchManager
     15 // to avoid hardcoding this here?
     16 const char kDefaultSearchProviderData[] =
     17     "default_search_provider_data.template_url_data";
     18 }  // namespace
     19 
     20 namespace policy {
     21 
     22 class DefaultSearchPolicyHandlerTest
     23     : public ConfigurationPolicyPrefStoreTest {
     24  public:
     25   DefaultSearchPolicyHandlerTest() {
     26     default_alternate_urls_.AppendString(
     27         "http://www.google.com/#q={searchTerms}");
     28     default_alternate_urls_.AppendString(
     29         "http://www.google.com/search#q={searchTerms}");
     30   }
     31 
     32   virtual void SetUp() OVERRIDE {
     33     handler_list_.AddHandler(make_scoped_ptr<ConfigurationPolicyHandler>(
     34         new DefaultSearchPolicyHandler));
     35   }
     36 
     37  protected:
     38   static const char kSearchURL[];
     39   static const char kSuggestURL[];
     40   static const char kIconURL[];
     41   static const char kName[];
     42   static const char kKeyword[];
     43   static const char kReplacementKey[];
     44   static const char kImageURL[];
     45   static const char kImageParams[];
     46   static const char kNewTabURL[];
     47   static const char kFileSearchURL[];
     48   static const char kHostName[];
     49 
     50   // Build a default search policy by setting search-related keys in |policy| to
     51   // reasonable values. You can update any of the keys after calling this
     52   // method.
     53   void BuildDefaultSearchPolicy(PolicyMap* policy);
     54 
     55   base::ListValue default_alternate_urls_;
     56 };
     57 
     58 const char DefaultSearchPolicyHandlerTest::kSearchURL[] =
     59     "http://test.com/search?t={searchTerms}";
     60 const char DefaultSearchPolicyHandlerTest::kSuggestURL[] =
     61     "http://test.com/sugg?={searchTerms}";
     62 const char DefaultSearchPolicyHandlerTest::kIconURL[] =
     63     "http://test.com/icon.jpg";
     64 const char DefaultSearchPolicyHandlerTest::kName[] =
     65     "MyName";
     66 const char DefaultSearchPolicyHandlerTest::kKeyword[] =
     67     "MyKeyword";
     68 const char DefaultSearchPolicyHandlerTest::kReplacementKey[] =
     69     "espv";
     70 const char DefaultSearchPolicyHandlerTest::kImageURL[] =
     71     "http://test.com/searchbyimage/upload";
     72 const char DefaultSearchPolicyHandlerTest::kImageParams[] =
     73     "image_content=content,image_url=http://test.com/test.png";
     74 const char DefaultSearchPolicyHandlerTest::kNewTabURL[] =
     75     "http://test.com/newtab";
     76 const char DefaultSearchPolicyHandlerTest::kFileSearchURL[] =
     77     "file:///c:/path/to/search?t={searchTerms}";
     78 const char DefaultSearchPolicyHandlerTest::kHostName[] = "test.com";
     79 
     80 void DefaultSearchPolicyHandlerTest::
     81     BuildDefaultSearchPolicy(PolicyMap* policy) {
     82   base::ListValue* encodings = new base::ListValue();
     83   encodings->AppendString("UTF-16");
     84   encodings->AppendString("UTF-8");
     85   policy->Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
     86               POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
     87   policy->Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
     88               POLICY_SCOPE_USER, base::Value::CreateStringValue(kSearchURL),
     89               NULL);
     90   policy->Set(key::kDefaultSearchProviderName, POLICY_LEVEL_MANDATORY,
     91               POLICY_SCOPE_USER, base::Value::CreateStringValue(kName), NULL);
     92   policy->Set(key::kDefaultSearchProviderKeyword, POLICY_LEVEL_MANDATORY,
     93               POLICY_SCOPE_USER, base::Value::CreateStringValue(kKeyword),
     94               NULL);
     95   policy->Set(key::kDefaultSearchProviderSuggestURL, POLICY_LEVEL_MANDATORY,
     96               POLICY_SCOPE_USER, base::Value::CreateStringValue(kSuggestURL),
     97               NULL);
     98   policy->Set(key::kDefaultSearchProviderIconURL, POLICY_LEVEL_MANDATORY,
     99               POLICY_SCOPE_USER, base::Value::CreateStringValue(kIconURL),
    100               NULL);
    101   policy->Set(key::kDefaultSearchProviderEncodings, POLICY_LEVEL_MANDATORY,
    102               POLICY_SCOPE_USER, encodings, NULL);
    103   policy->Set(key::kDefaultSearchProviderAlternateURLs, POLICY_LEVEL_MANDATORY,
    104               POLICY_SCOPE_USER, default_alternate_urls_.DeepCopy(), NULL);
    105   policy->Set(key::kDefaultSearchProviderSearchTermsReplacementKey,
    106               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
    107               base::Value::CreateStringValue(kReplacementKey), NULL);
    108   policy->Set(key::kDefaultSearchProviderImageURL,
    109               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
    110               base::Value::CreateStringValue(kImageURL), NULL);
    111   policy->Set(key::kDefaultSearchProviderImageURLPostParams,
    112               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
    113               base::Value::CreateStringValue(kImageParams), NULL);
    114   policy->Set(key::kDefaultSearchProviderNewTabURL,
    115               POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
    116               base::Value::CreateStringValue(kNewTabURL), NULL);
    117 }
    118 
    119 // Checks that if the policy for default search is valid, i.e. there's a
    120 // search URL, that all the elements have been given proper defaults.
    121 TEST_F(DefaultSearchPolicyHandlerTest, MinimallyDefined) {
    122   PolicyMap policy;
    123   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
    124              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true), NULL);
    125   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
    126              POLICY_SCOPE_USER, base::Value::CreateStringValue(kSearchURL),
    127              NULL);
    128   UpdateProviderPolicy(policy);
    129 
    130   const base::Value* value = NULL;
    131   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
    132   EXPECT_TRUE(base::StringValue(kSearchURL).Equals(value));
    133 
    134   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderName, &value));
    135   EXPECT_TRUE(base::StringValue(kHostName).Equals(value));
    136 
    137   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
    138   EXPECT_TRUE(base::StringValue(kHostName).Equals(value));
    139 
    140   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL,
    141                                &value));
    142   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    143 
    144   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
    145   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    146 
    147   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
    148   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    149 
    150   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderInstantURL,
    151                                &value));
    152   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    153 
    154   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
    155                              &value));
    156   EXPECT_TRUE(base::ListValue().Equals(value));
    157 
    158   EXPECT_TRUE(
    159       store_->GetValue(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
    160       &value));
    161   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    162 
    163   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderImageURL, &value));
    164   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    165 
    166   EXPECT_TRUE(store_->GetValue(
    167       prefs::kDefaultSearchProviderSearchURLPostParams, &value));
    168   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    169 
    170   EXPECT_TRUE(store_->GetValue(
    171       prefs::kDefaultSearchProviderSuggestURLPostParams, &value));
    172   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    173 
    174   EXPECT_TRUE(store_->GetValue(
    175       prefs::kDefaultSearchProviderInstantURLPostParams, &value));
    176   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    177 
    178   EXPECT_TRUE(store_->GetValue(
    179       prefs::kDefaultSearchProviderImageURLPostParams, &value));
    180   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    181 
    182   EXPECT_TRUE(store_->GetValue(
    183       prefs::kDefaultSearchProviderNewTabURL, &value));
    184   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    185 }
    186 
    187 // Checks that for a fully defined search policy, all elements have been
    188 // read properly.
    189 TEST_F(DefaultSearchPolicyHandlerTest, FullyDefined) {
    190   PolicyMap policy;
    191   BuildDefaultSearchPolicy(&policy);
    192   UpdateProviderPolicy(policy);
    193 
    194   const base::Value* value = NULL;
    195   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
    196   EXPECT_TRUE(base::StringValue(kSearchURL).Equals(value));
    197 
    198   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderName, &value));
    199   EXPECT_TRUE(base::StringValue(kName).Equals(value));
    200 
    201   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
    202   EXPECT_TRUE(base::StringValue(kKeyword).Equals(value));
    203 
    204   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL,
    205                                &value));
    206   EXPECT_TRUE(base::StringValue(kSuggestURL).Equals(value));
    207 
    208   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
    209   EXPECT_TRUE(base::StringValue(kIconURL).Equals(value));
    210 
    211   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
    212   EXPECT_TRUE(base::StringValue("UTF-16;UTF-8").Equals(value));
    213 
    214   EXPECT_TRUE(store_->GetValue(
    215       prefs::kDefaultSearchProviderAlternateURLs, &value));
    216   EXPECT_TRUE(default_alternate_urls_.Equals(value));
    217 
    218   EXPECT_TRUE(
    219       store_->GetValue(prefs::kDefaultSearchProviderSearchTermsReplacementKey,
    220       &value));
    221   EXPECT_TRUE(base::StringValue(kReplacementKey).Equals(value));
    222 
    223   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderImageURL, &value));
    224   EXPECT_TRUE(base::StringValue(std::string(kImageURL)).Equals(value));
    225 
    226   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderImageURLPostParams,
    227                                &value));
    228   EXPECT_TRUE(base::StringValue(std::string(kImageParams)).Equals(value));
    229 
    230   EXPECT_TRUE(store_->GetValue(
    231       prefs::kDefaultSearchProviderSearchURLPostParams, &value));
    232   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    233 
    234   EXPECT_TRUE(store_->GetValue(
    235       prefs::kDefaultSearchProviderSuggestURLPostParams, &value));
    236   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    237 
    238   EXPECT_TRUE(store_->GetValue(
    239       prefs::kDefaultSearchProviderInstantURLPostParams, &value));
    240   EXPECT_TRUE(base::StringValue(std::string()).Equals(value));
    241 }
    242 
    243 // Checks that if the default search policy is missing, that no elements of the
    244 // default search policy will be present.
    245 TEST_F(DefaultSearchPolicyHandlerTest, MissingUrl) {
    246   PolicyMap policy;
    247   BuildDefaultSearchPolicy(&policy);
    248   policy.Erase(key::kDefaultSearchProviderSearchURL);
    249   UpdateProviderPolicy(policy);
    250 
    251   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
    252   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
    253   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
    254   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
    255   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
    256   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
    257   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
    258                                 NULL));
    259   EXPECT_FALSE(store_->GetValue(
    260       prefs::kDefaultSearchProviderSearchTermsReplacementKey, NULL));
    261   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderImageURL, NULL));
    262   EXPECT_FALSE(store_->GetValue(
    263       prefs::kDefaultSearchProviderImageURLPostParams, NULL));
    264   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderInstantURL, NULL));
    265   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderNewTabURL, NULL));
    266 }
    267 
    268 // Checks that if the default search policy is invalid, that no elements of the
    269 // default search policy will be present.
    270 TEST_F(DefaultSearchPolicyHandlerTest, Invalid) {
    271   PolicyMap policy;
    272   BuildDefaultSearchPolicy(&policy);
    273   const char bad_search_url[] = "http://test.com/noSearchTerms";
    274   policy.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_MANDATORY,
    275              POLICY_SCOPE_USER,
    276              base::Value::CreateStringValue(bad_search_url), NULL);
    277   UpdateProviderPolicy(policy);
    278 
    279   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
    280   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderName, NULL));
    281   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
    282   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
    283   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
    284   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
    285   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderAlternateURLs,
    286                                 NULL));
    287   EXPECT_FALSE(store_->GetValue(
    288       prefs::kDefaultSearchProviderSearchTermsReplacementKey, NULL));
    289   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderImageURL, NULL));
    290   EXPECT_FALSE(store_->GetValue(
    291       prefs::kDefaultSearchProviderImageURLPostParams, NULL));
    292   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderInstantURL, NULL));
    293   EXPECT_FALSE(store_->GetValue(prefs::kDefaultSearchProviderNewTabURL, NULL));
    294 }
    295 
    296 // Checks that if the default search policy is invalid, that no elements of the
    297 // default search policy will be present.
    298 TEST_F(DefaultSearchPolicyHandlerTest, Disabled) {
    299   PolicyMap policy;
    300   policy.Set(key::kDefaultSearchProviderEnabled, POLICY_LEVEL_MANDATORY,
    301              POLICY_SCOPE_USER, base::Value::CreateBooleanValue(false), NULL);
    302   UpdateProviderPolicy(policy);
    303 
    304   const base::Value* value = NULL;
    305   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderEnabled, &value));
    306   base::FundamentalValue expected_enabled(false);
    307   EXPECT_TRUE(base::Value::Equals(&expected_enabled, value));
    308   EXPECT_TRUE(store_->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
    309   base::StringValue expected_search_url((std::string()));
    310   EXPECT_TRUE(base::Value::Equals(&expected_search_url, value));
    311 }
    312 
    313 // Checks that for a fully defined search policy, all elements have been
    314 // read properly into the dictionary pref.
    315 TEST_F(DefaultSearchPolicyHandlerTest, DictionaryPref) {
    316   PolicyMap policy;
    317   BuildDefaultSearchPolicy(&policy);
    318   UpdateProviderPolicy(policy);
    319 
    320   const base::Value* temp = NULL;
    321   const base::DictionaryValue* dictionary;
    322   std::string value;
    323   const base::ListValue* list_value;
    324   EXPECT_TRUE(store_->GetValue(kDefaultSearchProviderData, &temp));
    325   temp->GetAsDictionary(&dictionary);
    326 
    327   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kURL, &value));
    328   EXPECT_EQ(kSearchURL, value);
    329   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kShortName, &value));
    330   EXPECT_EQ(kName, value);
    331   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kKeyword, &value));
    332   EXPECT_EQ(kKeyword, value);
    333 
    334   EXPECT_TRUE(
    335       dictionary->GetString(DefaultSearchManager::kSuggestionsURL, &value));
    336   EXPECT_EQ(kSuggestURL, value);
    337   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kFaviconURL, &value));
    338   EXPECT_EQ(kIconURL, value);
    339 
    340   base::ListValue encodings;
    341   encodings.AppendString("UTF-16");
    342   encodings.AppendString("UTF-8");
    343 
    344   EXPECT_TRUE(
    345       dictionary->GetList(DefaultSearchManager::kInputEncodings, &list_value));
    346   EXPECT_TRUE(encodings.Equals(list_value));
    347 
    348   EXPECT_TRUE(
    349       dictionary->GetList(DefaultSearchManager::kAlternateURLs, &list_value));
    350   EXPECT_TRUE(default_alternate_urls_.Equals(list_value));
    351 
    352   EXPECT_TRUE(dictionary->GetString(
    353       DefaultSearchManager::kSearchTermsReplacementKey, &value));
    354   EXPECT_EQ(kReplacementKey, value);
    355 
    356   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kImageURL, &value));
    357   EXPECT_EQ(kImageURL, value);
    358 
    359   EXPECT_TRUE(
    360       dictionary->GetString(DefaultSearchManager::kImageURLPostParams, &value));
    361   EXPECT_EQ(kImageParams, value);
    362 
    363   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kSearchURLPostParams,
    364                                     &value));
    365   EXPECT_EQ(std::string(), value);
    366 
    367   EXPECT_TRUE(dictionary->GetString(
    368       DefaultSearchManager::kSuggestionsURLPostParams, &value));
    369   EXPECT_EQ(std::string(), value);
    370 
    371   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kInstantURLPostParams,
    372                                     &value));
    373   EXPECT_EQ(std::string(), value);
    374 }
    375 
    376 // Checks that disabling default search is properly reflected the dictionary
    377 // pref.
    378 TEST_F(DefaultSearchPolicyHandlerTest, DictionaryPrefDSEDisabled) {
    379   PolicyMap policy;
    380   policy.Set(key::kDefaultSearchProviderEnabled,
    381              POLICY_LEVEL_MANDATORY,
    382              POLICY_SCOPE_USER,
    383              base::Value::CreateBooleanValue(false),
    384              NULL);
    385   UpdateProviderPolicy(policy);
    386   const base::Value* temp = NULL;
    387   const base::DictionaryValue* dictionary;
    388   EXPECT_TRUE(store_->GetValue(kDefaultSearchProviderData, &temp));
    389   temp->GetAsDictionary(&dictionary);
    390   bool disabled = false;
    391   EXPECT_TRUE(dictionary->GetBoolean(DefaultSearchManager::kDisabledByPolicy,
    392                                      &disabled));
    393   EXPECT_TRUE(disabled);
    394 }
    395 
    396 // Checks that if the policy for default search is valid, i.e. there's a
    397 // search URL, that all the elements have been given proper defaults.
    398 TEST_F(DefaultSearchPolicyHandlerTest, DictionaryPrefMinimallyDefined) {
    399   PolicyMap policy;
    400   policy.Set(key::kDefaultSearchProviderEnabled,
    401              POLICY_LEVEL_MANDATORY,
    402              POLICY_SCOPE_USER,
    403              base::Value::CreateBooleanValue(true),
    404              NULL);
    405   policy.Set(key::kDefaultSearchProviderSearchURL,
    406              POLICY_LEVEL_MANDATORY,
    407              POLICY_SCOPE_USER,
    408              base::Value::CreateStringValue(kSearchURL),
    409              NULL);
    410   UpdateProviderPolicy(policy);
    411 
    412   const base::Value* temp = NULL;
    413   const base::DictionaryValue* dictionary;
    414   std::string value;
    415   const base::ListValue* list_value;
    416   EXPECT_TRUE(store_->GetValue(kDefaultSearchProviderData, &temp));
    417   temp->GetAsDictionary(&dictionary);
    418 
    419   // Name and keyword should be derived from host.
    420   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kURL, &value));
    421   EXPECT_EQ(kSearchURL, value);
    422   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kShortName, &value));
    423   EXPECT_EQ(kHostName, value);
    424   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kKeyword, &value));
    425   EXPECT_EQ(kHostName, value);
    426 
    427   // Everything else should be set to the default value.
    428   EXPECT_TRUE(
    429       dictionary->GetString(DefaultSearchManager::kSuggestionsURL, &value));
    430   EXPECT_EQ(std::string(), value);
    431   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kFaviconURL, &value));
    432   EXPECT_EQ(std::string(), value);
    433   EXPECT_TRUE(
    434       dictionary->GetList(DefaultSearchManager::kInputEncodings, &list_value));
    435   EXPECT_TRUE(base::ListValue().Equals(list_value));
    436   EXPECT_TRUE(
    437       dictionary->GetList(DefaultSearchManager::kAlternateURLs, &list_value));
    438   EXPECT_TRUE(base::ListValue().Equals(list_value));
    439   EXPECT_TRUE(dictionary->GetString(
    440       DefaultSearchManager::kSearchTermsReplacementKey, &value));
    441   EXPECT_EQ(std::string(), value);
    442   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kImageURL, &value));
    443   EXPECT_EQ(std::string(), value);
    444   EXPECT_TRUE(
    445       dictionary->GetString(DefaultSearchManager::kImageURLPostParams, &value));
    446   EXPECT_EQ(std::string(), value);
    447   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kSearchURLPostParams,
    448                                     &value));
    449   EXPECT_EQ(std::string(), value);
    450   EXPECT_TRUE(dictionary->GetString(
    451       DefaultSearchManager::kSuggestionsURLPostParams, &value));
    452   EXPECT_EQ(std::string(), value);
    453   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kInstantURLPostParams,
    454                                     &value));
    455   EXPECT_EQ(std::string(), value);
    456 }
    457 
    458 // Checks that setting a file URL as the default search is reflected properly in
    459 // the dictionary pref.
    460 TEST_F(DefaultSearchPolicyHandlerTest, DictionaryPrefFileURL) {
    461   PolicyMap policy;
    462   policy.Set(key::kDefaultSearchProviderEnabled,
    463              POLICY_LEVEL_MANDATORY,
    464              POLICY_SCOPE_USER,
    465              base::Value::CreateBooleanValue(true),
    466              NULL);
    467   policy.Set(key::kDefaultSearchProviderSearchURL,
    468              POLICY_LEVEL_MANDATORY,
    469              POLICY_SCOPE_USER,
    470              base::Value::CreateStringValue(kFileSearchURL),
    471              NULL);
    472   UpdateProviderPolicy(policy);
    473 
    474   const base::Value* temp = NULL;
    475   const base::DictionaryValue* dictionary;
    476   std::string value;
    477 
    478   EXPECT_TRUE(store_->GetValue(kDefaultSearchProviderData, &temp));
    479   temp->GetAsDictionary(&dictionary);
    480 
    481   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kURL, &value));
    482   EXPECT_EQ(kFileSearchURL, value);
    483   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kShortName, &value));
    484   EXPECT_EQ("_", value);
    485   EXPECT_TRUE(dictionary->GetString(DefaultSearchManager::kKeyword, &value));
    486   EXPECT_EQ("_", value);
    487 }
    488 }  // namespace policy
    489