Remove stl_util's deletion function use from components/url_matcher/.

components/url_matcher/url_matcher.cc

 // Copyright 2013 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/url_matcher/url_matcher.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 
 namespace url_matcher {
 
 // This set of classes implement a mapping of URL Component Patterns, such as
 // host_prefix, host_suffix, host_equals, ..., etc., to StringPatterns
 // for use in substring comparisons.
 //
@@ skipping 233 matching lines @@
 const char kQueryComponentDelimiter[] = {static_cast<char>(-4), 0};
 const char kEndOfURL[] = {static_cast<char>(-5), 0};
 
 // The delimiter for query parameters
 const char kQuerySeparator = '&';
 }  // namespace
 
 URLMatcherConditionFactory::URLMatcherConditionFactory() : id_counter_(0) {}
 
 URLMatcherConditionFactory::~URLMatcherConditionFactory() {
-  base::STLDeleteElements(&substring_pattern_singletons_);
-  base::STLDeleteElements(&regex_pattern_singletons_);
-  base::STLDeleteElements(&origin_and_path_regex_pattern_singletons_);
 }
 
 std::string URLMatcherConditionFactory::CanonicalizeURLForComponentSearches(
     const GURL& url) const {
   return kBeginningOfURL + CanonicalizeHostname(url.host()) + kEndOfDomain +
          url.path() + kEndOfPath +
          (url.has_query() ? CanonicalizeQuery(url.query(), true, true)
                           : std::string()) +
          kEndOfURL;
 }
@@ skipping 178 matching lines @@
 }
 
 URLMatcherCondition
 URLMatcherConditionFactory::CreateOriginAndPathMatchesCondition(
     const std::string& regex) {
   return CreateCondition(URLMatcherCondition::ORIGIN_AND_PATH_MATCHES, regex);
 }
 
 void URLMatcherConditionFactory::ForgetUnusedPatterns(
       const std::set<StringPattern::ID>& used_patterns) {
-  PatternSingletons::iterator i = substring_pattern_singletons_.begin();
+  auto i = substring_pattern_singletons_.begin();
   while (i != substring_pattern_singletons_.end()) {
-    if (base::ContainsKey(used_patterns, (*i)->id())) {
+    if (base::ContainsKey(used_patterns, i->first->id()))
       ++i;
-    } else {
-      delete *i;
+    else
       substring_pattern_singletons_.erase(i++);
-    }
   }
+
   i = regex_pattern_singletons_.begin();
   while (i != regex_pattern_singletons_.end()) {
-    if (base::ContainsKey(used_patterns, (*i)->id())) {
+    if (base::ContainsKey(used_patterns, i->first->id()))
       ++i;
-    } else {
-      delete *i;
+    else
       regex_pattern_singletons_.erase(i++);
-    }
   }
+
   i = origin_and_path_regex_pattern_singletons_.begin();
   while (i != origin_and_path_regex_pattern_singletons_.end()) {
-    if (base::ContainsKey(used_patterns, (*i)->id())) {
+    if (base::ContainsKey(used_patterns, i->first->id()))
       ++i;
-    } else {
-      delete *i;
+    else
       origin_and_path_regex_pattern_singletons_.erase(i++);
-    }
   }
 }
 
 bool URLMatcherConditionFactory::IsEmpty() const {
   return substring_pattern_singletons_.empty() &&
       regex_pattern_singletons_.empty() &&
       origin_and_path_regex_pattern_singletons_.empty();
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateCondition(
     URLMatcherCondition::Criterion criterion,
     const std::string& pattern) {
   StringPattern search_pattern(pattern, 0);
   PatternSingletons* pattern_singletons = NULL;
   if (IsRegexCriterion(criterion))
     pattern_singletons = &regex_pattern_singletons_;
   else if (IsOriginAndPathRegexCriterion(criterion))
     pattern_singletons = &origin_and_path_regex_pattern_singletons_;
   else
     pattern_singletons = &substring_pattern_singletons_;
 
-  PatternSingletons::const_iterator iter =
-      pattern_singletons->find(&search_pattern);
+  auto iter = pattern_singletons->find(&search_pattern);
 
   if (iter != pattern_singletons->end())
-    return URLMatcherCondition(criterion, *iter);
+    return URLMatcherCondition(criterion, iter->first);
 
   StringPattern* new_pattern = new StringPattern(pattern, id_counter_++);
-  pattern_singletons->insert(new_pattern);
+  (*pattern_singletons)[new_pattern] = base::WrapUnique(new_pattern);
   return URLMatcherCondition(criterion, new_pattern);
 }
 
 std::string URLMatcherConditionFactory::CanonicalizeHostSuffix(
     const std::string& suffix) const {
   if (suffix.empty())
     return ".";
   return suffix.back() == '.' ? suffix : suffix + ".";
 }
 
@@ skipping 565 matching lines @@
 
 void URLMatcher::UpdateInternalDatastructures() {
   UpdateSubstringSetMatcher(false);
   UpdateSubstringSetMatcher(true);
   UpdateRegexSetMatcher();
   UpdateTriggers();
   UpdateConditionFactory();
 }
 
 }  // namespace url_matcher