Keep the toolbar overflow menu the same when removing a component action

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 215 matching lines @@
   // added by EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED below, if the user
   // hides the browser action and then disables and enables the extension.
   if (!HasItem(ToolbarItem(extension->id(), EXTENSION_ACTION)))
     AddExtension(extension);
 }
 
 void ToolbarActionsModel::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
-  size_t index = 0u;
-  while (toolbar_items().size() > index &&
-         toolbar_items()[index].id != extension->id())
-    ++index;
   bool was_visible_and_has_overflow =
-      index < visible_icon_count() && !all_icons_visible();
+      IsActionVisible(extension->id()) && !all_icons_visible();
   RemoveExtension(extension);
   // If the extension was previously visible and there are overflowed
   // extensions, and this extension is being uninstalled, we reduce the visible
   // count so that we don't pop out a previously-hidden extension.
   if (was_visible_and_has_overflow &&
       reason == extensions::UnloadedExtensionInfo::REASON_UNINSTALL)
     SetVisibleIconCount(visible_icon_count() - 1);
 }
 
 void ToolbarActionsModel::OnExtensionUninstalled(
@@ skipping 389 matching lines @@
   }
 
   DCHECK(use_redesign_);
   ToolbarItem component_item(action_id, COMPONENT_ACTION);
   DCHECK(!HasItem(component_item));
   AddItem(component_item);
 }
 
 void ToolbarActionsModel::RemoveComponentAction(const std::string& action_id) {
   DCHECK(use_redesign_);
+  // If the action was visible and there are overflowed actions, we reduce the
+  // visible count so that we don't pop out a previously-hidden action.
+  if (IsActionVisible(action_id) && !all_icons_visible())
+    SetVisibleIconCount(visible_icon_count() - 1);
+
   ToolbarItem component_item(action_id, COMPONENT_ACTION);
   DCHECK(HasItem(component_item));
   RemoveItem(component_item);
   RemovePref(component_item);
 }
 
 void ToolbarActionsModel::IncognitoPopulate() {
   DCHECK(profile_->IsOffTheRecord());
   const ToolbarActionsModel* original_model =
       ToolbarActionsModel::Get(profile_->GetOriginalProfile());
@@ skipping 141 matching lines @@
   for (const std::string& action_id : ids) {
     for (const ToolbarItem& item : toolbar_items_) {
       if (action_id == item.id)
         highlighted_items_.push_back(item);
     }
   }
 
   // If we have any items in |highlighted_items_|, then we entered highlighting
   // mode.
   if (highlighted_items_.size()) {
-    // It's important that is_highlighting_ is changed immediately before the
+    // It's important that |highlight_type_| is changed immediately before the
     // observers are notified since it changes the result of toolbar_items().
     highlight_type_ = highlight_type;
     for (Observer& observer : observers_)
       observer.OnToolbarHighlightModeChanged(true);
 
     // We set the visible icon count after the highlight mode change because
     // the UI actions are created/destroyed during highlight, and doing that
     // prior to changing the size allows us to still have smooth animations.
     if (visible_icon_count() < ids.size())
       SetVisibleIconCount(ids.size());
 
     return true;
   }
 
   // Otherwise, we didn't enter highlighting mode (and, in fact, exited it if
   // we were otherwise in it).
   if (is_highlighting())
     StopHighlighting();
   return false;
 }
 
 void ToolbarActionsModel::StopHighlighting() {
   if (is_highlighting()) {
-    // It's important that is_highlighting_ is changed immediately before the
+    // It's important that |highlight_type_| is changed immediately before the
     // observers are notified since it changes the result of toolbar_items().
     highlight_type_ = HIGHLIGHT_NONE;
     for (Observer& observer : observers_)
       observer.OnToolbarHighlightModeChanged(false);
 
     // For the same reason, we don't clear highlighted_items_ until after the
     // mode changed.
     highlighted_items_.clear();
 
     // We set the visible icon count after the highlight mode change because
     // the UI actions are created/destroyed during highlight, and doing that
     // prior to changing the size allows us to still have smooth animations.
     int saved_icon_count =
         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);
 }
+
+bool ToolbarActionsModel::IsActionVisible(const std::string& action_id) const {
+  size_t index = 0u;
+  while (toolbar_items().size() > index &&
+         toolbar_items()[index].id != action_id)
+    ++index;
+  return index < visible_icon_count();
+}