chrome: Use stl utilities from the base namespace

chrome/browser/extensions/menu_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/menu_manager.h"
 
 #include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ skipping 114 matching lines @@
                    Type type,
                    const ContextList& contexts)
     : id_(id),
       title_(title),
       type_(type),
       checked_(checked),
       enabled_(enabled),
       contexts_(contexts) {}
 
 MenuItem::~MenuItem() {
-  STLDeleteElements(&children_);
+  base::STLDeleteElements(&children_);
 }
 
 MenuItem* MenuItem::ReleaseChild(const Id& child_id,
                                  bool recursive) {
   for (List::iterator i = children_.begin(); i != children_.end(); ++i) {
     MenuItem* child = NULL;
     if ((*i)->id() == child_id) {
       child = *i;
       children_.erase(i);
       return child;
@@ skipping 13 matching lines @@
 }
 
 std::set<MenuItem::Id> MenuItem::RemoveAllDescendants() {
   std::set<Id> result;
   for (List::iterator i = children_.begin(); i != children_.end(); ++i) {
     MenuItem* child = *i;
     result.insert(child->id());
     std::set<Id> removed = child->RemoveAllDescendants();
     result.insert(removed.begin(), removed.end());
   }
-  STLDeleteElements(&children_);
+  base::STLDeleteElements(&children_);
   return result;
 }
 
 base::string16 MenuItem::TitleWithReplacement(const base::string16& selection,
                                               size_t max_length) const {
   base::string16 result = base::UTF8ToUTF16(title_);
   // TODO(asargent) - Change this to properly handle %% escaping so you can
   // put "%s" in titles that won't get substituted.
   base::ReplaceSubstringsAfterOffset(
       &result, 0, base::ASCIIToUTF16("%s"), selection);
@@ skipping 131 matching lines @@
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                  content::NotificationService::AllSources());
   if (store_)
     store_->RegisterKey(kContextMenusKey);
 }
 
 MenuManager::~MenuManager() {
   MenuItemMap::iterator i;
   for (i = context_items_.begin(); i != context_items_.end(); ++i) {
-    STLDeleteElements(&(i->second));
+    base::STLDeleteElements(&(i->second));
   }
 }
 
 // static
 MenuManager* MenuManager::Get(content::BrowserContext* context) {
   return MenuManagerFactory::GetForBrowserContext(context);
 }
 
 std::set<MenuItem::ExtensionKey> MenuManager::ExtensionIds() {
   std::set<MenuItem::ExtensionKey> id_set;
@@ skipping 10 matching lines @@
   if (i != context_items_.end()) {
     return &(i->second);
   }
   return NULL;
 }
 
 bool MenuManager::AddContextItem(const Extension* extension, MenuItem* item) {
   const MenuItem::ExtensionKey& key = item->id().extension_key;
 
   // The item must have a non-empty key, and not have already been added.
-  if (key.empty() || ContainsKey(items_by_id_, item->id()))
+  if (key.empty() || base::ContainsKey(items_by_id_, item->id()))
     return false;
 
   DCHECK_EQ(extension->id(), key.extension_id);
 
-  bool first_item = !ContainsKey(context_items_, key);
+  bool first_item = !base::ContainsKey(context_items_, key);
   context_items_[key].push_back(item);
   items_by_id_[item->id()] = item;
 
   if (item->type() == MenuItem::RADIO) {
     if (item->checked())
       RadioItemSelected(item);
     else
       SanitizeRadioList(context_items_[key]);
   }
 
   // If this is the first item for this extension, start loading its icon.
   if (first_item)
     icon_manager_.LoadIcon(browser_context_, extension);
 
   return true;
 }
 
 bool MenuManager::AddChildItem(const MenuItem::Id& parent_id,
                                MenuItem* child) {
   MenuItem* parent = GetItemById(parent_id);
   if (!parent || parent->type() != MenuItem::NORMAL ||
       parent->incognito() != child->incognito() ||
       parent->extension_id() != child->extension_id() ||
-      ContainsKey(items_by_id_, child->id()))
+      base::ContainsKey(items_by_id_, child->id()))
     return false;
   parent->AddChild(child);
   items_by_id_[child->id()] = child;
 
   if (child->type() == MenuItem::RADIO)
     SanitizeRadioList(parent->children());
   return true;
 }
 
 bool MenuManager::DescendantOf(MenuItem* item,
@@ skipping 61 matching lines @@
   } else {
     const MenuItem::ExtensionKey& child_key = child->id().extension_key;
     context_items_[child_key].push_back(child);
     child->parent_id_.reset(NULL);
     SanitizeRadioList(context_items_[child_key]);
   }
   return true;
 }
 
 bool MenuManager::RemoveContextMenuItem(const MenuItem::Id& id) {
-  if (!ContainsKey(items_by_id_, id))
+  if (!base::ContainsKey(items_by_id_, id))
     return false;
 
   MenuItem* menu_item = GetItemById(id);
   DCHECK(menu_item);
   const MenuItem::ExtensionKey extension_key = id.extension_key;
   MenuItemMap::iterator i = context_items_.find(extension_key);
   if (i == context_items_.end()) {
     NOTREACHED();
     return false;
   }
@@ skipping 63 matching lines @@
     MenuItem* item = *i;
     items_by_id_.erase(item->id());
 
     // Remove descendants from this item and erase them from the lookup cache.
     std::set<MenuItem::Id> removed_ids = item->RemoveAllDescendants();
     std::set<MenuItem::Id>::const_iterator j;
     for (j = removed_ids.begin(); j != removed_ids.end(); ++j) {
       items_by_id_.erase(*j);
     }
   }
