Refactor: Makes menus use gfx::FontList instead of gfx::Font.

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 "grit/ui_resources.h"
 #include "grit/ui_strings.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/image/image.h"
+#include "ui/gfx/text_utils.h"
 #include "ui/native_theme/common_theme.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/menu/menu_config.h"
 #include "ui/views/controls/menu/menu_controller.h"
 #include "ui/views/controls/menu/menu_image_util.h"
 #include "ui/views/controls/menu/menu_scroll_view_container.h"
 #include "ui/views/controls/menu/menu_separator.h"
 #include "ui/views/controls/menu/submenu_view.h"
 #include "ui/views/widget/widget.h"
@@ skipping 651 matching lines @@
   if (GetRootMenuItem()->has_mnemonics_) {
     if (GetMenuConfig().show_mnemonics || GetRootMenuItem()->show_mnemonics_) {
       flags |= gfx::Canvas::SHOW_PREFIX;
     } else {
       flags |= gfx::Canvas::HIDE_PREFIX;
     }
   }
   return flags;
 }
 
-const gfx::Font& MenuItemView::GetFont() {
+const gfx::FontList& MenuItemView::GetFontList() {
   const MenuDelegate* delegate = GetDelegate();
   if (delegate) {
-    const gfx::Font* font = delegate->GetLabelFont(GetCommand());
-    if (font)
-      return *font;
+    const gfx::FontList* font_list = delegate->GetLabelFontList(GetCommand());
+    if (font_list)
+      return *font_list;
   }
-  return GetMenuConfig().font;
+  return GetMenuConfig().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 89 matching lines @@
         ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor:
         ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor;
   }
   SkColor fg_color = native_theme->GetSystemColor(color_id);
   SkColor override_foreground_color;
   if (delegate && delegate->GetForegroundColor(GetCommand(),
                                                render_selection,
                                                &override_foreground_color))
     fg_color = override_foreground_color;
 
-  const gfx::Font& font = GetFont();
+  const gfx::FontList& font_list = GetFontList();
   int accel_width = parent_menu_item_->GetSubmenu()->max_minor_text_width();
   int label_start = GetLabelStartForThisItem();
 
   int width = this->width() - label_start - accel_width -
       (!delegate ||
        delegate->ShouldReserveSpaceForSubmenuIndicator() ?
            item_right_margin_ : config.arrow_to_edge_padding);
   gfx::Rect text_bounds(label_start, top_margin, width,
                         subtitle_.empty() ? available_height
                                           : available_height / 2);
   text_bounds.set_x(GetMirroredXForRect(text_bounds));
   int flags = GetDrawStringFlags();
   if (mode == PB_FOR_DRAG)
     flags |= gfx::Canvas::NO_SUBPIXEL_RENDERING;
-  canvas->DrawStringInt(title(), font, fg_color,
-                        text_bounds.x(), text_bounds.y(), text_bounds.width(),
-                        text_bounds.height(), flags);
+  canvas->DrawStringRectWithFlags(title(), font_list, fg_color, text_bounds,
+                                  flags);
   if (!subtitle_.empty()) {
-    canvas->DrawStringInt(
+    canvas->DrawStringRectWithFlags(
         subtitle_,
-        font,
+        font_list,
         GetNativeTheme()->GetSystemColor(
             ui::NativeTheme::kColorId_ButtonDisabledColor),
-        text_bounds.x(),
-        text_bounds.y() + GetFont().GetHeight(),
-        text_bounds.width(),
-        text_bounds.height(),
+        text_bounds + gfx::Vector2d(0, font_list.GetHeight()),
         flags);
   }
 
   PaintMinorText(canvas, render_selection);
 
   // Render the submenu indicator (arrow).
   if (HasSubmenu()) {
     gfx::Rect arrow_bounds(this->width() - config.arrow_width -
                                config.arrow_to_edge_padding,
                            top_margin + (available_height -
                                          config.arrow_width) / 2,
                            config.arrow_width, height());
     AdjustBoundsForRTLUI(&arrow_bounds);
     canvas->DrawImageInt(GetSubmenuArrowImage(IsSelected()),
                          arrow_bounds.x(), arrow_bounds.y());
   }
 }
 
 void MenuItemView::PaintMinorText(gfx::Canvas* canvas,
                                   bool render_selection) {
   base::string16 minor_text = GetMinorText();
   if (minor_text.empty())
     return;
 
-  const gfx::Font& font = GetFont();
   int available_height = height() - GetTopMargin() - GetBottomMargin();
   int max_accel_width =
       parent_menu_item_->GetSubmenu()->max_minor_text_width();
   const MenuConfig& config = GetMenuConfig();
   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
     flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
-  canvas->DrawStringInt(
+  canvas->DrawStringRectWithFlags(
       minor_text,
-      font,
+      GetFontList(),
       GetNativeTheme()->GetSystemColor(render_selection ?
           ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor :
           ui::NativeTheme::kColorId_ButtonDisabledColor),
-      accel_bounds.x(),
-      accel_bounds.y(),
-      accel_bounds.width(),
-      accel_bounds.height(),
+      accel_bounds,
       flags);
 }
 
 void MenuItemView::DestroyAllMenuHosts() {
   if (!HasSubmenu())
     return;
 
   submenu_->Close();
   for (int i = 0, item_count = submenu_->GetMenuItemCount(); i < item_count;
        ++i) {
@@ skipping 61 matching lines @@
     dimensions.height = std::max(dimensions.height,
                                  GetMenuConfig().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::Font& font = GetFont();
+  const gfx::FontList& font_list = GetFontList();
 
   // Get Icon margin overrides for this particular item.
   const MenuDelegate* delegate = GetDelegate();
   if (delegate) {
     delegate->GetHorizontalIconMargins(command_,
                                        icon_area_width_,
                                        &left_icon_margin_,
                                        &right_icon_margin_);
   } else {
     left_icon_margin_ = 0;
     right_icon_margin_ = 0;
   }
   int label_start = GetLabelStartForThisItem();
 
-  int string_width = font.GetStringWidth(title_);
-  if (!subtitle_.empty())
-    string_width = std::max(string_width, font.GetStringWidth(subtitle_));
+  int string_width = gfx::GetStringWidth(title_, font_list);
+  if (!subtitle_.empty()) {
+    string_width = std::max(string_width,
+                            gfx::GetStringWidth(subtitle_, font_list));
+  }
 
   dimensions.standard_width = string_width + label_start +
       item_right_margin_;
   // Determine the length of the right-side text.
   base::string16 minor_text = GetMinorText();
   dimensions.minor_text_width =
-      minor_text.empty() ? 0 : GetFont().GetStringWidth(minor_text);
+      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,
-      (subtitle_.empty() ? 0 : font.GetHeight()) +
-      font.GetHeight() + GetBottomMargin() + GetTopMargin());
-  dimensions.height = std::max(dimensions.height,
-      GetMenuConfig().item_min_height);
+                               GetMenuConfig().item_min_height);
   return dimensions;
 }
 
 int MenuItemView::GetLabelStartForThisItem() {
   int label_start = label_start_ + left_icon_margin_ + right_icon_margin_;
   if ((type_ == CHECKBOX || type_ == RADIO) && icon_view_) {
     label_start += icon_view_->size().width() +
         GetMenuConfig().icon_to_label_padding;
   }
   return label_start;
@@ skipping 55 matching lines @@
     } else {
       const Type& type = menu_item->GetType();
       if (type == CHECKBOX || type == RADIO)
         return true;
     }
   }
   return false;
 }
 
 }  // namespace views