Remove old default search preferences.

components/search_engines/default_search_policy_handler.cc

 // Copyright 2014 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 "components/search_engines/default_search_policy_handler.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"

[Peter Kasting, 2017/01/06 00:09:56]

Can this #include or any others now be removed?

[Alexander Yashkin, 2017/01/09 06:11:38]

Removed string_util.h.

 #include "components/policy/core/browser/policy_error_map.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/policy_constants.h"
 #include "components/prefs/pref_value_map.h"
 #include "components/search_engines/default_search_manager.h"
 #include "components/search_engines/search_engines_pref_names.h"
 #include "components/search_engines/search_terms_data.h"
 #include "components/search_engines/template_url.h"
 #include "grit/components_strings.h"
 
@@ skipping 27 matching lines @@
     bool is_string = policy_value->GetAsString(&str);
     DCHECK(is_string);
   }
   dict->SetString(key, str);
 }
 
 }  // namespace
 
 // List of policy types to preference names, for policies affecting the default
 // search provider.
 const PolicyToPreferenceMapEntry kDefaultSearchPolicyMap[] = {

[Peter Kasting, 2017/01/06 00:09:56]

Will we have more entries in this map in the future?  If we don't know the
answer is yes, should we simplify this and the code that uses it within the
class by hardcoding the handling of this more?

[Alexander Yashkin, 2017/01/09 06:11:38]

Removed kDefaultSearchPolicyMap and handlers_ from this class, because they were
used only to check value types for policies. 
Added  kDefaultSearchProviderEnabled to kDefaultSearchPolicyDataMap.

   { key::kDefaultSearchProviderEnabled,
     prefs::kDefaultSearchProviderEnabled,
     base::Value::Type::BOOLEAN },
-  { key::kDefaultSearchProviderName,
-    prefs::kDefaultSearchProviderName,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderKeyword,
-    prefs::kDefaultSearchProviderKeyword,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderSearchURL,
-    prefs::kDefaultSearchProviderSearchURL,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderSuggestURL,
-    prefs::kDefaultSearchProviderSuggestURL,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderInstantURL,
-    prefs::kDefaultSearchProviderInstantURL,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderIconURL,
-    prefs::kDefaultSearchProviderIconURL,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderEncodings,
-    prefs::kDefaultSearchProviderEncodings,
-    base::Value::Type::LIST },
-  { key::kDefaultSearchProviderAlternateURLs,
-    prefs::kDefaultSearchProviderAlternateURLs,
-    base::Value::Type::LIST },
-  { key::kDefaultSearchProviderSearchTermsReplacementKey,
-    prefs::kDefaultSearchProviderSearchTermsReplacementKey,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderImageURL,
-    prefs::kDefaultSearchProviderImageURL,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderNewTabURL,
-    prefs::kDefaultSearchProviderNewTabURL,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderSearchURLPostParams,
-    prefs::kDefaultSearchProviderSearchURLPostParams,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderSuggestURLPostParams,
-    prefs::kDefaultSearchProviderSuggestURLPostParams,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderInstantURLPostParams,
-    prefs::kDefaultSearchProviderInstantURLPostParams,
-    base::Value::Type::STRING },
-  { key::kDefaultSearchProviderImageURLPostParams,
-    prefs::kDefaultSearchProviderImageURLPostParams,
-    base::Value::Type::STRING },
 };
 
 // List of policy types to preference names, for policies affecting the default
 // search provider.
 const PolicyToPreferenceMapEntry kDefaultSearchPolicyDataMap[] = {
     {key::kDefaultSearchProviderName, DefaultSearchManager::kShortName,
      base::Value::Type::STRING},
     {key::kDefaultSearchProviderKeyword, DefaultSearchManager::kKeyword,
      base::Value::Type::STRING},
     {key::kDefaultSearchProviderSearchURL, DefaultSearchManager::kURL,
@@ skipping 19 matching lines @@
      DefaultSearchManager::kSearchURLPostParams, base::Value::Type::STRING},
     {key::kDefaultSearchProviderSuggestURLPostParams,
      DefaultSearchManager::kSuggestionsURLPostParams,
      base::Value::Type::STRING},
     {key::kDefaultSearchProviderInstantURLPostParams,
      DefaultSearchManager::kInstantURLPostParams, base::Value::Type::STRING},
     {key::kDefaultSearchProviderImageURLPostParams,
      DefaultSearchManager::kImageURLPostParams, base::Value::Type::STRING},
 };
 
