Componentize TemplateURLPrepopulateData, DefaultSearchManager and DefaultSearchPolicyHandler

chrome/browser/search_engines/default_search_policy_handler.cc

Index: chrome/browser/search_engines/default_search_policy_handler.cc
diff --git a/chrome/browser/search_engines/default_search_policy_handler.cc b/chrome/browser/search_engines/default_search_policy_handler.cc
deleted file mode 100644
index 2ef354b9eeb512b1aeb9ba9b1a7ed77f294598c9..0000000000000000000000000000000000000000
--- a/chrome/browser/search_engines/default_search_policy_handler.cc
+++ /dev/null
@@ -1,461 +0,0 @@
-// Copyright 2013 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/default_search_policy_handler.h"
-
-#include "base/prefs/pref_value_map.h"
-#include "base/stl_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-#include "chrome/browser/search_engines/default_search_manager.h"
-#include "components/policy/core/browser/policy_error_map.h"
-#include "components/policy/core/common/policy_map.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"
-#include "policy/policy_constants.h"
-
-namespace policy {
-
-namespace {
-// Extracts a list from a policy value and adds it to a pref dictionary.
-void SetListInPref(const PolicyMap& policies,
-                   const char* policy_name,
-                   const char* key,
-                   base::DictionaryValue* dict) {
-  DCHECK(dict);
-  const base::Value* policy_value = policies.GetValue(policy_name);
-  const base::ListValue* policy_list = NULL;
-  if (policy_value) {
-    bool is_list = policy_value->GetAsList(&policy_list);
-    DCHECK(is_list);
-  }
-  dict->Set(key, policy_list ? policy_list->DeepCopy() : new base::ListValue());
-}
-
-// Extracts a string from a policy value and adds it to a pref dictionary.
-void SetStringInPref(const PolicyMap& policies,
-                     const char* policy_name,
-                     const char* key,
-                     base::DictionaryValue* dict) {
-  DCHECK(dict);
-  const base::Value* policy_value = policies.GetValue(policy_name);
-  std::string str;
-  if (policy_value) {
-    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[] = {
-  { 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,
-     base::Value::TYPE_STRING},
-    {key::kDefaultSearchProviderSuggestURL,
-     DefaultSearchManager::kSuggestionsURL, base::Value::TYPE_STRING},
-    {key::kDefaultSearchProviderInstantURL, DefaultSearchManager::kInstantURL,
-     base::Value::TYPE_STRING},
-    {key::kDefaultSearchProviderIconURL, DefaultSearchManager::kFaviconURL,
-     base::Value::TYPE_STRING},
-    {key::kDefaultSearchProviderEncodings,
-     DefaultSearchManager::kInputEncodings, base::Value::TYPE_LIST},
-    {key::kDefaultSearchProviderAlternateURLs,
-     DefaultSearchManager::kAlternateURLs, base::Value::TYPE_LIST},
-    {key::kDefaultSearchProviderSearchTermsReplacementKey,
-     DefaultSearchManager::kSearchTermsReplacementKey,
-     base::Value::TYPE_STRING},
-    {key::kDefaultSearchProviderImageURL, DefaultSearchManager::kImageURL,
-     base::Value::TYPE_STRING},
-    {key::kDefaultSearchProviderNewTabURL, DefaultSearchManager::kNewTabURL,
-     base::Value::TYPE_STRING},
-    {key::kDefaultSearchProviderSearchURLPostParams,
-     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 = JoinString(string_parts, ';');
-  prefs->SetValue(prefs::kDefaultSearchProviderEncodings,
-                  base::Value::CreateStringValue(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(new DefaultSearchEncodingsPolicyHandler());
-    } else {
-      handlers_.push_back(new SimplePolicyHandler(
-          policy_name,
-          kDefaultSearchPolicyMap[i].preference_path,
-          kDefaultSearchPolicyMap[i].value_type));
-    }
-  }
-}
-
-DefaultSearchPolicyHandler::~DefaultSearchPolicyHandler() {
-  STLDeleteElements(&handlers_);
-}
-
-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 (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler =
-             handlers_.begin();
-         handler != handlers_.end(); ++handler) {
-      const char* policy_name = (*handler)->policy_name();
-      if (policy_name != key::kDefaultSearchProviderEnabled &&
-          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) ||
-      !AnyDefaultSearchPoliciesSpecified(policies))
-    return true;
-  errors->AddError(key::kDefaultSearchProviderSearchURL, url ?
-      IDS_POLICY_INVALID_SEARCH_URL_ERROR : IDS_POLICY_NOT_SPECIFIED_ERROR);
-  return false;
-}
-
-void DefaultSearchPolicyHandler::HandleDictionaryPref(const PolicyMap& policies,
-                                                      PrefValueMap* prefs) {
-  if (DefaultSearchProviderIsDisabled(policies)) {
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
-    dict->SetBoolean(DefaultSearchManager::kDisabledByPolicy, true);
-    DefaultSearchManager::AddPrefValueToMap(dict.release(), prefs);
-    return;
-  }
-
-  // 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
-  // aren't used.
-  const base::Value* dummy;
-  std::string url;
-  if (!DefaultSearchURLIsValid(policies, &dummy, &url))
-    return;
-
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
-  for (size_t i = 0; i < arraysize(kDefaultSearchPolicyDataMap); ++i) {
-    const char* policy_name = kDefaultSearchPolicyDataMap[i].policy_name;
-    switch (kDefaultSearchPolicyDataMap[i].value_type) {
-      case base::Value::TYPE_STRING:
-        SetStringInPref(policies,
-                        policy_name,
-                        kDefaultSearchPolicyDataMap[i].preference_path,
-                        dict.get());
-        break;
-      case base::Value::TYPE_LIST:
-        SetListInPref(policies,
-                      policy_name,
-                      kDefaultSearchPolicyDataMap[i].preference_path,
-                      dict.get());
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
-  }
-
-  // Set the fields which are not specified by the policy to default values.
-  dict->SetString(DefaultSearchManager::kID,
-                  base::Int64ToString(kInvalidTemplateURLID));
-  dict->SetInteger(DefaultSearchManager::kPrepopulateID, 0);
-  dict->SetString(DefaultSearchManager::kSyncGUID, std::string());
-  dict->SetString(DefaultSearchManager::kOriginatingURL, std::string());
-  dict->SetBoolean(DefaultSearchManager::kSafeForAutoReplace, true);
-  dict->SetDouble(DefaultSearchManager::kDateCreated,
-                  base::Time::Now().ToInternalValue());
-  dict->SetDouble(DefaultSearchManager::kLastModified,
-                  base::Time::Now().ToInternalValue());
-  dict->SetInteger(DefaultSearchManager::kUsageCount, 0);
-  dict->SetBoolean(DefaultSearchManager::kCreatedByPolicy, true);
-
-  // For the name and keyword, default to the host if not specified.  If
-  // there is no host (as is the case with file URLs of the form:
-  // "file:///c:/..."), use "_" to guarantee that the keyword is non-empty.
-  std::string name, keyword;
-  dict->GetString(DefaultSearchManager::kKeyword, &keyword);
-  dict->GetString(DefaultSearchManager::kShortName, &name);
-  dict->GetString(DefaultSearchManager::kURL, &url);
-
-  std::string host(GURL(url).host());
-  if (host.empty())
-    host = "_";
-  if (name.empty())
-    dict->SetString(DefaultSearchManager::kShortName, host);
-  if (keyword.empty())
-    dict->SetString(DefaultSearchManager::kKeyword, host);
-
-  DefaultSearchManager::AddPrefValueToMap(dict.release(), prefs);
-}
-
-void DefaultSearchPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
-                                                     PrefValueMap* prefs) {
-  HandleDictionaryPref(policies, prefs);
-
-  if (DefaultSearchProviderIsDisabled(policies)) {
-    prefs->SetBoolean(prefs::kDefaultSearchProviderEnabled, false);
-
-    // If default search is disabled, the other fields are ignored.
-    prefs->SetString(prefs::kDefaultSearchProviderName, std::string());
-    prefs->SetString(prefs::kDefaultSearchProviderSearchURL, std::string());
-    prefs->SetString(prefs::kDefaultSearchProviderSuggestURL, std::string());
-    prefs->SetString(prefs::kDefaultSearchProviderIconURL, std::string());
-    prefs->SetString(prefs::kDefaultSearchProviderEncodings, std::string());
-    prefs->SetString(prefs::kDefaultSearchProviderKeyword, std::string());
-    prefs->SetString(prefs::kDefaultSearchProviderInstantURL, std::string());
-    prefs->SetString(prefs::kDefaultSearchProviderNewTabURL, std::string());
-    prefs->SetValue(prefs::kDefaultSearchProviderAlternateURLs,
-                    new base::ListValue());
-    prefs->SetString(
-        prefs::kDefaultSearchProviderSearchTermsReplacementKey, std::string());
-    prefs->SetString(prefs::kDefaultSearchProviderImageURL, std::string());
-    prefs->SetString(
-        prefs::kDefaultSearchProviderSearchURLPostParams, std::string());
-    prefs->SetString(
-        prefs::kDefaultSearchProviderSuggestURLPostParams, std::string());
-    prefs->SetString(
-        prefs::kDefaultSearchProviderInstantURLPostParams, std::string());
-    prefs->SetString(
-        prefs::kDefaultSearchProviderImageURLPostParams, 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
-    // aren't used.
-    const base::Value* dummy;
-    std::string url;
-    if (DefaultSearchURLIsValid(policies, &dummy, &url)) {
-
-      for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler =
-               handlers_.begin();
-           handler != handlers_.end(); ++handler) {
-        (*handler)->ApplyPolicySettings(policies, prefs);
-      }
-
-      EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderSuggestURL);
-      EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderIconURL);
-      EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderEncodings);
-      EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderKeyword);
-      EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderInstantURL);
-      EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderNewTabURL);
-      EnsureListPrefExists(prefs, prefs::kDefaultSearchProviderAlternateURLs);
-      EnsureStringPrefExists(
-          prefs,
-          prefs::kDefaultSearchProviderSearchTermsReplacementKey);
-      EnsureStringPrefExists(prefs, prefs::kDefaultSearchProviderImageURL);
-      EnsureStringPrefExists(
-          prefs,
-          prefs::kDefaultSearchProviderSearchURLPostParams);
-      EnsureStringPrefExists(
-          prefs,
-          prefs::kDefaultSearchProviderSuggestURLPostParams);
-      EnsureStringPrefExists(
-          prefs,
-          prefs::kDefaultSearchProviderInstantURLPostParams);
-      EnsureStringPrefExists(
-          prefs,
-          prefs::kDefaultSearchProviderImageURLPostParams);
-
-      // 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
-      // keyword is non-empty.
-      std::string name, keyword;
-      std::string host(GURL(url).host());
-      if (host.empty())
-        host = "_";
-      if (!prefs->GetString(prefs::kDefaultSearchProviderName, &name) ||
-          name.empty()) {
-        prefs->SetString(prefs::kDefaultSearchProviderName, host);
-      }
-      if (!prefs->GetString(prefs::kDefaultSearchProviderKeyword, &keyword) ||
-          keyword.empty()) {
-        prefs->SetString(prefs::kDefaultSearchProviderKeyword, host);
-      }
-
-      // And clear the IDs since these are not specified via policy.
-      prefs->SetString(prefs::kDefaultSearchProviderID, std::string());
-      prefs->SetString(prefs::kDefaultSearchProviderPrepopulateID,
-                       std::string());
-    }
-  }
-}
-
-bool DefaultSearchPolicyHandler::CheckIndividualPolicies(
-    const PolicyMap& policies,
-    PolicyErrorMap* errors) {
-  for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler =
-           handlers_.begin();
-       handler != handlers_.end(); ++handler) {
-    if (!(*handler)->CheckPolicySettings(policies, errors))
-      return false;
-  }
-  return true;
-}
-
-bool DefaultSearchPolicyHandler::HasDefaultSearchPolicy(
-    const PolicyMap& policies,
-    const char* policy_name) {
-  return policies.Get(policy_name) != NULL;
-}
-
-bool DefaultSearchPolicyHandler::AnyDefaultSearchPoliciesSpecified(
-    const PolicyMap& policies) {
-  for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler =
-           handlers_.begin();
-       handler != handlers_.end(); ++handler) {
-    if (policies.Get((*handler)->policy_name()))
-      return true;
-  }
-  return false;
-}
-
-bool DefaultSearchPolicyHandler::DefaultSearchProviderIsDisabled(
-    const PolicyMap& policies) {
-  const base::Value* provider_enabled =
-      policies.GetValue(key::kDefaultSearchProviderEnabled);
-  bool enabled = true;
-  return provider_enabled && provider_enabled->GetAsBoolean(&enabled) &&
-      !enabled;
-}
-
-bool DefaultSearchPolicyHandler::DefaultSearchURLIsValid(
-    const PolicyMap& policies,
-    const base::Value** url_value,
-    std::string* url_string) {
-  *url_value = policies.GetValue(key::kDefaultSearchProviderSearchURL);
-  if (!*url_value || !(*url_value)->GetAsString(url_string) ||
-      url_string->empty())
-    return false;
-  TemplateURLData data;
-  data.SetURL(*url_string);
-  SearchTermsData search_terms_data;
-  return TemplateURL(data).SupportsReplacement(search_terms_data);
-}
-
-void DefaultSearchPolicyHandler::EnsureStringPrefExists(
-    PrefValueMap* prefs,
-    const std::string& path) {
-  std::string value;
-  if (!prefs->GetString(path, &value))
-    prefs->SetString(path, value);
-}
-
-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, new base::ListValue());
-}
-
-}  // namespace policy