components: Use stl utilities from the base namespace

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>
 
@@ skipping 204 matching lines @@
 }
 
 bool URLMatcherCondition::IsOriginAndPathRegexCondition() const {
   return IsOriginAndPathRegexCriterion(criterion_);
 }
 
 bool URLMatcherCondition::IsMatch(
     const std::set<StringPattern::ID>& matching_patterns,
     const GURL& url) const {
   DCHECK(string_pattern_);
-  if (!ContainsKey(matching_patterns, string_pattern_->id()))
+  if (!base::ContainsKey(matching_patterns, string_pattern_->id()))
     return false;
   // The criteria HOST_CONTAINS, PATH_CONTAINS, QUERY_CONTAINS are based on
   // a substring match on the raw URL. In case of a match, we need to verify
   // that the match was found in the correct component of the URL.
   switch (criterion_) {
     case HOST_CONTAINS:
       return url.host().find(string_pattern_->pattern()) !=
           std::string::npos;
     case PATH_CONTAINS:
       return url.path().find(string_pattern_->pattern()) !=
@@ skipping 19 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() {
-  STLDeleteElements(&substring_pattern_singletons_);
-  STLDeleteElements(&regex_pattern_singletons_);
-  STLDeleteElements(&origin_and_path_regex_pattern_singletons_);
+  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 180 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();
   while (i != substring_pattern_singletons_.end()) {
-    if (ContainsKey(used_patterns, (*i)->id())) {
+    if (base::ContainsKey(used_patterns, (*i)->id())) {
       ++i;
     } else {
       delete *i;
       substring_pattern_singletons_.erase(i++);
     }
   }
   i = regex_pattern_singletons_.begin();
   while (i != regex_pattern_singletons_.end()) {
-    if (ContainsKey(used_patterns, (*i)->id())) {
+    if (base::ContainsKey(used_patterns, (*i)->id())) {
       ++i;
     } else {
       delete *i;
       regex_pattern_singletons_.erase(i++);
     }
   }
   i = origin_and_path_regex_pattern_singletons_.begin();
   while (i != origin_and_path_regex_pattern_singletons_.end()) {
-    if (ContainsKey(used_patterns, (*i)->id())) {
+    if (base::ContainsKey(used_patterns, (*i)->id())) {
       ++i;
     } else {
       delete *i;
       origin_and_path_regex_pattern_singletons_.erase(i++);
     }
   }
 }
 
 bool URLMatcherConditionFactory::IsEmpty() const {
   return substring_pattern_singletons_.empty() &&
@@ skipping 280 matching lines @@
   if (port_filter_.get() && !port_filter_->IsMatch(url))
     return false;
   if (query_conditions_.empty())
     return true;
   // The loop is duplicated below for performance reasons. If not all query
   // elements are found, no need to verify match that is expected to take more
   // cycles.
   for (QueryConditions::const_iterator i = query_conditions_.begin();
        i != query_conditions_.end();
        ++i) {
-    if (!ContainsKey(matching_patterns, i->string_pattern()->id()))
+    if (!base::ContainsKey(matching_patterns, i->string_pattern()->id()))
       return false;
   }
   for (QueryConditions::const_iterator i = query_conditions_.begin();
        i != query_conditions_.end();
        ++i) {
     if (!i->IsMatch(url_for_component_searches))
       return false;
   }
   return true;
 }
@@ skipping 298 matching lines @@
 
 void URLMatcher::UpdateInternalDatastructures() {
   UpdateSubstringSetMatcher(false);
   UpdateSubstringSetMatcher(true);
   UpdateRegexSetMatcher();
   UpdateTriggers();
   UpdateConditionFactory();
 }
 
 }  // namespace url_matcher