Switch various ValueTypeToString()s to base::Value::GetTypeName().

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 <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "components/policy/core/browser/policy_error_map.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/prefs/pref_value_map.h"
 #include "grit/components_strings.h"
 #include "url/gurl.h"
 
 namespace policy {
 
 // ConfigurationPolicyHandler implementation -----------------------------------
 
-// static
-std::string ConfigurationPolicyHandler::ValueTypeToString(
-    base::Value::Type type) {
-  return std::string(base::Value::GetTypeName(type));
-}
-
 ConfigurationPolicyHandler::ConfigurationPolicyHandler() {
 }
 
 ConfigurationPolicyHandler::~ConfigurationPolicyHandler() {
 }
 
 void ConfigurationPolicyHandler::PrepareForDisplaying(
     PolicyMap* policies) const {}
 
 void ConfigurationPolicyHandler::ApplyPolicySettingsWithParameters(
@@ skipping 23 matching lines @@
                                                     PolicyErrorMap* errors) {
   const base::Value* value = NULL;
   return CheckAndGetValue(policies, errors, &value);
 }
 
 bool TypeCheckingPolicyHandler::CheckAndGetValue(const PolicyMap& policies,
                                                  PolicyErrorMap* errors,
                                                  const base::Value** value) {
   *value = policies.GetValue(policy_name_);
   if (*value && !(*value)->IsType(value_type_)) {
-    errors->AddError(policy_name_,
-                     IDS_POLICY_TYPE_ERROR,
-                     ValueTypeToString(value_type_));
+    errors->AddError(policy_name_, IDS_POLICY_TYPE_ERROR,
+                     base::Value::GetTypeName(value_type_));
     return false;
   }
   return true;
 }
 
 
 // IntRangePolicyHandlerBase implementation ------------------------------------
 
 IntRangePolicyHandlerBase::IntRangePolicyHandlerBase(
     const char* policy_name,
@@ skipping 95 matching lines @@
   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(),
+        errors->AddError(policy_name(), entry - list_value->begin(),
                          IDS_POLICY_TYPE_ERROR,
-                         ValueTypeToString(base::Value::TYPE_STRING));
+                         base::Value::GetTypeName(base::Value::TYPE_STRING));
       }
       continue;
     }
 
     std::unique_ptr<base::Value> mapped_value = Map(entry_value);
     if (mapped_value) {
       if (output)
         output->Append(std::move(mapped_value));
     } else {
       if (errors) {
         errors->AddError(policy_name(),
                          entry - list_value->begin(),
                          IDS_POLICY_OUT_OF_RANGE_ERROR);
       }
     }
   }
 
   return true;
 }
 
 std::unique_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_);
 
   std::unique_ptr<base::Value> return_value;
-  for (ScopedVector<MappingEntry>::const_iterator it = map_.begin();
-       it != map_.end(); ++it) {
-    const MappingEntry* mapping_entry = *it;
+  for (const auto& mapping_entry : map_) {
     if (mapping_entry->enum_value == entry_value) {
       return_value = base::WrapUnique(mapping_entry->mapped_value->DeepCopy());
       break;
     }
   }
   return return_value;
 }
 
 // IntRangePolicyHandler implementation ----------------------------------------
 
@@ skipping 173 matching lines @@
     PrefValueMap* prefs) {
   if (!pref_path_)
     return;
   const base::Value* value = policies.GetValue(policy_name());
   if (value)
     prefs->SetValue(pref_path_, value->CreateDeepCopy());
 }
 
 // LegacyPoliciesDeprecatingPolicyHandler implementation -----------------------
 
-// TODO(binjin): Add a new common base class for SchemaValidatingPolicyHandler
-// and TypeCheckingPolicyHandler representing policy handlers for a single
-// policy, and use it as the type of |new_policy_handler|.
-// http://crbug.com/345299
 LegacyPoliciesDeprecatingPolicyHandler::LegacyPoliciesDeprecatingPolicyHandler(
     ScopedVector<ConfigurationPolicyHandler> legacy_policy_handlers,
     std::unique_ptr<SchemaValidatingPolicyHandler> new_policy_handler)
     : legacy_policy_handlers_(std::move(legacy_policy_handlers)),
       new_policy_handler_(std::move(new_policy_handler)) {}
 
 LegacyPoliciesDeprecatingPolicyHandler::
     ~LegacyPoliciesDeprecatingPolicyHandler() {
 }
 
 bool LegacyPoliciesDeprecatingPolicyHandler::CheckPolicySettings(
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
-  if (policies.Get(new_policy_handler_->policy_name())) {
+  if (policies.Get(new_policy_handler_->policy_name()))
     return new_policy_handler_->CheckPolicySettings(policies, errors);
-  } else {
-    // The new policy is not set, fall back to legacy ones.
-    ScopedVector<ConfigurationPolicyHandler>::iterator handler;
-    bool valid_policy_found = false;
-    for (handler = legacy_policy_handlers_.begin();
-         handler != legacy_policy_handlers_.end();
-         ++handler) {
-      if ((*handler)->CheckPolicySettings(policies, errors))
-        valid_policy_found = true;
-    }
-    return valid_policy_found;
+
+  // The new policy is not set, fall back to legacy ones.
+  ScopedVector<ConfigurationPolicyHandler>::iterator handler;
+  bool valid_policy_found = false;
+  for (const auto& handler : legacy_policy_handlers_) {
+    if (handler->CheckPolicySettings(policies, errors))
+      valid_policy_found = true;
   }
+  return valid_policy_found;
 }
 
 void LegacyPoliciesDeprecatingPolicyHandler::ApplyPolicySettingsWithParameters(
     const policy::PolicyMap& policies,
     const policy::PolicyHandlerParameters& parameters,
     PrefValueMap* prefs) {
   if (policies.Get(new_policy_handler_->policy_name())) {
     new_policy_handler_->ApplyPolicySettingsWithParameters(policies, parameters,
                                                            prefs);
-  } else {
-    // The new policy is not set, fall back to legacy ones.
-    PolicyErrorMap scoped_errors;
-    ScopedVector<ConfigurationPolicyHandler>::iterator handler;
-    for (handler = legacy_policy_handlers_.begin();
-         handler != legacy_policy_handlers_.end();
-         ++handler) {
-      if ((*handler)->CheckPolicySettings(policies, &scoped_errors)) {
-        (*handler)
-            ->ApplyPolicySettingsWithParameters(policies, parameters, prefs);
-      }
-    }
+    return;
+  }
+
+  // The new policy is not set, fall back to legacy ones.
+  PolicyErrorMap scoped_errors;
+  for (const auto& handler : legacy_policy_handlers_) {
+    if (handler->CheckPolicySettings(policies, &scoped_errors))
+      handler->ApplyPolicySettingsWithParameters(policies, parameters, prefs);
   }
 }
+
 void LegacyPoliciesDeprecatingPolicyHandler::ApplyPolicySettings(
     const policy::PolicyMap& /* policies */,
     PrefValueMap* /* prefs */) {
   NOTREACHED();
 }
 
 }  // namespace policy