Use a single views::MenuConfig instance for each platform

ui/views/controls/menu/menu_item_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/menu_item_view.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_view_state.h"
@@ skipping 222 matching lines @@
     const base::string16& minor_text,
     const gfx::ImageSkia& icon,
     Type type,
     ui::MenuSeparatorType separator_style) {
   DCHECK_NE(type, EMPTY);
   DCHECK_LE(0, index);
   if (!submenu_)
     CreateSubmenu();
   DCHECK_GE(submenu_->child_count(), index);
   if (type == SEPARATOR) {
-    submenu_->AddChildViewAt(new MenuSeparator(this, separator_style), index);
+    submenu_->AddChildViewAt(new MenuSeparator(separator_style), index);
     return NULL;
   }
   MenuItemView* item = new MenuItemView(this, item_id, type);
   if (label.empty() && GetDelegate())
     item->SetTitle(GetDelegate()->GetLabel(item_id));
   else
     item->SetTitle(label);
   item->SetSubtitle(sublabel);
   item->SetMinorText(minor_text);
   if (!icon.isNull())
@@ skipping 157 matching lines @@
                    dimensions.height);
 }
 
 int MenuItemView::GetHeightForWidth(int width) const {
   // If this isn't a container, we can just use the preferred size's height.
   if (!IsContainer())
     return GetPreferredSize().height();
 
   int height = child_at(0)->GetHeightForWidth(width);
   if (!icon_view_ && GetRootMenuItem()->has_icons())
-    height = std::max(height, GetMenuConfig().check_height);
+    height = std::max(height, MenuConfig::instance().check_height);
   height += GetBottomMargin() + GetTopMargin();
 
   return height;
 }
 
 const MenuItemView::MenuItemDimensions& MenuItemView::GetDimensions() const {
   if (!is_dimensions_valid())
     dimensions_ = CalculateDimensions();
   DCHECK(is_dimensions_valid());
   return dimensions_;
@@ skipping 106 matching lines @@
     int x = width() - (use_right_margin_ ? item_right_margin_ : 0);
     for (int i = child_count() - 1; i >= 0; --i) {
       View* child = child_at(i);
       if (icon_view_ && (icon_view_ == child))
         continue;
       int width = child->GetPreferredSize().width();
       child->SetBounds(x - width, 0, width, height());
       x -= width - kChildXPadding;
     }
     // Position |icon_view|.
-    const MenuConfig& config = GetMenuConfig();
+    const MenuConfig& config = MenuConfig::instance();
     if (icon_view_) {
       icon_view_->SizeToPreferredSize();
       gfx::Size size = icon_view_->GetPreferredSize();
       int x = config.item_left_margin + left_icon_margin_ +
               (icon_area_width_ - size.width()) / 2;
       if (config.icons_in_label || type_ == CHECKBOX || type_ == RADIO)
         x = label_start_;
       int y =
           (height() + GetTopMargin() - GetBottomMargin() - size.height()) / 2;
       icon_view_->SetPosition(gfx::Point(x, y));
     }
   }
 }
 
 void MenuItemView::SetMargins(int top_margin, int bottom_margin) {
   top_margin_ = top_margin;
   bottom_margin_ = bottom_margin;
 
   invalidate_dimensions();
 }
 
-const MenuConfig& MenuItemView::GetMenuConfig() const {
-  return MenuConfig::instance(GetNativeTheme());
-}
-
 MenuItemView::MenuItemView(MenuItemView* parent,
                            int command,
                            MenuItemView::Type type)
     : delegate_(NULL),
       controller_(NULL),
       canceled_(false),
       parent_menu_item_(parent),
       type_(type),
       selected_(false),
       command_(command),