-// DefaultSearchEncodingsPolicyHandler implementation --------------------------
-
-DefaultSearchEncodingsPolicyHandler::DefaultSearchEncodingsPolicyHandler()
-    : TypeCheckingPolicyHandler(key::kDefaultSearchProviderEncodings,
-                                base::Value::Type::LIST) {}
-
-DefaultSearchEncodingsPolicyHandler::~DefaultSearchEncodingsPolicyHandler() {
-}
-
-void DefaultSearchEncodingsPolicyHandler::ApplyPolicySettings(
-    const PolicyMap& policies, PrefValueMap* prefs) {
-  // The DefaultSearchProviderEncodings policy has type list, but the related
-  // preference has type string. Convert one into the other here, using
-  // ';' as a separator.
-  const base::Value* value = policies.GetValue(policy_name());
-  const base::ListValue* list;
-  if (!value || !value->GetAsList(&list))
-    return;
-
-  base::ListValue::const_iterator iter(list->begin());
-  base::ListValue::const_iterator end(list->end());
-  std::vector<std::string> string_parts;
-  for (; iter != end; ++iter) {
-    std::string s;
-    if ((*iter)->GetAsString(&s)) {
-      string_parts.push_back(s);
-    }
-  }
-  std::string encodings = base::JoinString(string_parts, ";");
-  prefs->SetString(prefs::kDefaultSearchProviderEncodings, encodings);
-}
-
-
 // DefaultSearchPolicyHandler implementation -----------------------------------
 
 DefaultSearchPolicyHandler::DefaultSearchPolicyHandler() {
   for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) {
     const char* policy_name = kDefaultSearchPolicyMap[i].policy_name;
-    if (policy_name == key::kDefaultSearchProviderEncodings) {
-      handlers_.push_back(
-          base::MakeUnique<DefaultSearchEncodingsPolicyHandler>());
-    } else {
-      handlers_.push_back(base::MakeUnique<SimplePolicyHandler>(
-          policy_name, kDefaultSearchPolicyMap[i].preference_path,
-          kDefaultSearchPolicyMap[i].value_type));
-    }
+    handlers_.push_back(base::MakeUnique<SimplePolicyHandler>(
+        policy_name, kDefaultSearchPolicyMap[i].preference_path,
+        kDefaultSearchPolicyMap[i].value_type));
   }
 }
 
 DefaultSearchPolicyHandler::~DefaultSearchPolicyHandler() {}
 
 bool DefaultSearchPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
                                                      PolicyErrorMap* errors) {
   if (!CheckIndividualPolicies(policies, errors))
     return false;
 
   if (DefaultSearchProviderIsDisabled(policies)) {
     // Add an error for all specified default search policies except
     // DefaultSearchProviderEnabled.
 
     for (const auto& handler : handlers_) {
       const char* policy_name = handler->policy_name();
       if (policy_name != key::kDefaultSearchProviderEnabled &&

[Peter Kasting, 2017/01/06 00:09:56]

Can this ever succeed anymore?

[Alexander Yashkin, 2017/01/09 06:11:38]

I think after removing entries from kDefaultSearchPolicyMap I broke check of
policies value types.
I tried to fix it, added unittest.

           HasDefaultSearchPolicy(policies, policy_name)) {
         errors->AddError(policy_name, IDS_POLICY_DEFAULT_SEARCH_DISABLED);
       }
     }
     return true;
   }
 
   const base::Value* url;
   std::string dummy;
   if (DefaultSearchURLIsValid(policies, &url, &dummy) ||
@@ skipping 137 matching lines @@
 void DefaultSearchPolicyHandler::EnsureListPrefExists(
     PrefValueMap* prefs,
     const std::string& path) {
   base::Value* value;
   base::ListValue* list_value;
   if (!prefs->GetValue(path, &value) || !value->GetAsList(&list_value))
     prefs->SetValue(path, base::MakeUnique<base::ListValue>());
 }
 
 }  // namespace policy