extensions: Use stl utilities from the base namespace

extensions/common/features/simple_feature.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 "extensions/common/features/simple_feature.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 381 matching lines @@
     Manifest::Location location,
     int manifest_version,
     Platform platform) const {
   // Check extension type first to avoid granting platform app permissions
   // to component extensions.
   // HACK(kalman): user script -> extension. Solve this in a more generic way
   // when we compile feature files.
   Manifest::Type type_to_check = (type == Manifest::TYPE_USER_SCRIPT) ?
       Manifest::TYPE_EXTENSION : type;
   if (!extension_types_.empty() &&
-      !ContainsValue(extension_types_, type_to_check)) {
+      !base::ContainsValue(extension_types_, type_to_check)) {
     return CreateAvailability(INVALID_TYPE, type);
   }
 
   if (IsIdInBlacklist(extension_id))
     return CreateAvailability(FOUND_IN_BLACKLIST, type);
 
   // TODO(benwells): don't grant all component extensions.
   // See http://crbug.com/370375 for more details.
   // Component extensions can access any feature.
   // NOTE: Deliberately does not match EXTERNAL_COMPONENT.
   if (component_extensions_auto_granted_ && location == Manifest::COMPONENT)
     return CreateAvailability(IS_AVAILABLE, type);
 
   if (!whitelist_.empty() && !IsIdInWhitelist(extension_id) &&
       !IsWhitelistedForTest(extension_id)) {
     return CreateAvailability(NOT_FOUND_IN_WHITELIST, type);
   }
 
   if (!MatchesManifestLocation(location))
     return CreateAvailability(INVALID_LOCATION, type);
 
-  if (!platforms_.empty() && !ContainsValue(platforms_, platform))
+  if (!platforms_.empty() && !base::ContainsValue(platforms_, platform))
     return CreateAvailability(INVALID_PLATFORM, type);
 
   if (min_manifest_version_ != 0 && manifest_version < min_manifest_version_)
     return CreateAvailability(INVALID_MIN_MANIFEST_VERSION, type);
 
   if (max_manifest_version_ != 0 && manifest_version > max_manifest_version_)
     return CreateAvailability(INVALID_MAX_MANIFEST_VERSION, type);
 
   if (!command_line_switch_.empty() &&
       !IsCommandLineSwitchEnabled(command_line_switch_)) {
@@ skipping 23 matching lines @@
                                                 extension->manifest_version(),
                                                 platform);
     if (!result.is_available())
       return result;
   }
 
   // TODO(lazyboy): This isn't quite right for Extension Service Worker
   // extension API calls, since there's no guarantee that the extension is
   // "active" in current renderer process when the API permission check is
   // done.
-  if (!contexts_.empty() && !ContainsValue(contexts_, context))
+  if (!contexts_.empty() && !base::ContainsValue(contexts_, context))
     return CreateAvailability(INVALID_CONTEXT, context);
 
   // TODO(kalman): Consider checking |matches_| regardless of context type.
   // Fewer surprises, and if the feature configuration wants to isolate
   // "matches" from say "blessed_extension" then they can use complex features.
   if ((context == WEB_PAGE_CONTEXT || context == WEBUI_CONTEXT) &&
       !matches_.MatchesURL(url)) {
     return CreateAvailability(INVALID_URL, url);
   }
 
@@ skipping 136 matching lines @@
   return ((std::find(start, end, extension_id) != end) ||
           (std::find(start, end, HashedIdInHex(extension_id)) != end));
 }
 
 // static
 bool SimpleFeature::IsIdInList(const std::string& extension_id,
                                const std::vector<std::string>& list) {
   if (!IsValidExtensionId(extension_id))
     return false;
 
-  return (ContainsValue(list, extension_id) ||
-          ContainsValue(list, HashedIdInHex(extension_id)));
+  return (base::ContainsValue(list, extension_id) ||
+          base::ContainsValue(list, HashedIdInHex(extension_id)));
 }
 
 bool SimpleFeature::MatchesManifestLocation(
     Manifest::Location manifest_location) const {
   switch (location_) {
     case SimpleFeature::UNSPECIFIED_LOCATION:
       return true;
     case SimpleFeature::COMPONENT_LOCATION:
       return manifest_location == Manifest::COMPONENT;
     case SimpleFeature::EXTERNAL_COMPONENT_LOCATION:
@@ skipping 64 matching lines @@
 void SimpleFeature::set_platforms(std::initializer_list<Platform> platforms) {
   platforms_ = platforms;
 }
 
 void SimpleFeature::set_whitelist(
     std::initializer_list<const char* const> whitelist) {
   whitelist_.assign(whitelist.begin(), whitelist.end());
 }
 
 }  // namespace extensions