Revert of Make extensions that desire to act pop out if in overflow

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 <algorithm>
 #include <string>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 103 matching lines @@
     toolbar_items_.push_back(extension);
     last_known_positions_.push_back(id);
   }
 
   FOR_EACH_OBSERVER(
       Observer, observers_, ToolbarExtensionMoved(extension.get(), index));
   MaybeUpdateVisibilityPref(extension.get(), index);
   UpdatePrefs();
 }
 
-void ExtensionToolbarModel::SetVisibleIconCount(size_t count) {
-  visible_icon_count_ = (count == toolbar_items_.size()) ? -1 : count;
+void ExtensionToolbarModel::SetVisibleIconCount(int count) {
+  visible_icon_count_ =
+      count == static_cast<int>(toolbar_items_.size()) ? -1 : count;
 
   // Only set the prefs if we're not in highlight mode and the profile is not
   // incognito. Highlight mode is designed to be a transitory state, and should
   //  not persist across browser restarts (though it may be re-entered), and we
   // don't store anything in incognito.
   if (!is_highlighting_ && !profile_->IsOffTheRecord()) {
     // Additionally, if we are using the new toolbar, any icons which are in the
     // overflow menu are considered "hidden". But it so happens that the times
     // we are likely to call SetVisibleIconCount() are also those when we are
     // in flux. So wait for things to cool down before setting the prefs.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ExtensionToolbarModel::MaybeUpdateVisibilityPrefs,
                    weak_ptr_factory_.GetWeakPtr()));
     prefs_->SetInteger(pref_names::kToolbarSize, visible_icon_count_);
   }
 
   FOR_EACH_OBSERVER(Observer, observers_, ToolbarVisibleCountChanged());
 }
 
 void ExtensionToolbarModel::OnExtensionActionUpdated(
     ExtensionAction* extension_action,
     content::WebContents* web_contents,
     content::BrowserContext* browser_context) {
   const Extension* extension =
       ExtensionRegistry::Get(profile_)->enabled_extensions().GetByID(
           extension_action->extension_id());
   // Notify observers if the extension exists and is in the model.
-  ExtensionList::const_iterator iter =
-      std::find(toolbar_items_.begin(), toolbar_items_.end(), extension);
-  if (iter != toolbar_items_.end()) {
-    FOR_EACH_OBSERVER(
-        Observer, observers_, ToolbarExtensionUpdated(extension));
-    // If the action was in the overflow menu, we have to alert observers that
-    // the toolbar needs to be reordered (to show the action).
-    if (static_cast<size_t>(iter - toolbar_items_.begin()) >=
-            visible_icon_count()) {
-      FOR_EACH_OBSERVER(
-          Observer, observers_, OnToolbarReorderNecessary(web_contents));
-    }
+  if (extension &&
+      std::find(toolbar_items_.begin(),
+                toolbar_items_.end(),
+                extension) != toolbar_items_.end()) {
+    FOR_EACH_OBSERVER(Observer, observers_, ToolbarExtensionUpdated(extension));
   }
 }
 
 void ExtensionToolbarModel::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const Extension* extension) {
   // We don't want to add the same extension twice. It may have already been
   // added by EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED below, if the user
   // hides the browser action and then disables and enables the extension.
   for (size_t i = 0; i < toolbar_items_.size(); i++) {
@@ skipping 323 matching lines @@
 
 void ExtensionToolbarModel::IncognitoPopulate() {
   DCHECK(profile_->IsOffTheRecord());
   // Clear the current items, if any.
   ClearItems();
 
   const ExtensionToolbarModel* original_model =
       ExtensionToolbarModel::Get(profile_->GetOriginalProfile());
 
   // Find the absolute value of the original model's count.
-  int original_visible = original_model->visible_icon_count();
+  int original_visible = original_model->GetVisibleIconCount();
+  if (original_visible == -1)
+    original_visible = original_model->toolbar_items_.size();
 
   // In incognito mode, we show only those extensions that are
   // incognito-enabled. Further, any actions that were overflowed in regular
   // mode are still overflowed. Order is the same as in regular mode.
   visible_icon_count_ = 0;
   for (ExtensionList::const_iterator iter =
            original_model->toolbar_items_.begin();
        iter != original_model->toolbar_items_.end(); ++iter) {
     if (ShouldAddExtension(iter->get())) {
       toolbar_items_.push_back(*iter);
@@ skipping 76 matching lines @@
   if (last_known_positions_.size() > pref_position_size) {
     // Need to update pref because we have extra icons. But can't call
     // UpdatePrefs() directly within observation closure.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ExtensionToolbarModel::UpdatePrefs,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
-size_t ExtensionToolbarModel::GetVisibleIconCountForTab(
-    content::WebContents* web_contents) const {
-  if (all_icons_visible())
-    return visible_icon_count();  // Already displaying all actions.
-
-  ExtensionActionAPI* extension_action_api = ExtensionActionAPI::Get(profile_);
-  size_t total_icons = visible_icon_count_;
-  for (size_t i = total_icons; i < toolbar_items_.size(); ++i) {
-    if (extension_action_api->ExtensionWantsToRun(toolbar_items_[i].get(),
-                                                  web_contents))
-      ++total_icons;
-  }
-  return total_icons;
-}
-
-ExtensionList ExtensionToolbarModel::GetItemOrderForTab(
-    content::WebContents* web_contents) const {
-  // If we're highlighting, the items are always the same.
-  if (is_highlighting_)
-    return highlighted_items_;
-
-  // Start by initializing the array to be the same as toolbar items (this isn't
-  // any more expensive than initializing it to be of the same size with all
-  // nulls, and saves us time at the end).
-  ExtensionList result = toolbar_items_;
-  if (toolbar_items_.empty())
-    return result;
-
-  ExtensionList overflowed_actions_wanting_to_run;
-  ExtensionActionAPI* extension_action_api = ExtensionActionAPI::Get(profile_);
-  size_t boundary = visible_icon_count();
-  // Rotate any actions that want to run to the boundary between visible and
-  // overflowed actions.
-  for (ExtensionList::iterator iter = result.begin() + boundary;
-       iter != result.end(); ++iter) {
-    if (extension_action_api->ExtensionWantsToRun(iter->get(), web_contents)) {
-      std::rotate(result.begin() + boundary, iter, iter + 1);
-      ++boundary;
-    }
-  }
-  return result;
-}
-
 bool ExtensionToolbarModel::ShowExtensionActionPopup(
     const Extension* extension,
     Browser* browser,
     bool grant_active_tab) {
   ObserverListBase<Observer>::Iterator it(observers_);
   Observer* obs = NULL;
   // Look for the Observer associated with the browser.
   // This would be cleaner if we had an abstract class for the Toolbar UI
   // (like we do for LocationBar), but sadly, we don't.
   while ((obs = it.GetNext()) != NULL) {
@@ skipping 70 matching lines @@
   if (is_highlighting_) {
     highlighted_items_.clear();
     is_highlighting_ = false;
     if (old_visible_icon_count_ != visible_icon_count_)
       SetVisibleIconCount(old_visible_icon_count_);
     FOR_EACH_OBSERVER(Observer, observers_, ToolbarHighlightModeChanged(false));
   }
 }
 
 }  // namespace extensions