extensions: Use stl utilities from the base namespace

extensions/browser/api/declarative/deduping_factory.h

 // Copyright (c) 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.
 
 #ifndef EXTENSIONS_BROWSER_API_DECLARATIVE_DEDUPING_FACTORY_H__
 #define EXTENSIONS_BROWSER_API_DECLARATIVE_DEDUPING_FACTORY_H__
 
 #include <stddef.h>
 
 #include <list>
@@ skipping 88 matching lines @@
     : max_number_prototypes_(max_number_prototypes) {}
 
 template<typename BaseClassT>
 DedupingFactory<BaseClassT>::~DedupingFactory() {}
 
 template<typename BaseClassT>
 void DedupingFactory<BaseClassT>::RegisterFactoryMethod(
     const std::string& instance_type,
     typename DedupingFactory<BaseClassT>::Parameterized parameterized,
     FactoryMethod factory_method) {
-  DCHECK(!ContainsKey(factory_methods_, instance_type));
+  DCHECK(!base::ContainsKey(factory_methods_, instance_type));
   factory_methods_[instance_type] = factory_method;
   if (parameterized == IS_PARAMETERIZED)
     parameterized_types_.insert(instance_type);
 }
 
 template<typename BaseClassT>
 scoped_refptr<const BaseClassT> DedupingFactory<BaseClassT>::Instantiate(
     const std::string& instance_type,
     const base::Value* value,
     std::string* error,
     bool* bad_message) {
   typename FactoryMethods::const_iterator factory_method_iter =
       factory_methods_.find(instance_type);
   if (factory_method_iter == factory_methods_.end()) {
     *error = "Invalid instance type " + instance_type;
     *bad_message = true;
     return scoped_refptr<const BaseClassT>();
   }
 
   FactoryMethod factory_method = factory_method_iter->second;
 
   PrototypeList& prototypes = prototypes_[instance_type];
 
   // We can take a shortcut for objects that are not parameterized. For those
   // only a single instance may ever exist so we can simplify the creation
   // logic.
-  if (!ContainsKey(parameterized_types_, instance_type)) {
+  if (!base::ContainsKey(parameterized_types_, instance_type)) {
     if (prototypes.empty()) {
       scoped_refptr<const BaseClassT> new_object =
           (*factory_method)(instance_type, value, error, bad_message);
       if (!new_object.get() || !error->empty() || *bad_message)
         return scoped_refptr<const BaseClassT>();
       prototypes.push_back(new_object);
     }
     return prototypes.front();
   }
 
@@ skipping 26 matching lines @@
 }
 
 template<typename BaseClassT>
 void DedupingFactory<BaseClassT>::ClearPrototypes() {
   prototypes_.clear();
 }
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_DECLARATIVE_DEDUPING_FACTORY_H__