Add device policies to control accessibility settings on the login screen

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 <algorithm>
+#include <cstring>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/prefs/pref_value_map.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 267 matching lines @@
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
   const base::Value* value;
   return CheckAndGetValue(policies, errors, &value) &&
       Convert(value, NULL, errors);
 }
 
 void StringToIntEnumListPolicyHandler::ApplyPolicySettings(
     const PolicyMap& policies,
     PrefValueMap* prefs) {
+  if (!strlen(pref_path_))

[Mattias Nissler (ping if slow), 2013/06/12 13:55:16]

Why not test for NULL?

[bartfab (slow), 2013/06/12 18:57:49]

Done.

+    return;
   const base::Value* value = policies.GetValue(policy_name());
   scoped_ptr<base::ListValue> list(new base::ListValue());
   if (value && Convert(value, list.get(), NULL))
     prefs->SetValue(pref_path_, list.release());
 }
 
 bool StringToIntEnumListPolicyHandler::Convert(const base::Value* input,
                                                base::ListValue* output,
                                                PolicyErrorMap* errors) {
   if (!input)
@@ skipping 48 matching lines @@
                                              bool clamp)
     : IntRangePolicyHandlerBase(policy_name, min, max, clamp),
       pref_path_(pref_path) {
 }
 
 IntRangePolicyHandler::~IntRangePolicyHandler() {
 }
 
 void IntRangePolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                                 PrefValueMap* prefs) {
+  if (!strlen(pref_path_))
+    return;
   const base::Value* value = policies.GetValue(policy_name());
   int value_in_range;
   if (value && EnsureInRange(value, &value_in_range, NULL)) {
     prefs->SetValue(pref_path_,
                     base::Value::CreateIntegerValue(value_in_range));
   }
 }
 
 // IntPercentageToDoublePolicyHandler implementation ---------------------------
 
 IntPercentageToDoublePolicyHandler::IntPercentageToDoublePolicyHandler(
     const char* policy_name,
     const char* pref_path,
     int min,
     int max,
     bool clamp)
     : IntRangePolicyHandlerBase(policy_name, min, max, clamp),
       pref_path_(pref_path) {
 }
 
 IntPercentageToDoublePolicyHandler::~IntPercentageToDoublePolicyHandler() {
 }
 
 void IntPercentageToDoublePolicyHandler::ApplyPolicySettings(
     const PolicyMap& policies,
     PrefValueMap* prefs) {
+  if (!strlen(pref_path_))
+    return;
   const base::Value* value = policies.GetValue(policy_name());
   int percentage;
   if (value && EnsureInRange(value, &percentage, NULL)) {
     prefs->SetValue(pref_path_, base::Value::CreateDoubleValue(
         static_cast<double>(percentage) / 100.));
   }
 }
 
 // ExtensionListPolicyHandler implementation -----------------------------------
 
@@ skipping 210 matching lines @@
       return false;
     }
   }
 
   return true;
 }
 
 void ExtensionURLPatternListPolicyHandler::ApplyPolicySettings(
     const PolicyMap& policies,
     PrefValueMap* prefs) {
+  if (!strlen(pref_path_))
+    return;
   const Value* value = policies.GetValue(policy_name());
   if (value)
     prefs->SetValue(pref_path_, value->DeepCopy());
 }
 
 // SimplePolicyHandler implementation ------------------------------------------
 
 SimplePolicyHandler::SimplePolicyHandler(
     const char* policy_name,
     const char* pref_path,
     Value::Type value_type)
     : TypeCheckingPolicyHandler(policy_name, value_type),
       pref_path_(pref_path) {
 }
 
 SimplePolicyHandler::~SimplePolicyHandler() {
 }
 
 void SimplePolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                               PrefValueMap* prefs) {
+  if (!strlen(pref_path_))
+    return;
   const Value* value = policies.GetValue(policy_name());
   if (value)
     prefs->SetValue(pref_path_, value->DeepCopy());
 }
 
 
 // SyncPolicyHandler implementation --------------------------------------------
 
 SyncPolicyHandler::SyncPolicyHandler()
     : TypeCheckingPolicyHandler(key::kSyncDisabled,
@@ skipping 926 matching lines @@
           errors->AddError(policy_name(),
                            IDS_POLICY_OUT_OF_RANGE_ERROR,
                            base::IntToString(restore_value));
       }
     }
   }
   return true;
 }
 
 }  // namespace policy