Dynamically calculate the number of extension icons to show per row in overflow

ui/views/controls/menu/submenu_view.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 "ui/views/controls/menu/submenu_view.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "ui/accessibility/ax_view_state.h"
@@ skipping 96 matching lines @@
     new_y = 0;
   SetBounds(x(), new_y, parent()->width(), pref_height);
 
   gfx::Insets insets = GetInsets();
   int x = insets.left();
   int y = insets.top();
   int menu_item_width = width() - insets.width();
   for (int i = 0; i < child_count(); ++i) {
     View* child = child_at(i);
     if (child->visible()) {
       gfx::Size child_pref_size = child->GetPreferredSize();

[sky, 2014/09/15 16:21:24]

Is this the bug you're working around? Now that we're using GetHeightForWidth
for sizing we need to use GetHeightForWidth for layout too.

[Devlin, 2014/09/15 16:57:55]

Yeah, if we change this to GetHeightForWidth(), it should work.  My only
hesitance in doing that was that then calling GetPreferredSize() on the
MenuItemView containing a view like the action overflow is kind of misleading. 
But no more so, I suppose, than invalidating dimensions as part of finding the
height for a width.  So changed.

       child->SetBounds(x, y, menu_item_width, child_pref_size.height());
       y += child_pref_size.height();
     }
   }
 }
 
 gfx::Size SubmenuView::GetPreferredSize() const {
   if (!has_children())
     return gfx::Size();
 
   max_minor_text_width_ = 0;
   // The maximum width of items which contain maybe a label and multiple views.
   int max_complex_width = 0;
   // The max. width of items which contain a label and maybe an accelerator.
   int max_simple_width = 0;
-  int height = 0;
+
+  // We perform the size calculation in two passes. In the first pass, we
+  // calculate the width of the menu. In the second, we calculate the height
+  // using that width. This allows views that have flexible widths to adjust
+  // accordingly.
   for (int i = 0; i < child_count(); ++i) {
     const View* child = child_at(i);
     if (!child->visible())
       continue;
     if (child->id() == MenuItemView::kMenuItemViewID) {
       const MenuItemView* menu = static_cast<const MenuItemView*>(child);
       const MenuItemView::MenuItemDimensions& dimensions =
           menu->GetDimensions();
       max_simple_width = std::max(
           max_simple_width, dimensions.standard_width);
       max_minor_text_width_ =
           std::max(max_minor_text_width_, dimensions.minor_text_width);
       max_complex_width = std::max(max_complex_width,
           dimensions.standard_width + dimensions.children_width);
-      height += dimensions.height;
     } else {
-      gfx::Size child_pref_size =
-          child->visible() ? child->GetPreferredSize() : gfx::Size();
-      max_complex_width = std::max(max_complex_width, child_pref_size.width());
-      height += child_pref_size.height();
+      max_complex_width = std::max(max_complex_width,
+                                   child->GetPreferredSize().width());
     }
   }
   if (max_minor_text_width_ > 0) {
     max_minor_text_width_ +=
         GetMenuItem()->GetMenuConfig().label_to_minor_text_padding;
   }
+  // Finish calculating our optimum width.
   gfx::Insets insets = GetInsets();
-  return gfx::Size(
-      std::max(max_complex_width,
-               std::max(max_simple_width + max_minor_text_width_ +
-                        insets.width(),
-               minimum_preferred_width_ - 2 * insets.width())),
-      height + insets.height());
+  int width = std::max(max_complex_width,
+                       std::max(max_simple_width + max_minor_text_width_ +
+                                    insets.width(),
+                                minimum_preferred_width_ - 2 * insets.width()));
+
+  // Then, the height for that width.
+  int height = 0;
+  for (int i = 0; i < child_count(); ++i) {
+    const View* child = child_at(i);
+    height += child->visible() ? child->GetHeightForWidth(width) : 0;
+  }
+
+  return gfx::Size(width, height + insets.height());
 }
 
 void SubmenuView::GetAccessibleState(ui::AXViewState* state) {
   // Inherit most of the state from the parent menu item, except the role.
   if (GetMenuItem())
     GetMenuItem()->GetAccessibleState(state);
   state->role = ui::AX_ROLE_MENU_LIST_POPUP;
 }
 
 ui::TextInputClient* SubmenuView::GetTextInputClient() {
@@ skipping 315 matching lines @@
   y = std::max(y, 0);
   gfx::Rect new_vis_bounds(x, y, vis_bounds.width(), vis_bounds.height());
   if (new_vis_bounds != vis_bounds) {
     ScrollRectToVisible(new_vis_bounds);
     return true;
   }
   return false;
 }
 
 }  // namespace views