Convert list policy to string preference. (DefaultSearchProviderEncodings).

chrome/browser/policy/configuration_policy_pref_store.cc

 // Copyright (c) 2011 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_pref_store.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 81 matching lines @@
   // ownership of |value| in the case that the policy is recognized.
   bool ApplyDownloadDirPolicy(ConfigurationPolicyType policy, Value* value);
 
   // Processes file-selection dialogs policy. Returns true if the specified
   // policy is the file-selection dialogs policy.
   // ApplyFileSelectionDialogsPolicy assumes the ownership of |value| in the
   // case that the policy is recognized.
   bool ApplyFileSelectionDialogsPolicy(ConfigurationPolicyType policy,
                                        Value* value);
 
+  // Processes default search provider policies. Returns true if the specified
+  // policy is a default search provider related policy. In that case,
+  // ApplyDefaultSearchPolicy takes ownership of |value|.
+  bool ApplyDefaultSearchPolicy(ConfigurationPolicyType policy, Value* value);
+
   // Make sure that the |path| if present in |prefs_|.  If not, set it to
   // a blank string.
   void EnsureStringPrefExists(const std::string& path);
 
   // If the required entries for default search are specified and valid,
   // finalizes the policy-specified configuration by initializing the
   // unspecified map entries.  Otherwise wipes all default search related
   // map entries from |prefs_|.
   void FinalizeDefaultSearchPolicySettings();
 
@@ skipping 167 matching lines @@
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderKeyword,
     prefs::kDefaultSearchProviderKeyword },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderSearchURL,
     prefs::kDefaultSearchProviderSearchURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderSuggestURL,
     prefs::kDefaultSearchProviderSuggestURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderInstantURL,
     prefs::kDefaultSearchProviderInstantURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderIconURL,
     prefs::kDefaultSearchProviderIconURL },
-  { Value::TYPE_STRING, kPolicyDefaultSearchProviderEncodings,
+  { Value::TYPE_LIST, kPolicyDefaultSearchProviderEncodings,
     prefs::kDefaultSearchProviderEncodings },
 };
 
 ConfigurationPolicyPrefKeeper::ConfigurationPolicyPrefKeeper(
     ConfigurationPolicyProvider* provider) {
   if (!provider->Provide(this))
     LOG(WARNING) << "Failed to get policy from provider.";
   FinalizeProxyPolicySettings();
   FinalizeDefaultSearchPolicySettings();
 }
@@ skipping 34 matching lines @@
 
   if (ApplyAutofillPolicy(policy, value))
     return;
 
   if (ApplyDownloadDirPolicy(policy, value))
     return;
 
   if (ApplyFileSelectionDialogsPolicy(policy, value))
     return;
 
-  if (ApplyPolicyFromMap(policy, value, kDefaultSearchPolicyMap,
-                         arraysize(kDefaultSearchPolicyMap)))
+  if (ApplyDefaultSearchPolicy(policy, value))
     return;
 
   if (ApplyPolicyFromMap(policy, value, kSimplePolicyMap,
                          arraysize(kSimplePolicyMap)))
     return;
 
   // Other policy implementations go here.
   NOTIMPLEMENTED();
   delete value;
 }
 
 bool ConfigurationPolicyPrefKeeper::RemovePreferencesOfMap(
     const PolicyToPreferenceMapEntry* map, int table_size) {
   bool found_any = false;
   for (int i = 0; i < table_size; ++i) {
     if (prefs_.RemoveValue(map[i].preference_path))
       found_any = true;
   }
   return found_any;
 }
 
 bool ConfigurationPolicyPrefKeeper::ApplyPolicyFromMap(
     ConfigurationPolicyType policy,
     Value* value,
     const PolicyToPreferenceMapEntry* map,
     int size) {
   for (int current = 0; current < size; ++current) {
     if (map[current].policy_type == policy) {
       DCHECK_EQ(map[current].value_type, value->GetType())
-          << "mismatch in provided and expected policy value for preferences"
+          << "mismatch in provided and expected policy value for preferences "
           << map[current].preference_path << ". expected = "
           << map[current].value_type << ", actual = "<< value->GetType();
       prefs_.SetValue(map[current].preference_path, value);
       return true;
     }
   }
   return false;
 }
 
 bool ConfigurationPolicyPrefKeeper::ApplyProxyPolicy(
@@ skipping 81 matching lines @@
     if (!allow_file_selection_dialogs) {
       prefs_.SetValue(prefs::kPromptForDownload,
                       Value::CreateBooleanValue(false));
     }
     return true;
   }
   // We are not interested in this policy.
   return false;
 }
 
