Resubmit: Rename BrowserActionView to ToolbarActionView

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 "base/compiler_specific.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/tab_helper.h"
@@ skipping 146 matching lines @@
 }
 
 BrowserActionsContainer::~BrowserActionsContainer() {
   FOR_EACH_OBSERVER(BrowserActionsContainerObserver,
                     observers_,
                     OnBrowserActionsContainerDestroyed());
 
   if (model_)
     model_->RemoveObserver(this);
   HideActivePopup();
-  DeleteBrowserActionViews();
+  DeleteToolbarActionViews();
 }
 
 void BrowserActionsContainer::Init() {
   LoadImages();
 
   // We wait to set the container width until now so that the chevron images
   // will be loaded.  The width calculation needs to know the chevron size.
   if (model_ && model_->extensions_initialized()) {
     container_width_ = GetPreferredWidth();
     SetChevronVisibility();
   }
 
   initialized_ = true;
 }
 
 const std::string& BrowserActionsContainer::GetIdAt(size_t index) {
-  return browser_action_views_[index]->view_controller()->GetId();
+  return toolbar_action_views_[index]->view_controller()->GetId();
 }
 
-BrowserActionView* BrowserActionsContainer::GetViewForExtension(
+ToolbarActionView* BrowserActionsContainer::GetViewForExtension(
     const Extension* extension) {
-  for (BrowserActionView* view : browser_action_views_) {
+  for (ToolbarActionView* view : toolbar_action_views_) {
     if (view->view_controller()->GetId() == extension->id())
       return view;
   }
-  return NULL;
+  return nullptr;
 }
 
-void BrowserActionsContainer::RefreshBrowserActionViews() {
-  for (BrowserActionView* view : browser_action_views_)
+void BrowserActionsContainer::RefreshToolbarActionViews() {
+  for (ToolbarActionView* view : toolbar_action_views_)
     view->UpdateState();
 }
 
-void BrowserActionsContainer::CreateBrowserActionViews() {
-  DCHECK(browser_action_views_.empty());
+void BrowserActionsContainer::CreateToolbarActionViews() {
+  DCHECK(toolbar_action_views_.empty());
   if (!model_)
     return;
 
   ScopedVector<ToolbarActionViewController> actions =
       GetToolbarActions(model_, browser_);
   for (ToolbarActionViewController* controller : actions) {
-    BrowserActionView* view =
-        new BrowserActionView(make_scoped_ptr(controller), browser_, this);
-    browser_action_views_.push_back(view);
+    ToolbarActionView* view =
+        new ToolbarActionView(make_scoped_ptr(controller), browser_, this);
+    toolbar_action_views_.push_back(view);
     AddChildView(view);
   }
   actions.weak_clear();
 }
 
-void BrowserActionsContainer::DeleteBrowserActionViews() {
+void BrowserActionsContainer::DeleteToolbarActionViews() {
   HideActivePopup();
-  STLDeleteElements(&browser_action_views_);
+  STLDeleteElements(&toolbar_action_views_);
 }
 
 size_t BrowserActionsContainer::VisibleBrowserActions() const {
   size_t visible_actions = 0;
-  for (const BrowserActionView* view : browser_action_views_) {
+  for (const ToolbarActionView* view : toolbar_action_views_) {
     if (view->visible())
       ++visible_actions;
   }
   return visible_actions;
 }
 
 size_t BrowserActionsContainer::VisibleBrowserActionsAfterAnimation() const {
   if (!animating())
     return VisibleBrowserActions();
 
@@ skipping 11 matching lines @@
 }
 
 void BrowserActionsContainer::NotifyActionMovedToOverflow() {
   // When an action is moved to overflow, we shrink the size of the container
   // by 1.
   int icon_count = model_->GetVisibleIconCount();
   // Since this happens when an icon moves from the main bar to overflow, we
   // can't possibly have had no visible icons on the main bar.
   DCHECK_NE(0, icon_count);
   if (icon_count == -1)
-    icon_count = browser_action_views_.size();
+    icon_count = toolbar_action_views_.size();
   model_->SetVisibleIconCount(icon_count - 1);
 }
 
 bool BrowserActionsContainer::ShownInsideMenu() const {
   return in_overflow_mode();
 }
 
-void BrowserActionsContainer::OnBrowserActionViewDragDone() {
+void BrowserActionsContainer::OnToolbarActionViewDragDone() {
   ToolbarVisibleCountChanged();
   FOR_EACH_OBSERVER(BrowserActionsContainerObserver,
                     observers_,
                     OnBrowserActionDragDone());
 }
 
 views::MenuButton* BrowserActionsContainer::GetOverflowReferenceView() {
   // With traditional overflow, the reference is the chevron. With the
   // redesign, we use the wrench menu instead.
   return chevron_ ?
       chevron_ :
       BrowserView::GetBrowserViewForBrowser(browser_)->toolbar()->app_menu();
 }
 
-void BrowserActionsContainer::SetPopupOwner(BrowserActionView* popup_owner) {
+void BrowserActionsContainer::SetPopupOwner(ToolbarActionView* popup_owner) {
   // We should never be setting a popup owner when one already exists, and
   // never unsetting one when one wasn't set.
   DCHECK((!popup_owner_ && popup_owner) ||
          (popup_owner_ && !popup_owner));
   popup_owner_ = popup_owner;
 }
 
 void BrowserActionsContainer::HideActivePopup() {
   if (popup_owner_)
     popup_owner_->view_controller()->HidePopup();
 }
 
-BrowserActionView* BrowserActionsContainer::GetMainViewForAction(
-    BrowserActionView* view) {
+ToolbarActionView* BrowserActionsContainer::GetMainViewForAction(
+    ToolbarActionView* view) {
   if (!in_overflow_mode())
     return view;  // This is the main view.
 
   // The overflow container and main container each have the same views and
   // view indices, so we can return the view of the index that |view| has in
   // this container.
-  BrowserActionViews::const_iterator iter =
-      std::find(browser_action_views_.begin(),
-                browser_action_views_.end(),
+  ToolbarActionViews::const_iterator iter =
+      std::find(toolbar_action_views_.begin(),
+                toolbar_action_views_.end(),
                 view);
-  DCHECK(iter != browser_action_views_.end());
-  size_t index = iter - browser_action_views_.begin();
-  return main_container_->browser_action_views_[index];
+  DCHECK(iter != toolbar_action_views_.end());
+  size_t index = iter - toolbar_action_views_.begin();
+  return main_container_->toolbar_action_views_[index];
 }
 
 void BrowserActionsContainer::AddObserver(
     BrowserActionsContainerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void BrowserActionsContainer::RemoveObserver(
     BrowserActionsContainerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 gfx::Size BrowserActionsContainer::GetPreferredSize() const {
   if (in_overflow_mode()) {
     int icon_count = GetIconCount();
     // In overflow, we always have a preferred size of a full row (even if we
     // don't use it), and always of at least one row. The parent may decide to
     // show us even when empty, e.g. as a drag target for dragging in icons from
     // the main container.
     int row_count =
         ((std::max(0, icon_count - 1)) / icons_per_overflow_menu_row_) + 1;
     return gfx::Size(IconCountToWidth(icons_per_overflow_menu_row_),
                      row_count * IconHeight());
   }
 
   // If there are no actions to show, then don't show the container at all.
-  if (browser_action_views_.empty())
+  if (toolbar_action_views_.empty())
     return gfx::Size();
 
   // We calculate the size of the view by taking the current width and
   // subtracting resize_amount_ (the latter represents how far the user is
   // resizing the view or, if animating the snapping, how far to animate it).
   // But we also clamp it to a minimum size and the maximum size, so that the
   // container can never shrink too far or take up more space than it needs.
   // In other words: MinimumNonemptyWidth() < width() - resize < ClampTo(MAX).
   int preferred_width = std::min(
       std::max(MinimumNonemptyWidth(), container_width_ - resize_amount_),
       IconCountToWidth(-1));
   return gfx::Size(preferred_width, IconHeight());
 }
 
 int BrowserActionsContainer::GetHeightForWidth(int width) const {
   if (in_overflow_mode())
     icons_per_overflow_menu_row_ = (width - kItemSpacing) / IconWidth(true);
   return GetPreferredSize().height();
 }
 
 gfx::Size BrowserActionsContainer::GetMinimumSize() const {
   int min_width = std::min(MinimumNonemptyWidth(), IconCountToWidth(-1));
   return gfx::Size(min_width, IconHeight());
 }
 
 void BrowserActionsContainer::Layout() {
-  if (browser_action_views_.empty()) {
+  if (toolbar_action_views_.empty()) {
     SetVisible(false);
     return;
   }
 
   SetVisible(true);
   if (resize_area_)
     resize_area_->SetBounds(0, 0, kItemSpacing, height());
 
   // If the icons don't all fit, show the chevron (unless suppressed).
   int max_x = GetPreferredSize().width();
@@ skipping 14 matching lines @@
   int container_padding =
       in_overflow_mode() ? kItemSpacing : ToolbarView::kStandardSpacing;
   // The range of visible icons, from start_index (inclusive) to end_index
   // (exclusive).
   size_t start_index = in_overflow_mode() ?
       main_container_->VisibleBrowserActionsAfterAnimation() : 0u;
   // For the main container's last visible icon, we calculate how many icons we
   // can display with the given width. We add an extra kItemSpacing because the
   // last icon doesn't need padding, but we want it to divide easily.
   size_t end_index = in_overflow_mode() ?
-      browser_action_views_.size() :
+      toolbar_action_views_.size() :
       (max_x - 2 * container_padding + kItemSpacing) / IconWidth(true);
   // The maximum length for one row of icons.
   size_t row_length =
       in_overflow_mode() ? icons_per_overflow_menu_row_ : end_index;
 
-  // Now draw the icons for the browser 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 < browser_action_views_.size(); ++i) {
-    BrowserActionView* view = browser_action_views_[i];
+  // 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];
     if (i < start_index || i >= end_index) {
       view->SetVisible(false);
     } else {
       size_t relative_index = i - start_index;
       size_t index_in_row = relative_index % row_length;
       size_t row_index = relative_index / row_length;
       view->SetBounds(container_padding + index_in_row * IconWidth(true),
                       row_index * IconHeight(),
                       IconWidth(false),
                       IconHeight());
@@ skipping 13 matching lines @@
 }
 
 bool BrowserActionsContainer::CanDrop(const OSExchangeData& data) {
   return BrowserActionDragData::CanDrop(data, profile_);
 }
 
 int BrowserActionsContainer::OnDragUpdated(
     const ui::DropTargetEvent& event) {
   size_t row_index = 0;
   size_t before_icon_in_row = 0;
-  // If there are no visible browser actions (such as when dragging an icon to
-  // an empty overflow/main container), then 0, 0 for row, column is correct.
+  // If there are no visible actions (such as when dragging an icon to an empty
+  // overflow/main container), then 0, 0 for row, column is correct.
   if (VisibleBrowserActions() != 0) {
     // Figure out where to display the indicator. This is a complex calculation:
 
     // First, we subtract out the padding to the left of the icon area, which is
     // ToolbarView::kStandardSpacing. If we're right-to-left, we also mirror the
     // event.x() so that our calculations are consistent with left-to-right.
     int offset_into_icon_area =
         GetMirroredXInView(event.x()) - ToolbarView::kStandardSpacing;
 
     // Next, figure out what row we're on. This only matters for overflow mode,
@@ skipping 84 matching lines @@
   // correct when dragging an icon to the left. When dragging to the right,
   // however, we want the icon being dragged to get the index of the item to
   // the left of the drop indicator, so we subtract one.
   // * Well, it can also point to the end, but not when dragging to the left. :)
   if (i > data.index())
     --i;
 
   // If this was a drag between containers, we will have to adjust the number of
   // visible icons.
   bool drag_between_containers =
-      !browser_action_views_[data.index()]->visible();
+      !toolbar_action_views_[data.index()]->visible();
   model_->MoveExtensionIcon(GetIdAt(data.index()), i);
 
   if (drag_between_containers) {
     // Let the main container update the model.
     if (in_overflow_mode())
       main_container_->NotifyActionMovedToOverflow();
     else  // This is the main container.
       model_->SetVisibleIconCount(model_->GetVisibleIconCount() + 1);
   }
 
   OnDragExited();  // Perform clean up after dragging.
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
 void BrowserActionsContainer::GetAccessibleState(
     ui::AXViewState* state) {
   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) {
   DCHECK(data);
 
-  BrowserActionViews::iterator iter = std::find(browser_action_views_.begin(),
-                                                browser_action_views_.end(),
+  ToolbarActionViews::iterator iter = std::find(toolbar_action_views_.begin(),
+                                                toolbar_action_views_.end(),
                                                 sender);
-  DCHECK(iter != browser_action_views_.end());
+  DCHECK(iter != toolbar_action_views_.end());
   ToolbarActionViewController* view_controller = (*iter)->view_controller();
   drag_utils::SetDragImageOnDataObject(
       view_controller->GetIconWithBadge(),
       press_pt.OffsetFromOrigin(),
       data);
   // Fill in the remaining info.
   BrowserActionDragData drag_data(view_controller->GetId(),
-                                  iter - browser_action_views_.begin());
+                                  iter - toolbar_action_views_.begin());
   drag_data.Write(profile_, data);
 }
 
 int BrowserActionsContainer::GetDragOperationsForView(View* sender,
                                                       const gfx::Point& p) {
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
 bool BrowserActionsContainer::CanStartDragForView(View* sender,
                                                   const gfx::Point& press_pt,
@@ skipping 59 matching lines @@
 
 gfx::NativeView BrowserActionsContainer::TestGetPopup() {
   return popup_owner_ ?
       popup_owner_->view_controller()->GetPopupNativeView() :
       NULL;
 }
 
 void BrowserActionsContainer::OnPaint(gfx::Canvas* canvas) {
   // If the views haven't been initialized yet, wait for the next call to
   // paint (one will be triggered by entering highlight mode).
-  if (model_->is_highlighting() && !browser_action_views_.empty() &&
+  if (model_->is_highlighting() && !toolbar_action_views_.empty() &&
       !in_overflow_mode()) {
     views::Painter::PaintPainterAt(
         canvas, highlight_painter_.get(), GetLocalBounds());
   }
 
   // TODO(sky/glen): Instead of using a drop indicator, animate the icons while
   // dragging (like we do for tab dragging).
   if (drop_position_.get()) {
     // The two-pixel width drop indicator.
     static const int kDropIndicatorWidth = 2;
@@ skipping 46 matching lines @@
           browser_->profile(),
           parent()->GetFocusManager(),
           extensions::ExtensionKeybindingRegistry::ALL_EXTENSIONS,
           this));
     }
 
     // Initial toolbar button creation and placement in the widget hierarchy.
     // We do this here instead of in the constructor because AddBrowserAction
     // calls Layout on the Toolbar, which needs this object to be constructed
     // before its Layout function is called.
-    CreateBrowserActionViews();
+    CreateToolbarActionViews();
   }
 }
 
 // static
 int BrowserActionsContainer::IconWidth(bool include_padding) {
   static bool initialized = false;
   static int icon_width = 0;
   if (!initialized) {
     initialized = true;
     icon_width = ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
@@ skipping 14 matching lines @@
   return icon_height;
 }
 
 void BrowserActionsContainer::ToolbarExtensionAdded(const Extension* extension,
                                                     int index) {
   DCHECK(!GetViewForExtension(extension)) <<
       "Asked to add a browser action view for an extension that already exists";
   if (chevron_)
     chevron_->CloseMenu();
 
-  // Add the new browser action to the vector and the view hierarchy.
-  BrowserActionView* view = new BrowserActionView(
+  // Add the new action to the vector and the view hierarchy.
+  ToolbarActionView* view = new ToolbarActionView(
       make_scoped_ptr(new ExtensionActionViewController(
           extension,
           browser_,
           extensions::ExtensionActionManager::Get(profile_)->
               GetExtensionAction(*extension))),
       browser_,
       this);
-  browser_action_views_.insert(browser_action_views_.begin() + index, view);
+  toolbar_action_views_.insert(toolbar_action_views_.begin() + index, view);
   AddChildViewAt(view, index);
 
   // If we are still initializing the container, don't bother animating.
   if (!model_->extensions_initialized())
     return;
 
   // If this is just an upgrade, then don't worry about resizing.
   if (!extensions::ExtensionSystem::Get(profile_)->runtime_data()->
           IsBeingUpgraded(extension)) {
     // We need to resize if either:
     // - The container is set to display all icons (visible count = -1), or
     // - The container will need to expand to include the chevron. This can
     //   happen when the container is set to display <n> icons, where <n> is
     //   the number of icons before the new icon. With the new icon, the chevron
     //   will need to be displayed.
     int model_icon_count = model_->GetVisibleIconCount();
     if (model_icon_count == -1 ||
-        (static_cast<size_t>(model_icon_count) < browser_action_views_.size() &&
+        (static_cast<size_t>(model_icon_count) < toolbar_action_views_.size() &&
          (chevron_ && !chevron_->visible()))) {
       suppress_chevron_ = true;
       Animate(gfx::Tween::LINEAR, GetIconCount());
       return;
     }
   }
 
   // Otherwise, we don't have to resize, so just redraw the (possibly modified)
   // visible icon set.
   OnBrowserActionVisibilityChanged();
 }
 
 void BrowserActionsContainer::ToolbarExtensionRemoved(
     const Extension* extension) {
   if (chevron_)
     chevron_->CloseMenu();
 
   size_t visible_actions = VisibleBrowserActionsAfterAnimation();
-  for (BrowserActionViews::iterator i(browser_action_views_.begin());
-       i != browser_action_views_.end(); ++i) {
+  for (ToolbarActionViews::iterator i(toolbar_action_views_.begin());
+       i != toolbar_action_views_.end(); ++i) {
     if ((*i)->view_controller()->GetId() == extension->id()) {
       delete *i;
-      browser_action_views_.erase(i);
+      toolbar_action_views_.erase(i);
 
       // If the extension is being upgraded we don't want the bar to shrink
       // because the icon is just going to get re-added to the same location.
       if (extensions::ExtensionSystem::Get(profile_)->runtime_data()->
               IsBeingUpgraded(extension))
         return;
 
-      if (browser_action_views_.size() > visible_actions) {
+      if (toolbar_action_views_.size() > visible_actions) {
         // If we have more icons than we can show, then we must not be changing
         // the container size (since we either removed an icon from the main
         // area and one from the overflow list will have shifted in, or we
         // removed an entry directly from the overflow list).
         OnBrowserActionVisibilityChanged();
       } else {
         // Either we went from overflow to no-overflow, or we shrunk the no-
         // overflow container by 1.  Either way the size changed, so animate.
         if (chevron_)
           chevron_->SetVisible(false);
-        Animate(gfx::Tween::EASE_OUT, browser_action_views_.size());
+        Animate(gfx::Tween::EASE_OUT, toolbar_action_views_.size());
       }
       return;  // We have found the action to remove, bail out.
     }
   }
 }
 
 void BrowserActionsContainer::ToolbarExtensionMoved(const Extension* extension,
                                                     int index) {
-  DCHECK(index >= 0 && index < static_cast<int>(browser_action_views_.size()));
+  DCHECK(index >= 0 && index < static_cast<int>(toolbar_action_views_.size()));
 
-  BrowserActionViews::iterator iter = browser_action_views_.begin();
-  while (iter != browser_action_views_.end() &&
+  ToolbarActionViews::iterator iter = toolbar_action_views_.begin();
+  while (iter != toolbar_action_views_.end() &&
          (*iter)->view_controller()->GetId() != extension->id())
     ++iter;
 
-  DCHECK(iter != browser_action_views_.end());
-  if (iter - browser_action_views_.begin() == index)
+  DCHECK(iter != toolbar_action_views_.end());
+  if (iter - toolbar_action_views_.begin() == index)
     return;  // Already in place.
 
-  BrowserActionView* moved_view = *iter;
-  browser_action_views_.erase(iter);
-  browser_action_views_.insert(
-      browser_action_views_.begin() + index, moved_view);
+  ToolbarActionView* moved_view = *iter;
+  toolbar_action_views_.erase(iter);
+  toolbar_action_views_.insert(
+      toolbar_action_views_.begin() + index, moved_view);
 
   Layout();
   SchedulePaint();
 }
 
 void BrowserActionsContainer::ToolbarExtensionUpdated(
     const Extension* extension) {
-  BrowserActionView* view = GetViewForExtension(extension);
+  ToolbarActionView* view = GetViewForExtension(extension);
   // There might not be a view in cases where we are highlighting or if we
   // haven't fully initialized extensions.
   if (view)
     view->UpdateState();
 }
 
 bool BrowserActionsContainer::ShowExtensionActionPopup(
     const Extension* extension,
     bool grant_active_tab) {
   // Don't override another popup, and only show in the active window.
   if (popup_owner_ || !browser_->window()->IsActive())
     return false;
 
-  BrowserActionView* view = GetViewForExtension(extension);
+  ToolbarActionView* view = GetViewForExtension(extension);
   return view && view->view_controller()->ExecuteAction(grant_active_tab);
 }
 
 void BrowserActionsContainer::ToolbarVisibleCountChanged() {
   if (GetPreferredWidth() != container_width_)
     Animate(gfx::Tween::EASE_OUT, GetIconCount());
 }
 
 void BrowserActionsContainer::ToolbarHighlightModeChanged(
     bool is_highlighting) {
   // The visual highlighting is done in OnPaint(). It's a bit of a pain that
   // we delete and recreate everything here, but given everything else going on
   // (the lack of highlight, n more extensions appearing, etc), it's not worth
   // the extra complexity to create and insert only the new extensions.
-  DeleteBrowserActionViews();
-  CreateBrowserActionViews();
+  DeleteToolbarActionViews();
+  CreateToolbarActionViews();
   Animate(gfx::Tween::LINEAR, GetIconCount());
 }
 
 Browser* BrowserActionsContainer::GetBrowser() {
   return browser_;
 }
 
 void BrowserActionsContainer::LoadImages() {
   if (in_overflow_mode())
     return;  // Overflow mode has neither a chevron nor highlighting.
 
   ui::ThemeProvider* tp = GetThemeProvider();
   if (tp && chevron_) {
     chevron_->SetImage(views::Button::STATE_NORMAL,
                        *tp->GetImageSkiaNamed(IDR_BROWSER_ACTIONS_OVERFLOW));
   }
 
   const int kImages[] = IMAGE_GRID(IDR_DEVELOPER_MODE_HIGHLIGHT);
   highlight_painter_.reset(views::Painter::CreateImageGridPainter(kImages));
 }
 
 void BrowserActionsContainer::OnBrowserActionVisibilityChanged() {
-  SetVisible(!browser_action_views_.empty());
+  SetVisible(!toolbar_action_views_.empty());
   if (parent()) {  // Parent can be null in testing.
     parent()->Layout();
     parent()->SchedulePaint();
   }
 }
 
 int BrowserActionsContainer::GetPreferredWidth() {
   return IconCountToWidth(GetIconCount());
 }
 
 void BrowserActionsContainer::SetChevronVisibility() {
   if (chevron_) {
     chevron_->SetVisible(
-        VisibleBrowserActionsAfterAnimation() < browser_action_views_.size());
+        VisibleBrowserActionsAfterAnimation() < toolbar_action_views_.size());
   }
 }
 
 int BrowserActionsContainer::IconCountToWidth(int icons) const {
   if (icons < 0)
-    icons = browser_action_views_.size();
+    icons = toolbar_action_views_.size();
   bool display_chevron =
-      chevron_ && static_cast<size_t>(icons) < browser_action_views_.size();
+      chevron_ && static_cast<size_t>(icons) < toolbar_action_views_.size();
   if (icons == 0 && !display_chevron)
     return ToolbarView::kStandardSpacing;
   int icons_size =
       (icons == 0) ? 0 : ((icons * IconWidth(true)) - kItemSpacing);
   int chevron_size = display_chevron ?
       (kChevronSpacing + chevron_->GetPreferredSize().width()) : 0;
   // In overflow mode, our padding is to use item spacing on either end (just so
   // we can see the drop indicator). Otherwise we use the standard toolbar
   // spacing.
   // Note: These are actually the same thing, but, on the offchance one
   // changes, let's get it right.
   int padding =
       2 * (in_overflow_mode() ? kItemSpacing : ToolbarView::kStandardSpacing);
   return icons_size + chevron_size + padding;
 }
 
 size_t BrowserActionsContainer::WidthToIconCount(int pixels) const {
   // Check for widths large enough to show the entire icon set.
   if (pixels >= IconCountToWidth(-1))
-    return browser_action_views_.size();
+    return toolbar_action_views_.size();
 
   // We reserve space for the padding on either side of the toolbar...
   int available_space = pixels - (ToolbarView::kStandardSpacing * 2);
   // ... and, if the chevron is enabled, the chevron.
   if (chevron_)
     available_space -= (chevron_->GetPreferredSize().width() + kChevronSpacing);
 
   // Now we add an extra between-item padding value so the space can be divided
   // evenly by (size of icon with padding).
   return static_cast<size_t>(
@@ skipping 31 matching lines @@
   int model_visible_size = model_->GetVisibleIconCount();
   size_t absolute_model_visible_size = model_visible_size == -1 ?
       model_->toolbar_items().size() : model_visible_size;
 
 #if !defined(NDEBUG)
   // Good time for some sanity checks: We should never try to display more
   // icons than we have, and we should always have a view per item in the model.
   // (The only exception is if this is in initialization.)
   if (initialized_) {
     size_t num_extension_actions = 0u;
-    for (BrowserActionView* view : browser_action_views_) {
+    for (ToolbarActionView* view : toolbar_action_views_) {
       // No component action should ever have a valid extension id, so we can
       // use this to check the extension amount.
       // TODO(devlin): Fix this to just check model size when the model also
       // includes component actions.
       if (crx_file::id_util::IdIsValid(view->view_controller()->GetId()))
         ++num_extension_actions;
     }
     DCHECK_LE(absolute_model_visible_size, num_extension_actions);
     DCHECK_EQ(model_->toolbar_items().size(), num_extension_actions);
   }
 #endif
 
   // The overflow displays any icons not shown by the main bar.
   return in_overflow_mode() ?
       model_->toolbar_items().size() - absolute_model_visible_size :
       absolute_model_visible_size;
 }