Introduces a search term extraction mechanism working for arbitrary search providers.

chrome/browser/policy/configuration_policy_handler.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 "chrome/browser/policy/configuration_policy_handler.h"
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/json/json_writer.h"
@@ skipping 71 matching lines @@
     Value::TYPE_STRING },
   { key::kDefaultSearchProviderInstantURL,
     prefs::kDefaultSearchProviderInstantURL,
     Value::TYPE_STRING },
   { key::kDefaultSearchProviderIconURL,
     prefs::kDefaultSearchProviderIconURL,
     Value::TYPE_STRING },
   { key::kDefaultSearchProviderEncodings,
     prefs::kDefaultSearchProviderEncodings,
     Value::TYPE_LIST },
+  { key::kDefaultSearchProviderAlternateURLs,
+    prefs::kDefaultSearchProviderAlternateURLs,
+    Value::TYPE_LIST },
 };
 
 // List of entries determining which proxy policies can be specified, depending
 // on the ProxyMode.
 const ProxyModeValidationEntry kProxyModeValidationMap[] = {
   { ProxyPrefs::kDirectProxyModeName,
     false, false, false, IDS_POLICY_PROXY_MODE_DISABLED_ERROR },
   { ProxyPrefs::kAutoDetectProxyModeName,
     false, false, false, IDS_POLICY_PROXY_MODE_AUTO_DETECT_ERROR },
   { ProxyPrefs::kPacScriptProxyModeName,
@@ skipping 542 matching lines @@
     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->SetValue(prefs::kDefaultSearchProviderAlternateURLs,
+                    new ListValue());
   } 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 Value* dummy;
     std::string url;
     if (DefaultSearchURLIsValid(policies, &dummy, &url)) {
       for (std::vector<ConfigurationPolicyHandler*>::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);
+      EnsureListPrefExists(prefs, prefs::kDefaultSearchProviderAlternateURLs);
 
       // 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())
@@ skipping 66 matching lines @@
 }
 
 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 ListValue());
+}
+
 
 // ProxyPolicyHandler implementation -------------------------------------------
 
 // The proxy policies have the peculiarity that they are loaded from individual
 // policies, but the providers then expose them through a unified
 // DictionaryValue. Once Dictionary policies are fully supported, the individual
 // proxy policies will be deprecated. http://crbug.com/108996
 
 ProxyPolicyHandler::ProxyPolicyHandler() {
 }
@@ skipping 582 matching lines @@
 
 void DisabledPluginsByVersionPolicyHandler::ApplyPolicySettings(
     const PolicyMap& policies,
     PrefValueMap* prefs) {
   const Value* value = policies.GetValue(policy_name());
   if (value)
     prefs->SetValue(prefs::kPluginsDisabledPluginsByVersion, value->DeepCopy());
 }
 
 }  // namespace policy