MenuItemView: use disabled text color for subtitles too

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 <stddef.h>
 
 #include "base/i18n/case_conversion.h"
 #include "base/macros.h"
@@ skipping 735 matching lines @@
 }
 
 void MenuItemView::PaintButton(gfx::Canvas* canvas, PaintButtonMode mode) {
   const MenuConfig& config = MenuConfig::instance();
   bool render_selection =
       (mode == PB_NORMAL && IsSelected() &&
        parent_menu_item_->GetSubmenu()->GetShowSelection(this) &&
        (NonIconChildViewsCount() == 0));
 
   MenuDelegate *delegate = GetDelegate();
+  bool emphasized =
+      delegate && delegate->GetShouldUseNormalForegroundColor(GetCommand());
   // 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();
   if (render_selection) {
     gfx::Rect item_bounds(0, 0, width(), height());
     AdjustBoundsForRTLUI(&item_bounds);
 
     native_theme->Paint(canvas->sk_canvas(),
                         ui::NativeTheme::kMenuItemBackground,
                         ui::NativeTheme::kHovered,
                         item_bounds,
                         ui::NativeTheme::ExtraParams());
   }
 
   const int icon_x = config.item_left_margin + left_icon_margin_;
   const int top_margin = GetTopMargin();
   const int bottom_margin = GetBottomMargin();
   const int available_height = height() - top_margin - bottom_margin;
 
   // Calculate some colors.
-  ui::NativeTheme::ColorId color_id;
-  if (enabled()) {
-    color_id = render_selection ?
-        ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor:
-        ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor;
-  } else {
-    bool emphasized =
-        delegate && delegate->GetShouldUseNormalForegroundColor(GetCommand());
-    color_id = emphasized
-                   ? ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor
-                   : ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor;
-  }
-  SkColor fg_color = native_theme->GetSystemColor(color_id);
+  SkColor fg_color = GetTextColor(false, render_selection, emphasized);
   SkColor icon_color = color_utils::DeriveDefaultIconColor(fg_color);
 
   // Render the check.
   if (type_ == CHECKBOX && delegate->IsItemChecked(GetCommand())) {
     gfx::ImageSkia check = GetMenuCheckImage(icon_color);
     // Don't use config.check_width here as it's padded
     // to force more padding (AURA).
     gfx::Rect check_bounds(icon_x,
                            top_margin + (available_height - check.height()) / 2,
                            check.width(),
@@ skipping 32 matching lines @@
   if (!subtitle_.empty()) {
     canvas->DrawStringRectWithFlags(
         subtitle_,
         font_list,
         GetNativeTheme()->GetSystemColor(
             ui::NativeTheme::kColorId_MenuItemSubtitleColor),
         text_bounds + gfx::Vector2d(0, font_list.GetHeight()),
         flags);
   }
 
-  PaintMinorText(canvas, render_selection);
+  PaintMinorText(canvas, GetTextColor(true, render_selection, emphasized));
 
   // Render the submenu indicator (arrow).
   if (HasSubmenu()) {
     gfx::ImageSkia arrow = GetSubmenuArrowImage(icon_color);
     gfx::Rect arrow_bounds(this->width() - config.arrow_width -
                                config.arrow_to_edge_padding,
                            top_margin + (available_height - arrow.height()) / 2,
                            config.arrow_width,
                            arrow.height());
     AdjustBoundsForRTLUI(&arrow_bounds);
     canvas->DrawImageInt(arrow, arrow_bounds.x(), arrow_bounds.y());
   }
 }
 
-void MenuItemView::PaintMinorText(gfx::Canvas* canvas,
-                                  bool render_selection) {
+void MenuItemView::PaintMinorText(gfx::Canvas* canvas, SkColor color) {
   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 = 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
     flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
-  canvas->DrawStringRectWithFlags(
-      minor_text,
-      GetFontList(),
-      GetNativeTheme()->GetSystemColor(render_selection ?
-          ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor :
-          ui::NativeTheme::kColorId_MenuItemSubtitleColor),
-      accel_bounds,
-      flags);
+  canvas->DrawStringRectWithFlags(minor_text, GetFontList(), color,
+                                  accel_bounds, flags);
+}
+
+SkColor MenuItemView::GetTextColor(bool minor,
+                                   bool render_selection,
+                                   bool emphasized) const {
+  ui::NativeTheme::ColorId color_id =
+      minor ? ui::NativeTheme::kColorId_MenuItemSubtitleColor
+            : ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor;
+  if (enabled()) {
+    if (render_selection)
+      color_id = ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor;
+  } else {
+    if (!emphasized)
+      color_id = ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor;
+  }
+  return GetNativeTheme()->GetSystemColor(color_id);
 }
 
 void MenuItemView::DestroyAllMenuHosts() {
   if (!HasSubmenu())
     return;
 
   submenu_->Close();
   for (int i = 0, item_count = submenu_->GetMenuItemCount(); i < item_count;
        ++i) {
     submenu_->GetMenuItemAt(i)->DestroyAllMenuHosts();
@@ skipping 171 matching lines @@
     } else {
       const Type& type = menu_item->GetType();
       if (type == CHECKBOX || type == RADIO)
         return true;
     }
   }
   return false;
 }
 
 }  // namespace views