Remove stl_util's deletion function use from chrome/.

chrome/browser/ui/views/toolbar/browser_actions_container.cc

 // Copyright 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.
 
 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
 
 #include <utility>
 
 #include "base/compiler_specific.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "chrome/browser/extensions/extension_message_bubble_controller.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_controller.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_model.h"
 #include "chrome/browser/ui/view_ids.h"
@@ skipping 93 matching lines @@
   // All views should be removed as part of ToolbarActionsBar::DeleteActions().
   DCHECK(toolbar_action_views_.empty());
 }
 
 std::string BrowserActionsContainer::GetIdAt(size_t index) const {
   return toolbar_action_views_[index]->view_controller()->GetId();
 }
 
 ToolbarActionView* BrowserActionsContainer::GetViewForId(
     const std::string& id) {
-  for (ToolbarActionView* view : toolbar_action_views_) {
+  for (const auto& view : toolbar_action_views_) {
     if (view->view_controller()->GetId() == id)
-      return view;
+      return view.get();
   }
   return nullptr;
 }
 
 void BrowserActionsContainer::RefreshToolbarActionViews() {
   toolbar_actions_bar_->Update();
 }
 
 size_t BrowserActionsContainer::VisibleBrowserActions() const {
   size_t visible_actions = 0;
-  for (const ToolbarActionView* view : toolbar_action_views_) {
+  for (const auto& view : toolbar_action_views_) {
     if (view->visible())
       ++visible_actions;
   }
   return visible_actions;
 }
 
 size_t BrowserActionsContainer::VisibleBrowserActionsAfterAnimation() const {
   if (!animating())
     return VisibleBrowserActions();
 
@@ skipping 10 matching lines @@
 
 views::MenuButton* BrowserActionsContainer::GetOverflowReferenceView() {
   return static_cast<views::MenuButton*>(
       GetToolbarView(browser_)->app_menu_button());
 }
 
 void BrowserActionsContainer::AddViewForAction(
    ToolbarActionViewController* view_controller,
    size_t index) {
   ToolbarActionView* view = new ToolbarActionView(view_controller, this);
-  toolbar_action_views_.insert(toolbar_action_views_.begin() + index, view);
+  toolbar_action_views_.insert(toolbar_action_views_.begin() + index,
+                               base::WrapUnique(view));
   AddChildViewAt(view, index);
 }
 
 void BrowserActionsContainer::RemoveViewForAction(
     ToolbarActionViewController* action) {
   for (ToolbarActionViews::iterator iter = toolbar_action_views_.begin();
        iter != toolbar_action_views_.end(); ++iter) {
     if ((*iter)->view_controller() == action) {
-      delete *iter;
       toolbar_action_views_.erase(iter);
       break;
     }
   }
 }
 
 void BrowserActionsContainer::RemoveAllViews() {
-  base::STLDeleteElements(&toolbar_action_views_);
+  toolbar_action_views_.clear();
 }
 
 void BrowserActionsContainer::Redraw(bool order_changed) {
   if (!added_to_view_) {
     // We don't want to redraw before the view has been fully added to the
     // hierarchy.
     return;
   }
 
   // Don't allow resizing if the bar is highlighting.
   if (resize_area_)
     resize_area_->SetEnabled(!toolbar_actions_bar()->is_highlighting());
 
   std::vector<ToolbarActionViewController*> actions =
       toolbar_actions_bar_->GetActions();
   if (order_changed) {
     // Run through the views and compare them to the desired order. If something
     // is out of place, find the correct spot for it.
     for (int i = 0; i < static_cast<int>(actions.size()) - 1; ++i) {
       if (actions[i] != toolbar_action_views_[i]->view_controller()) {
         // Find where the correct view is (it's guaranteed to be after our
         // current index, since everything up to this point is correct).
         int j = i + 1;
         while (actions[i] != toolbar_action_views_[j]->view_controller())
           ++j;
         std::swap(toolbar_action_views_[i], toolbar_action_views_[j]);
         // Also move the view in the child views vector.
-        ReorderChildView(toolbar_action_views_[i], i);
+        ReorderChildView(toolbar_action_views_[i].get(), i);
       }
     }
   }
 
   Layout();
 }
 
 void BrowserActionsContainer::ResizeAndAnimate(gfx::Tween::Type tween_type,
                                                int target_width) {
   if (resize_animation_ && !toolbar_actions_bar_->suppress_animation()) {
@@ skipping 129 matching lines @@
 
   // The range of visible icons, from start_index (inclusive) to end_index
   // (exclusive).
   size_t start_index = toolbar_actions_bar_->GetStartIndexInBounds();
   size_t end_index = toolbar_actions_bar_->GetEndIndexInBounds();
 
   // Now draw the icons for the actions in the available space. Once all the
   // variables are in place, the layout works equally well for the main and
   // overflow container.
   for (size_t i = 0u; i < toolbar_action_views_.size(); ++i) {
-    ToolbarActionView* view = toolbar_action_views_[i];
+    ToolbarActionView* view = toolbar_action_views_[i].get();
     if (i < start_index || i >= end_index) {
       view->SetVisible(false);
     } else {
       view->SetBoundsRect(toolbar_actions_bar_->GetFrameForIndex(i));
       view->SetVisible(true);
     }
   }
 }
 
 bool BrowserActionsContainer::GetDropFormats(
@@ skipping 133 matching lines @@
   state->role = ui::AX_ROLE_GROUP;
   state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_EXTENSIONS);
 }
 
 void BrowserActionsContainer::WriteDragDataForView(View* sender,
                                                    const gfx::Point& press_pt,
                                                    OSExchangeData* data) {
   toolbar_actions_bar_->OnDragStarted();
   DCHECK(data);
 
-  auto it = std::find(toolbar_action_views_.cbegin(),
-                      toolbar_action_views_.cend(), sender);
+  auto it =
+      std::find_if(toolbar_action_views_.cbegin(), toolbar_action_views_.cend(),
+                   [sender](const std::unique_ptr<ToolbarActionView>& ptr) {
+                     return ptr.get() == sender;
+                   });
   DCHECK(it != toolbar_action_views_.cend());
   ToolbarActionViewController* view_controller = (*it)->view_controller();
   gfx::Size size(ToolbarActionsBar::IconWidth(false),
                  ToolbarActionsBar::IconHeight());
   drag_utils::SetDragImageOnDataObject(
       view_controller->GetIcon(GetCurrentWebContents(), size).AsImageSkia(),
       press_pt.OffsetFromOrigin(),
       data);
   // Fill in the remaining info.
   BrowserActionDragData drag_data(view_controller->GetId(),
@@ skipping 134 matching lines @@
   }
 }
 
 void BrowserActionsContainer::ClearActiveBubble(views::Widget* widget) {
   DCHECK(active_bubble_);
   DCHECK_EQ(active_bubble_->GetWidget(), widget);
   widget->RemoveObserver(this);
   active_bubble_ = nullptr;
   toolbar_actions_bar_->OnBubbleClosed();
 }