Renamed ExtensionIdSet to ExtensionIds

chrome/browser/extensions/extension_toolbar_model.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/extension_toolbar_model.h"
 
 #include "chrome/browser/extensions/browser_event_router.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/tab_helper.h"
@@ skipping 253 matching lines @@
   else
     PopulateForNonActionBoxMode();
 
   UpdatePrefs();
 
   extensions_initialized_ = true;
   FOR_EACH_OBSERVER(Observer, observers_, ModelLoaded());
 }
 
 void ExtensionToolbarModel::PopulateForActionBoxMode() {
-  const extensions::ExtensionPrefs::ExtensionIdSet toolbar_order =
+  const extensions::ExtensionPrefs::ExtensionIds toolbar_order =
       service_->extension_prefs()->GetToolbarOrder();
-  extensions::ExtensionPrefs::ExtensionIdSet action_box_order =
+  extensions::ExtensionPrefs::ExtensionIds action_box_order =
       service_->extension_prefs()->GetActionBoxOrder();
 
   // Add all browser actions not already in the toolbar or action box
   // to the action box (the prefs list may omit some extensions).
   for (ExtensionSet::const_iterator iter = service_->extensions()->begin();
        iter != service_->extensions()->end(); ++iter) {
     const Extension* extension = *iter;
     if (!extension->browser_action())
       continue;
 
     if (std::find(toolbar_order.begin(), toolbar_order.end(),
                   extension->id()) != toolbar_order.end())
       continue;
 
     if (std::find(action_box_order.begin(), action_box_order.end(),
                   extension->id()) != action_box_order.end())
       continue;
 
     action_box_order.push_back(extension->id());
   }
 
   FillExtensionList(action_box_order, &action_box_menu_items_);
   FillExtensionList(toolbar_order, &toolbar_items_);
 }
 
 void ExtensionToolbarModel::PopulateForNonActionBoxMode() {
-  const extensions::ExtensionPrefs::ExtensionIdSet pref_order =
+  const extensions::ExtensionPrefs::ExtensionIds pref_order =
       service_->extension_prefs()->GetToolbarOrder();
   // Items that have a pref for their position.
   ExtensionList sorted;
   sorted.resize(pref_order.size(), NULL);
   // The items that don't have a pref for their position.
   ExtensionList unsorted;
 
   // Create the lists.
   for (ExtensionSet::const_iterator it = service_->extensions()->begin();
        it != service_->extensions()->end(); ++it) {
     const Extension* extension = *it;
     if (!extension->browser_action())
       continue;
     if (!service_->extension_prefs()->GetBrowserActionVisibility(extension))
       continue;
 
-    extensions::ExtensionPrefs::ExtensionIdSet::const_iterator pos =
+    extensions::ExtensionPrefs::ExtensionIds::const_iterator pos =
         std::find(pref_order.begin(), pref_order.end(), extension->id());
     if (pos != pref_order.end())
       sorted[pos - pref_order.begin()] = extension;
     else
       unsorted.push_back(make_scoped_refptr(extension));
   }
 
   // Merge the lists.
   toolbar_items_.clear();
   toolbar_items_.reserve(sorted.size() + unsorted.size());
@@ skipping 12 matching lines @@
                         unsorted.end());
 
   // Inform observers.
   for (size_t i = 0; i < toolbar_items_.size(); i++) {
     FOR_EACH_OBSERVER(Observer, observers_,
                       BrowserActionAdded(toolbar_items_[i], i));
   }
 }
 
 void ExtensionToolbarModel::FillExtensionList(
-    const extensions::ExtensionPrefs::ExtensionIdSet& order,
+    const extensions::ExtensionPrefs::ExtensionIds& order,
     ExtensionList* list) {
   list->clear();
   list->reserve(order.size());
   for (size_t i = 0; i < order.size(); ++i) {
     const extensions::Extension* extension =
         service_->GetExtensionById(order[i], false);
     if (extension)
       AddExtension(extension, list);
   }
 }
 
 void ExtensionToolbarModel::UpdatePrefs() {
   if (!service_->extension_prefs())
     return;
 
-  extensions::ExtensionPrefs::ExtensionIdSet toolbar_ids;
+  extensions::ExtensionPrefs::ExtensionIds toolbar_ids;
   toolbar_ids.reserve(toolbar_items_.size());
   for (size_t i = 0; i < toolbar_items_.size(); ++i)
     toolbar_ids.push_back(toolbar_items_[i]->id());
   service_->extension_prefs()->SetToolbarOrder(toolbar_ids);
 
-  extensions::ExtensionPrefs::ExtensionIdSet action_box_ids;
+  extensions::ExtensionPrefs::ExtensionIds action_box_ids;
   action_box_ids.reserve(action_box_menu_items_.size());
   for (size_t i = 0; i < action_box_menu_items_.size(); ++i)
     action_box_ids.push_back(action_box_menu_items_[i]->id());
   service_->extension_prefs()->SetActionBoxOrder(action_box_ids);
 }
 
 int ExtensionToolbarModel::IncognitoIndexToOriginal(int incognito_index) {
   int original_index = 0, i = 0;
   for (ExtensionList::iterator iter = toolbar_items_.begin();
        iter != toolbar_items_.end();
@@ skipping 12 matching lines @@
   for (ExtensionList::iterator iter = toolbar_items_.begin();
        iter != toolbar_items_.end();
        ++iter, ++i) {
     if (original_index == i)
       break;
     if (service_->IsIncognitoEnabled((*iter)->id()))
       ++incognito_index;
   }
   return incognito_index;
 }