Remove use of stl_util in search_engines.

components/search_engines/default_search_policy_handler.cc

 // Copyright 2014 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/search_engines/default_search_policy_handler.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/stl_util.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/policy/policy_constants.h"
 #include "components/prefs/pref_value_map.h"
 #include "components/search_engines/default_search_manager.h"
 #include "components/search_engines/search_engines_pref_names.h"
 #include "components/search_engines/search_terms_data.h"
 #include "components/search_engines/template_url.h"
@@ skipping 155 matching lines @@
   prefs->SetString(prefs::kDefaultSearchProviderEncodings, encodings);
 }
 
 
 // DefaultSearchPolicyHandler implementation -----------------------------------
 
 DefaultSearchPolicyHandler::DefaultSearchPolicyHandler() {
   for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) {
     const char* policy_name = kDefaultSearchPolicyMap[i].policy_name;
     if (policy_name == key::kDefaultSearchProviderEncodings) {
-      handlers_.push_back(new DefaultSearchEncodingsPolicyHandler());
+      handlers_.push_back(
+          base::MakeUnique<DefaultSearchEncodingsPolicyHandler>());
     } else {
-      handlers_.push_back(new SimplePolicyHandler(
-          policy_name,
-          kDefaultSearchPolicyMap[i].preference_path,
+      handlers_.push_back(base::MakeUnique<SimplePolicyHandler>(
+          policy_name, kDefaultSearchPolicyMap[i].preference_path,
           kDefaultSearchPolicyMap[i].value_type));
     }
   }
 }
 
-DefaultSearchPolicyHandler::~DefaultSearchPolicyHandler() {
-  base::STLDeleteElements(&handlers_);
-}
+DefaultSearchPolicyHandler::~DefaultSearchPolicyHandler() {}
 
 bool DefaultSearchPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
                                                      PolicyErrorMap* errors) {
   if (!CheckIndividualPolicies(policies, errors))
     return false;
 
   if (DefaultSearchProviderIsDisabled(policies)) {
     // Add an error for all specified default search policies except
     // DefaultSearchProviderEnabled.
 
-    for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler =
-             handlers_.begin();
-         handler != handlers_.end(); ++handler) {
-      const char* policy_name = (*handler)->policy_name();
+    for (auto& handler : handlers_) {

[Peter Kasting, 2016/08/31 04:12:56]

Nit: Seems like this could be const auto&.

[Avi (use Gerrit), 2016/09/01 00:34:26]

Done.

+      const char* policy_name = handler->policy_name();
       if (policy_name != key::kDefaultSearchProviderEnabled &&
           HasDefaultSearchPolicy(policies, policy_name)) {
         errors->AddError(policy_name, IDS_POLICY_DEFAULT_SEARCH_DISABLED);
       }
     }
     return true;
   }
 
   const base::Value* url;
   std::string dummy;
@@ skipping 73 matching lines @@
     dict->SetString(DefaultSearchManager::kShortName, host);
   if (keyword.empty())
     dict->SetString(DefaultSearchManager::kKeyword, host);
 
   DefaultSearchManager::AddPrefValueToMap(std::move(dict), prefs);
 }
 
 bool DefaultSearchPolicyHandler::CheckIndividualPolicies(
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
-  for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler =
-           handlers_.begin();
-       handler != handlers_.end(); ++handler) {
-    if (!(*handler)->CheckPolicySettings(policies, errors))
+  for (auto& handler : handlers_) {
+    if (!handler->CheckPolicySettings(policies, errors))
       return false;
   }
   return true;
 }
 
 bool DefaultSearchPolicyHandler::HasDefaultSearchPolicy(
     const PolicyMap& policies,
     const char* policy_name) {
   return policies.Get(policy_name) != NULL;
 }
 
 bool DefaultSearchPolicyHandler::AnyDefaultSearchPoliciesSpecified(
     const PolicyMap& policies) {
-  for (std::vector<TypeCheckingPolicyHandler*>::const_iterator handler =
-           handlers_.begin();
-       handler != handlers_.end(); ++handler) {
-    if (policies.Get((*handler)->policy_name()))
+  for (auto& handler : handlers_) {

[Peter Kasting, 2016/08/31 04:12:56]

Nit: Seems like this could be const auto&.

[Avi (use Gerrit), 2016/09/01 00:34:26]

Done.

+    if (policies.Get(handler->policy_name()))
       return true;
   }
   return false;
 }
 
 bool DefaultSearchPolicyHandler::DefaultSearchProviderIsDisabled(
     const PolicyMap& policies) {
   const base::Value* provider_enabled =
       policies.GetValue(key::kDefaultSearchProviderEnabled);
   bool enabled = true;
@@ skipping 26 matching lines @@
 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, base::WrapUnique(new base::ListValue()));
 }
 
 }  // namespace policy