-  STLDeleteElements(&context_items_for_key);
+  base::STLDeleteElements(&context_items_for_key);
   context_items_.erase(extension_key);
   icon_manager_.RemoveIcon(extension_id);
 }
 
 MenuItem* MenuManager::GetItemById(const MenuItem::Id& id) const {
   std::map<MenuItem::Id, MenuItem*>::const_iterator i =
       items_by_id_.find(id);
   if (i != items_by_id_.end())
     return i->second;
   else
@@ skipping 215 matching lines @@
     if (last_checked != item_list.end())
       (*last_checked)->SetChecked(true);
     else
       (*i)->SetChecked(true);
 
     i = radio_run_iter;
   }
 }
 
 bool MenuManager::ItemUpdated(const MenuItem::Id& id) {
-  if (!ContainsKey(items_by_id_, id))
+  if (!base::ContainsKey(items_by_id_, id))
     return false;
 
   MenuItem* menu_item = GetItemById(id);
   DCHECK(menu_item);
 
   if (menu_item->parent_id()) {
     SanitizeRadioList(GetItemById(*menu_item->parent_id())->children());
   } else {
     MenuItemMap::iterator i =
         context_items_.find(menu_item->id().extension_key);
@@ skipping 67 matching lines @@
         kContextMenusKey,
         base::Bind(
             &MenuManager::ReadFromStorage, AsWeakPtr(), extension->id()));
   }
 }
 
 void MenuManager::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                       const Extension* extension,
                                       UnloadedExtensionInfo::Reason reason) {
   MenuItem::ExtensionKey extension_key(extension->id());
-  if (ContainsKey(context_items_, extension_key)) {
+  if (base::ContainsKey(context_items_, extension_key)) {
     RemoveAllContextItems(extension_key);
   }
 }
 
 void MenuManager::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
   Profile* profile = content::Source<Profile>(source).ptr();
   // We cannot use profile_->HasOffTheRecordProfile as it may already be
@@ skipping 103 matching lines @@
 bool MenuItem::Id::operator!=(const Id& other) const {
   return !(*this == other);
 }
 
 bool MenuItem::Id::operator<(const Id& other) const {
   return std::tie(incognito, extension_key, uid, string_uid) <
     std::tie(other.incognito, other.extension_key, other.uid, other.string_uid);
 }
 
 }  // namespace extensions