Refactored StringToIntEnumListPolicyHandler to be more general purpose

components/policy/core/browser/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 "components/policy/core/browser/configuration_policy_handler.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
@@ skipping 133 matching lines @@
 
     value = std::min(std::max(value, min_), max_);
   }
 
   if (output)
     *output = value;
   return true;
 }
 
 
-// StringToIntEnumListPolicyHandler implementation -----------------------------
+// StringMappingListPolicyHandler implementation -----------------------------
 
-StringToIntEnumListPolicyHandler::StringToIntEnumListPolicyHandler(
+StringMappingListPolicyHandler::MappingEntry::MappingEntry(
+    const char* policy_value, scoped_ptr<base::Value> map)
+    : enum_value(policy_value), mapped_value(map.release()) {}

[Joao da Silva, 2014/06/18 08:45:26]

.release() works but I think it's more common to do .Pass() to move from
scoped_ptr to scoped_ptr

+
+StringMappingListPolicyHandler::MappingEntry::~MappingEntry() {}
+
+StringMappingListPolicyHandler::StringMappingListPolicyHandler(
     const char* policy_name,
     const char* pref_path,
-    const MappingEntry* mapping_begin,
-    const MappingEntry* mapping_end)
+    GenerateMapCallback callback)
     : TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST),
       pref_path_(pref_path),
-      mapping_begin_(mapping_begin),
-      mapping_end_(mapping_end) {}
+      map_getter_(callback) {}
 
-bool StringToIntEnumListPolicyHandler::CheckPolicySettings(
+StringMappingListPolicyHandler::~StringMappingListPolicyHandler() {}
+
+bool StringMappingListPolicyHandler::CheckPolicySettings(
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
   const base::Value* value;
   return CheckAndGetValue(policies, errors, &value) &&
       Convert(value, NULL, errors);
 }
 
-void StringToIntEnumListPolicyHandler::ApplyPolicySettings(
+void StringMappingListPolicyHandler::ApplyPolicySettings(
     const PolicyMap& policies,
     PrefValueMap* prefs) {
   if (!pref_path_)
     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) {
+bool StringMappingListPolicyHandler::Convert(const base::Value* input,
+                                             base::ListValue* output,
+                                             PolicyErrorMap* errors) {
   if (!input)
     return true;
 
   const base::ListValue* list_value = NULL;
   if (!input->GetAsList(&list_value)) {
     NOTREACHED();
     return false;
   }
 
   for (base::ListValue::const_iterator entry(list_value->begin());
        entry != list_value->end(); ++entry) {
     std::string entry_value;
     if (!(*entry)->GetAsString(&entry_value)) {
       if (errors) {
         errors->AddError(policy_name(),
                          entry - list_value->begin(),
                          IDS_POLICY_TYPE_ERROR,
                          ValueTypeToString(base::Value::TYPE_STRING));
       }
       continue;
     }
-    bool found = false;
-    for (const MappingEntry* mapping_entry(mapping_begin_);
-         mapping_entry != mapping_end_; ++mapping_entry) {
-      if (mapping_entry->enum_value == entry_value) {
-        found = true;
-        if (output)
-          output->AppendInteger(mapping_entry->int_value);
-        break;
-      }
-    }
-    if (!found) {
+
+    scoped_ptr<base::Value> mapped_value = Map(entry_value);
+    if (mapped_value) {
+      if (output)
+        output->Append(mapped_value.release());
+    } else {
       if (errors) {
         errors->AddError(policy_name(),
                          entry - list_value->begin(),
                          IDS_POLICY_OUT_OF_RANGE_ERROR);
       }
     }
   }
 
   return true;
 }
 
+scoped_ptr<base::Value> StringMappingListPolicyHandler::Map(
+    const std::string& entry_value) {
+  // Lazily generate the map of policy strings to mapped values.
+  if (map_.empty())
+    map_getter_.Run(&map_);
+
+  scoped_ptr<base::Value> return_value;
+  for (ScopedVector<MappingEntry>::const_iterator it = map_.begin();
+       it != map_.end(); ++it) {
+    const MappingEntry* mapping_entry = *it;
+    if (mapping_entry->enum_value == entry_value) {
+      return_value = make_scoped_ptr(mapping_entry->mapped_value->DeepCopy());
+      break;
+    }
+  }
+  return return_value.Pass();
+}
 
 // IntRangePolicyHandler implementation ----------------------------------------
 
 IntRangePolicyHandler::IntRangePolicyHandler(const char* policy_name,
                                              const char* pref_path,
                                              int min,
                                              int max,
                                              bool clamp)
     : IntRangePolicyHandlerBase(policy_name, min, max, clamp),
       pref_path_(pref_path) {
@@ skipping 223 matching lines @@
     for (handler = legacy_policy_handlers_.begin();
          handler != legacy_policy_handlers_.end();
          ++handler) {
       if ((*handler)->CheckPolicySettings(policies, &scoped_errors))
         (*handler)->ApplyPolicySettings(policies, prefs);
     }
   }
 }
 
 }  // namespace policy