@@ skipping 18 matching lines @@
 }
 
 const char* MenuItemView::GetClassName() const {
   return kViewClassName;
 }
 
 // Calculates all sizes that we can from the OS.
 //
 // This is invoked prior to Running a menu.
 void MenuItemView::UpdateMenuPartSizes() {
-  const MenuConfig& config = GetMenuConfig();
+  const MenuConfig& config = MenuConfig::instance();
 
   item_right_margin_ = config.label_to_arrow_padding + config.arrow_width +
                        config.arrow_to_edge_padding;
   icon_area_width_ = config.check_width;
   if (has_icons_)
     icon_area_width_ = std::max(icon_area_width_, GetMaxIconViewWidth());
 
   label_start_ = config.item_left_margin + icon_area_width_;
   int padding = 0;
   if (config.always_use_icon_to_label_padding) {
@@ skipping 57 matching lines @@
 }
 
 int MenuItemView::GetDrawStringFlags() {
   int flags = 0;
   if (base::i18n::IsRTL())
     flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
   else
     flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
 
   if (GetRootMenuItem()->has_mnemonics_) {
-    if (GetMenuConfig().show_mnemonics || GetRootMenuItem()->show_mnemonics_) {
+    if (MenuConfig::instance().show_mnemonics ||
+        GetRootMenuItem()->show_mnemonics_) {
       flags |= gfx::Canvas::SHOW_PREFIX;
     } else {
       flags |= gfx::Canvas::HIDE_PREFIX;
     }
   }
   return flags;
 }
 
 const gfx::FontList& MenuItemView::GetFontList() const {
   const MenuDelegate* delegate = GetDelegate();
   if (delegate) {
     const gfx::FontList* font_list = delegate->GetLabelFontList(GetCommand());
     if (font_list)
       return *font_list;
   }
-  return GetMenuConfig().font_list;
+  return MenuConfig::instance().font_list;
 }
 
 void MenuItemView::AddEmptyMenus() {
   DCHECK(HasSubmenu());
   if (!submenu_->has_children()) {
     submenu_->AddChildViewAt(new EmptyMenuMenuItem(this), 0);
   } else {
     for (int i = 0, item_count = submenu_->GetMenuItemCount(); i < item_count;
          ++i) {
       MenuItemView* child = submenu_->GetMenuItemAt(i);
@@ skipping 19 matching lines @@
       child = NULL;
     }
   }
 }
 
 void MenuItemView::AdjustBoundsForRTLUI(gfx::Rect* rect) const {
   rect->set_x(GetMirroredXForRect(*rect));
 }
 
 void MenuItemView::PaintButton(gfx::Canvas* canvas, PaintButtonMode mode) {
-  const MenuConfig& config = GetMenuConfig();
+  const MenuConfig& config = MenuConfig::instance();
   bool render_selection =
       (mode == PB_NORMAL && IsSelected() &&
        parent_menu_item_->GetSubmenu()->GetShowSelection(this) &&
        (NonIconChildViewsCount() == 0));
 
   MenuDelegate *delegate = GetDelegate();
   // Render the background. As MenuScrollViewContainer draws the background, we
   // only need the background when we want it to look different, as when we're
   // selected.
   ui::NativeTheme* native_theme = GetNativeTheme();
@@ skipping 105 matching lines @@
 
 void MenuItemView::PaintMinorText(gfx::Canvas* canvas,
                                   bool render_selection) {
   base::string16 minor_text = GetMinorText();
   if (minor_text.empty())
     return;
 
   int available_height = height() - GetTopMargin() - GetBottomMargin();
   int max_accel_width =
       parent_menu_item_->GetSubmenu()->max_minor_text_width();
-  const MenuConfig& config = GetMenuConfig();
+  const MenuConfig& config = MenuConfig::instance();
   int accel_right_margin = config.align_arrow_and_shortcut ?
                            config.arrow_to_edge_padding :  item_right_margin_;
   gfx::Rect accel_bounds(width() - accel_right_margin - max_accel_width,
                          GetTopMargin(), max_accel_width, available_height);
   accel_bounds.set_x(GetMirroredXForRect(accel_bounds));
   int flags = GetDrawStringFlags();
   flags &= ~(gfx::Canvas::TEXT_ALIGN_RIGHT | gfx::Canvas::TEXT_ALIGN_LEFT);
   if (base::i18n::IsRTL())
     flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
   else
@@ skipping 18 matching lines @@
     submenu_->GetMenuItemAt(i)->DestroyAllMenuHosts();
   }
 }
 
 int MenuItemView::GetTopMargin() const {
   if (top_margin_ >= 0)
     return top_margin_;
 
   const MenuItemView* root = GetRootMenuItem();
   return root && root->has_icons_
-      ? GetMenuConfig().item_top_margin :
-        GetMenuConfig().item_no_icon_top_margin;
+             ? MenuConfig::instance().item_top_margin
+             : MenuConfig::instance().item_no_icon_top_margin;
 }
 
 int MenuItemView::GetBottomMargin() const {
   if (bottom_margin_ >= 0)
     return bottom_margin_;
 
   const MenuItemView* root = GetRootMenuItem();
   return root && root->has_icons_
-      ? GetMenuConfig().item_bottom_margin :
-        GetMenuConfig().item_no_icon_bottom_margin;
+             ? MenuConfig::instance().item_bottom_margin
+             : MenuConfig::instance().item_no_icon_bottom_margin;
 }
 
 gfx::Size MenuItemView::GetChildPreferredSize() const {
   if (!has_children())
     return gfx::Size();
 
   if (IsContainer())
     return child_at(0)->GetPreferredSize();
 
   int width = 0;
@@ skipping 17 matching lines @@
 MenuItemView::MenuItemDimensions MenuItemView::CalculateDimensions() const {
   gfx::Size child_size = GetChildPreferredSize();
 
   MenuItemDimensions dimensions;
   // Get the container height.
   dimensions.children_width = child_size.width();
   dimensions.height = child_size.height();
   // Adjust item content height if menu has both items with and without icons.
   // This way all menu items will have the same height.
   if (!icon_view_ && GetRootMenuItem()->has_icons()) {
-    dimensions.height = std::max(dimensions.height,
-                                 GetMenuConfig().check_height);
+    dimensions.height =
+        std::max(dimensions.height, MenuConfig::instance().check_height);
   }
   dimensions.height += GetBottomMargin() + GetTopMargin();
 
   // In case of a container, only the container size needs to be filled.
   if (IsContainer())
     return dimensions;
 
   // Determine the length of the label text.
   const gfx::FontList& font_list = GetFontList();
 
@@ skipping 21 matching lines @@
   // Determine the length of the right-side text.
   base::string16 minor_text = GetMinorText();
   dimensions.minor_text_width =
       minor_text.empty() ? 0 : gfx::GetStringWidth(minor_text, font_list);
 
   // Determine the height to use.
   dimensions.height =
       std::max(dimensions.height,
                (subtitle_.empty() ? 0 : font_list.GetHeight()) +
                font_list.GetHeight() + GetBottomMargin() + GetTopMargin());
-  dimensions.height = std::max(dimensions.height,
-                               GetMenuConfig().item_min_height);
+  dimensions.height =
+      std::max(dimensions.height, MenuConfig::instance().item_min_height);
   return dimensions;
 }
 
 int MenuItemView::GetLabelStartForThisItem() const {
-  const MenuConfig& config = GetMenuConfig();
+  const MenuConfig& config = MenuConfig::instance();
   int label_start = label_start_ + left_icon_margin_ + right_icon_margin_;
   if ((config.icons_in_label || type_ == CHECKBOX || type_ == RADIO) &&
       icon_view_)
     label_start += icon_view_->size().width() + config.icon_to_label_padding;
 
   return label_start;
 }
 
 base::string16 MenuItemView::GetMinorText() const {
   if (id() == kEmptyMenuItemViewID) {
     // Don't query the delegate for menus that represent no children.
     return base::string16();
   }
 
   ui::Accelerator accelerator;
-  if (GetMenuConfig().show_accelerators && GetDelegate() && GetCommand() &&
-          GetDelegate()->GetAccelerator(GetCommand(), &accelerator)) {
+  if (MenuConfig::instance().show_accelerators && GetDelegate() &&
+      GetCommand() &&
+      GetDelegate()->GetAccelerator(GetCommand(), &accelerator)) {
     return accelerator.GetShortcutText();
   }
 
   return minor_text_;
 }
 
 bool MenuItemView::IsContainer() const {
   // Let the first child take over |this| when we only have one child and no
   // title.
   return (NonIconChildViewsCount() == 1) && title_.empty();
@@ skipping 10 matching lines @@
   for (int i = 0; i < submenu_->GetMenuItemCount(); ++i) {
     MenuItemView* menu_item = submenu_->GetMenuItemAt(i);
     int temp_width = 0;
     if (menu_item->GetType() == CHECKBOX ||
         menu_item->GetType() == RADIO) {
       // If this item has a radio or checkbox, the icon will not affect
       // alignment of other items.
       continue;
     } else if (menu_item->HasSubmenu()) {
       temp_width = menu_item->GetMaxIconViewWidth();
-    } else if (menu_item->icon_view() && !GetMenuConfig().icons_in_label) {
+    } else if (menu_item->icon_view() &&
+               !MenuConfig::instance().icons_in_label) {
       temp_width = menu_item->icon_view()->GetPreferredSize().width();
     }
     width = std::max(width, temp_width);
   }
   return width;
 }
 
 bool MenuItemView::HasChecksOrRadioButtons() const {
   for (int i = 0; i < submenu_->GetMenuItemCount(); ++i) {
     MenuItemView* menu_item = submenu_->GetMenuItemAt(i);
     if (menu_item->HasSubmenu()) {
       if (menu_item->HasChecksOrRadioButtons())
         return true;
     } else {
       const Type& type = menu_item->GetType();
       if (type == CHECKBOX || type == RADIO)
         return true;
     }
   }
   return false;
 }
 
 }  // namespace views