+bool ConfigurationPolicyPrefKeeper::ApplyDefaultSearchPolicy(
+    ConfigurationPolicyType policy,
+    Value* value) {
+  // The DefaultSearchProviderEncodings policy has type list, but the related
+  // preference has type string. Convert one into the other here, using
+  // ';' as a separator.
+  // None of the types has been fixed for backwards compatibility.

[Mattias Nissler (ping if slow), 2011/05/20 16:56:16]

That comment only adds confusion. If you think that's desirable, add a TODO. If
you don't think so, just leave it out.

+  if (policy == kPolicyDefaultSearchProviderEncodings) {
+    ListValue* list;
+    if (!value->GetAsList(&list)) {
+      NOTREACHED()
+          << "mismatch in provided and expected policy value for preferences "
+          << prefs::kDefaultSearchProviderEncodings << ". expected = "
+          << Value::TYPE_LIST << ", actual = "<< value->GetType();
+      return false;
+    }
+    ListValue::const_iterator iter(list->begin());
+    ListValue::const_iterator end(list->end());
+    std::string encodings;
+    for (; iter != end; ++iter) {
+      std::string s;
+      if ((*iter)->GetAsString(&s)) {
+        if (!encodings.empty())
+          encodings.push_back(';');
+        encodings.append(s);
+      } else {
+        NOTREACHED();
+      }
+    }
+    // We own |value|.
+    delete value;
+    prefs_.SetValue(prefs::kDefaultSearchProviderEncodings,
+                    Value::CreateStringValue(encodings));
+    return true;
+  }
+
+  if (ApplyPolicyFromMap(policy, value, kDefaultSearchPolicyMap,
+                         arraysize(kDefaultSearchPolicyMap))) {
+    return true;
+  }
+  return false;
+}
+
 void ConfigurationPolicyPrefKeeper::EnsureStringPrefExists(
     const std::string& path) {
   std::string value;
   if (!prefs_.GetString(path, &value))
     prefs_.SetString(path, value);
 }
 
 namespace {
 
 // Implementation of SearchTermsData just for validation.
@@ skipping 189 matching lines @@
   }
   return true;
 }
 
 void ConfigurationPolicyPrefKeeper::ApplyProxySettings() {
   ProxyPrefs::ProxyMode mode;
   if (HasProxyPolicy(kPolicyProxyMode)) {
     std::string string_mode;
     CHECK(proxy_policies_[kPolicyProxyMode]->GetAsString(&string_mode));
     if (!ProxyPrefs::StringToProxyMode(string_mode, &mode)) {
-      LOG(WARNING) << "A centrally-administered policy specifies a value for"
+      LOG(WARNING) << "A centrally-administered policy specifies a value for "
                    << "the ProxyMode policy that isn't recognized.";
       return;
     }
   } else if (HasProxyPolicy(kPolicyProxyServerMode)) {
     int int_mode = 0;
     CHECK(proxy_policies_[kPolicyProxyServerMode]->GetAsInteger(&int_mode));
     switch (int_mode) {
       case kPolicyNoProxyServerMode:
         mode = ProxyPrefs::MODE_DIRECT;
         break;
@@ skipping 193 matching lines @@
     { kPolicyDefaultSearchProviderKeyword, Value::TYPE_STRING,
       key::kDefaultSearchProviderKeyword },
     { kPolicyDefaultSearchProviderSearchURL, Value::TYPE_STRING,
       key::kDefaultSearchProviderSearchURL },
     { kPolicyDefaultSearchProviderSuggestURL, Value::TYPE_STRING,
       key::kDefaultSearchProviderSuggestURL },
     { kPolicyDefaultSearchProviderInstantURL, Value::TYPE_STRING,
       key::kDefaultSearchProviderInstantURL },
     { kPolicyDefaultSearchProviderIconURL, Value::TYPE_STRING,
       key::kDefaultSearchProviderIconURL },
-    { kPolicyDefaultSearchProviderEncodings, Value::TYPE_STRING,
+    { kPolicyDefaultSearchProviderEncodings, Value::TYPE_LIST,
       key::kDefaultSearchProviderEncodings },
     { kPolicyProxyMode, Value::TYPE_STRING, key::kProxyMode },
     { kPolicyProxyServerMode, Value::TYPE_INTEGER, key::kProxyServerMode },
     { kPolicyProxyServer, Value::TYPE_STRING, key::kProxyServer },
     { kPolicyProxyPacUrl, Value::TYPE_STRING, key::kProxyPacUrl },
     { kPolicyProxyBypassList, Value::TYPE_STRING, key::kProxyBypassList },
     { kPolicyAlternateErrorPagesEnabled, Value::TYPE_BOOLEAN,
       key::kAlternateErrorPagesEnabled },
     { kPolicySearchSuggestEnabled, Value::TYPE_BOOLEAN,
       key::kSearchSuggestEnabled },
@@ skipping 142 matching lines @@
   // Update the initialization flag.
   if (!initialization_complete_ &&
       provider_->IsInitializationComplete()) {
     initialization_complete_ = true;
     FOR_EACH_OBSERVER(PrefStore::Observer, observers_,
                       OnInitializationCompleted(true));
   }
 }
 
 }  // namespace policy