chrome: Use stl utilities from the base namespace

chrome/browser/ui/toolbar/toolbar_actions_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/ui/toolbar/toolbar_actions_model.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/location.h"
@@ skipping 318 matching lines @@
 
   AddItem(ToolbarItem(extension->id(), EXTENSION_ACTION),
           extensions::Manifest::IsComponentLocation(extension->location()));
 }
 
 void ToolbarActionsModel::AddItem(const ToolbarItem& item, bool is_component) {
   // We only use AddItem() once the system is initialized.
   DCHECK(actions_initialized_);
 
   // See if we have a last known good position for this extension.
-  bool is_new_extension =
-      !ContainsValue(last_known_positions_, item.id);
+  bool is_new_extension = !base::ContainsValue(last_known_positions_, item.id);
 
   // New extensions go at the right (end) of the visible extensions. Other
   // extensions go at their previous position.
   size_t new_index = 0;
   if (is_new_extension) {
     new_index = is_component ? 0 : visible_icon_count();
     // For the last-known position, we use the index of the extension that is
     // just before this extension, plus one. (Note that this isn't the same
     // as new_index + 1, because last_known_positions_ can include disabled
     // extensions.)
@@ skipping 262 matching lines @@
       // BrowserActionsVisible is when the redesign has been enabled.
       UMA_HISTOGRAM_COUNTS_100("Toolbar.ActionsModel.ToolbarActionsVisible",
                                visible_icon_count_ == -1
                                    ? base::HistogramBase::kSampleType_MAX
                                    : visible_icon_count_);
     }
   }
 }
 
 bool ToolbarActionsModel::HasItem(const ToolbarItem& item) const {
-  return ContainsValue(toolbar_items_, item);
+  return base::ContainsValue(toolbar_items_, item);
 }
 
 bool ToolbarActionsModel::HasComponentAction(
     const std::string& action_id) const {
   DCHECK(use_redesign_);
   return HasItem(ToolbarItem(action_id, COMPONENT_ACTION));
 }
 
 void ToolbarActionsModel::AddComponentAction(const std::string& action_id) {
   DCHECK(use_redesign_);
@@ skipping 102 matching lines @@
 void ToolbarActionsModel::OnActionToolbarPrefChange() {
   // If extensions are not ready, defer to later Populate() call.
   if (!actions_initialized_)
     return;
 
   // Recalculate |last_known_positions_| to be |pref_positions| followed by
   // ones that are only in |last_known_positions_|.
   std::vector<std::string> pref_positions = extension_prefs_->GetToolbarOrder();
   size_t pref_position_size = pref_positions.size();
   for (size_t i = 0; i < last_known_positions_.size(); ++i) {
-    if (!ContainsValue(pref_positions, last_known_positions_[i])) {
+    if (!base::ContainsValue(pref_positions, last_known_positions_[i])) {
       pref_positions.push_back(last_known_positions_[i]);
     }
   }
   last_known_positions_.swap(pref_positions);
 
   // Loop over the updated list of last known positions, moving any extensions
   // that are in the wrong place.
   auto desired_pos = toolbar_items_.begin();
   for (const std::string& id : last_known_positions_) {
     auto current_pos = std::find_if(
@@ skipping 81 matching lines @@
         prefs_->GetInteger(extensions::pref_names::kToolbarSize);
     if (saved_icon_count != visible_icon_count_)
       SetVisibleIconCount(saved_icon_count);
   }
 }
 
 const extensions::Extension* ToolbarActionsModel::GetExtensionById(
     const std::string& id) const {
   return extension_registry_->enabled_extensions().GetByID(id);
 }