Fix text color of WrenchMenu buttons on Linux Aura.

chrome/browser/ui/views/toolbar/wrench_menu.cc

 // Copyright 2013 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/ui/views/toolbar/wrench_menu.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 
@@ skipping 348 matching lines @@
 
   // Overridden from views::View.
   virtual void SchedulePaintInRect(const gfx::Rect& r) OVERRIDE {
     // Normally when the mouse enters/exits a button the buttons invokes
     // SchedulePaint. As part of the button border (MenuButtonBackground) is
     // rendered by the button to the left/right of it SchedulePaint on the the
     // button may not be enough, so this forces a paint all.
     View::SchedulePaintInRect(gfx::Rect(size()));
   }
 
-  LabelButton* CreateAndConfigureButton(const ui::NativeTheme* native_theme,
-                                        int string_id,
+  virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) OVERRIDE {
+    views::View::OnNativeThemeChanged(theme);
+    for (int i = 0; i < child_count(); ++i) {
+      if (child_at(i)->GetClassName() == views::LabelButton::kViewClassName) {
+        UpdateButtonWithNativeTheme(
+            static_cast<views::LabelButton*>(child_at(i)), theme);
+      }
+    }
+  }
+
+  LabelButton* CreateAndConfigureButton(int string_id,
                                         MenuButtonBackground::ButtonType type,
                                         int index,
                                         MenuButtonBackground** background) {
-    return CreateButtonWithAccName(
-        native_theme, string_id, type, index, background, string_id);
+    return
+        CreateButtonWithAccName(string_id, type, index, background, string_id);
   }
 
-  LabelButton* CreateButtonWithAccName(const ui::NativeTheme* native_theme,
-                                       int string_id,
+  LabelButton* CreateButtonWithAccName(int string_id,
                                        MenuButtonBackground::ButtonType type,
                                        int index,
                                        MenuButtonBackground** background,
                                        int acc_string_id) {
     // Should only be invoked during construction when |menu_| is valid.
     DCHECK(menu_);
     LabelButton* button = new LabelButton(this, gfx::RemoveAcceleratorChar(
         l10n_util::GetStringUTF16(string_id), '&', NULL, NULL));
     button->SetAccessibleName(
         GetAccessibleNameForWrenchMenuItem(menu_model_, index, acc_string_id));
     button->SetFocusable(true);
     button->set_request_focus_on_press(false);
     button->set_tag(index);
     button->SetEnabled(menu_model_->IsEnabledAt(index));
     MenuButtonBackground* bg =
         new MenuButtonBackground(type, menu_->use_new_menu());
     button->set_background(bg);
-    const MenuConfig& menu_config = menu_->GetMenuConfig();
     if (background)
       *background = bg;
-    button->SetBorder(scoped_ptr<views::Border>(
-        new MenuButtonBorder(menu_config, menu_->use_new_menu())));
     button->SetHorizontalAlignment(gfx::ALIGN_CENTER);
-    button->SetFontList(menu_config.font_list);
-    button->SetTextColor(
-        views::Button::STATE_DISABLED,
-        native_theme->GetSystemColor(
-            ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor));
-    button->SetTextColor(
-        views::Button::STATE_HOVERED,
-        native_theme->GetSystemColor(
-            ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor));
-    button->SetTextColor(
-        views::Button::STATE_PRESSED,
-        native_theme->GetSystemColor(
-            ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor));
-    button->SetTextColor(
-        views::Button::STATE_NORMAL,
-        native_theme->GetSystemColor(
-            ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor));
     AddChildView(button);
     // all buttons on menu should must be a custom button in order for
     // the keyboard nativigation work.
     DCHECK(CustomButton::AsCustomButton(button));
+    UpdateButtonWithNativeTheme(button, NULL);
     return button;
   }
 
   // Overridden from WrenchMenuObserver:
   virtual void WrenchMenuDestroyed() OVERRIDE {
     menu_->RemoveObserver(this);
     menu_ = NULL;
     menu_model_ = NULL;
   }
 
  protected:
   WrenchMenu* menu() { return menu_; }
   MenuModel* menu_model() { return menu_model_; }
 
  private:
+  void UpdateButtonWithNativeTheme(views::LabelButton* button,
+                                   const ui::NativeTheme* native_theme) {
+    if (native_theme) {
+      button->SetTextColor(
+          views::Button::STATE_DISABLED,
+          native_theme->GetSystemColor(
+              ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor));
+      button->SetTextColor(
+          views::Button::STATE_HOVERED,
+          native_theme->GetSystemColor(
+              ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor));
+      button->SetTextColor(
+          views::Button::STATE_PRESSED,
+          native_theme->GetSystemColor(
+              ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor));
+      button->SetTextColor(
+          views::Button::STATE_NORMAL,
+          native_theme->GetSystemColor(
+              ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor));
+    }
+
+    MenuConfig menu_config(native_theme);
+    button->SetBorder(scoped_ptr<views::Border>(
+        new MenuButtonBorder(menu_config, menu_->use_new_menu())));
+    button->SetFontList(menu_config.font_list);
+  }
+
   // Hosting WrenchMenu.
   // WARNING: this may be NULL during shutdown.
   WrenchMenu* menu_;
 
   // The menu model containing the increment/decrement/reset items.
   // WARNING: this may be NULL during shutdown.
   MenuModel* menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(WrenchMenuView);
 };
@@ skipping 64 matching lines @@
 
 }  // namespace
 
 // CutCopyPasteView ------------------------------------------------------------
 
 // CutCopyPasteView is the view containing the cut/copy/paste buttons.
 class WrenchMenu::CutCopyPasteView : public WrenchMenuView {
  public:
   CutCopyPasteView(WrenchMenu* menu,
                    MenuModel* menu_model,
-                   const ui::NativeTheme* native_theme,
                    int cut_index,
                    int copy_index,
                    int paste_index)
       : WrenchMenuView(menu, menu_model) {
     LabelButton* cut = CreateAndConfigureButton(
-        native_theme, IDS_CUT, MenuButtonBackground::LEFT_BUTTON,
-        cut_index, NULL);
+        IDS_CUT, MenuButtonBackground::LEFT_BUTTON, cut_index, NULL);
     MenuButtonBackground* copy_background = NULL;
     CreateAndConfigureButton(
-        native_theme, IDS_COPY, MenuButtonBackground::CENTER_BUTTON,
+        IDS_COPY, MenuButtonBackground::CENTER_BUTTON,
         copy_index, &copy_background);
     LabelButton* paste = CreateAndConfigureButton(
-        native_theme,
         IDS_PASTE,
         menu->use_new_menu() && menu->supports_new_separators_ ?
             MenuButtonBackground::CENTER_BUTTON :
             MenuButtonBackground::RIGHT_BUTTON,
         paste_index,
         NULL);
     copy_background->SetOtherButtons(cut, paste);
   }
 
   // Overridden from View.
@@ skipping 34 matching lines @@
 static const int kZoomPadding = 6;
 static const int kTouchZoomPadding = 14;
 
 // ZoomView contains the various zoom controls: two buttons to increase/decrease
 // the zoom, a label showing the current zoom percent, and a button to go
 // full-screen.
 class WrenchMenu::ZoomView : public WrenchMenuView {
  public:
   ZoomView(WrenchMenu* menu,
            MenuModel* menu_model,
-           const ui::NativeTheme* native_theme,
            int decrement_index,
            int increment_index,
            int fullscreen_index)
       : WrenchMenuView(menu, menu_model),
         fullscreen_index_(fullscreen_index),
         increment_button_(NULL),
         zoom_label_(NULL),
         decrement_button_(NULL),
         fullscreen_button_(NULL),
         zoom_label_width_(0) {
     zoom_subscription_ = HostZoomMap::GetForBrowserContext(
         menu->browser_->profile())->AddZoomLevelChangedCallback(
             base::Bind(&WrenchMenu::ZoomView::OnZoomLevelChanged,
                        base::Unretained(this)));
 
     decrement_button_ = CreateButtonWithAccName(
-        native_theme, IDS_ZOOM_MINUS2, MenuButtonBackground::LEFT_BUTTON,
+        IDS_ZOOM_MINUS2, MenuButtonBackground::LEFT_BUTTON,
         decrement_index, NULL, IDS_ACCNAME_ZOOM_MINUS2);
 
     zoom_label_ = new Label(
         l10n_util::GetStringFUTF16Int(IDS_ZOOM_PERCENT, 100));
     zoom_label_->SetAutoColorReadabilityEnabled(false);
     zoom_label_->SetHorizontalAlignment(gfx::ALIGN_RIGHT);
 
     MenuButtonBackground* center_bg = new MenuButtonBackground(
         menu->use_new_menu() && menu->supports_new_separators_ ?
             MenuButtonBackground::RIGHT_BUTTON :
             MenuButtonBackground::CENTER_BUTTON,
         menu->use_new_menu());
     zoom_label_->set_background(center_bg);
-    const MenuConfig& menu_config(menu->GetMenuConfig());
-    zoom_label_->SetBorder(scoped_ptr<views::Border>(
-        new MenuButtonBorder(menu_config, menu->use_new_menu())));
-    zoom_label_->SetFontList(menu_config.font_list);
 
     AddChildView(zoom_label_);
-    zoom_label_width_ = MaxWidthForZoomLabel();
 
     increment_button_ = CreateButtonWithAccName(
-        native_theme, IDS_ZOOM_PLUS2, MenuButtonBackground::RIGHT_BUTTON,
+        IDS_ZOOM_PLUS2, MenuButtonBackground::RIGHT_BUTTON,
         increment_index, NULL, IDS_ACCNAME_ZOOM_PLUS2);
 
     center_bg->SetOtherButtons(decrement_button_, increment_button_);
 
     fullscreen_button_ = new FullscreenButton(this);
     // all buttons on menu should must be a custom button in order for
     // the keyboard nativigation work.
     DCHECK(CustomButton::AsCustomButton(fullscreen_button_));
     gfx::ImageSkia* full_screen_image =
         ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
             IDR_FULLSCREEN_MENU_BUTTON);
     fullscreen_button_->SetImage(ImageButton::STATE_NORMAL, full_screen_image);
-    SkColor fg_color = native_theme->GetSystemColor(
-        ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor);
-    gfx::ImageSkia hovered_fullscreen_image(
-        new HoveredImageSource(*full_screen_image, fg_color),
-        full_screen_image->size());
-    fullscreen_button_->SetImage(
-        ImageButton::STATE_HOVERED, &hovered_fullscreen_image);
-    fullscreen_button_->SetImage(
-        ImageButton::STATE_PRESSED, &hovered_fullscreen_image);
-
-    SkColor enabled_text_color = native_theme->GetSystemColor(
-        ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor);
-    zoom_label_->SetEnabledColor(enabled_text_color);
-    decrement_button_->SetTextColor(views::Button::STATE_NORMAL,
-                                    enabled_text_color);
-    increment_button_->SetTextColor(views::Button::STATE_NORMAL,
-                                    enabled_text_color);
-    SkColor disabled_text_color = native_theme->GetSystemColor(
-        ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor);
-    decrement_button_->SetTextColor(views::Button::STATE_DISABLED,
-                                    disabled_text_color);
-    increment_button_->SetTextColor(views::Button::STATE_DISABLED,
-                                    disabled_text_color);
     fullscreen_button_->SetFocusable(true);
     fullscreen_button_->set_request_focus_on_press(false);
     fullscreen_button_->set_tag(fullscreen_index);
     fullscreen_button_->SetImageAlignment(
         ImageButton::ALIGN_CENTER, ImageButton::ALIGN_MIDDLE);
     int horizontal_padding =
         menu->use_new_menu() ? kHorizontalTouchPadding : kHorizontalPadding;
     fullscreen_button_->SetBorder(views::Border::CreateEmptyBorder(
         0, horizontal_padding, 0, horizontal_padding));
     fullscreen_button_->set_background(
         new MenuButtonBackground(MenuButtonBackground::SINGLE_BUTTON,
                                  menu->use_new_menu()));
     fullscreen_button_->SetAccessibleName(
         GetAccessibleNameForWrenchMenuItem(
             menu_model, fullscreen_index, IDS_ACCNAME_FULLSCREEN));
     AddChildView(fullscreen_button_);
 
+    OnNativeThemeChanged(NULL);
     UpdateZoomControls();
   }
 
   virtual ~ZoomView() {}
 
   // Overridden from View.
   virtual gfx::Size GetPreferredSize() OVERRIDE {
     // The increment/decrement button are forced to the same width.
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
@@ skipping 26 matching lines @@
     bounds.set_width(button_width);
     increment_button_->SetBoundsRect(bounds);
 
     x += bounds.width() + (menu()->use_new_menu() ? 0 : kZoomPadding);
     bounds.set_x(x);
     bounds.set_width(fullscreen_button_->GetPreferredSize().width() +
                      (menu()->use_new_menu() ? kTouchZoomPadding : 0));
     fullscreen_button_->SetBoundsRect(bounds);
   }
 
+  virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) OVERRIDE {
+    WrenchMenuView::OnNativeThemeChanged(theme);
+
+    MenuConfig menu_config(theme);
+    zoom_label_->SetBorder(scoped_ptr<views::Border>(
+        new MenuButtonBorder(menu_config, menu()->use_new_menu())));
+    zoom_label_->SetFontList(menu_config.font_list);
+    zoom_label_width_ = MaxWidthForZoomLabel();
+
+    if (theme) {
+      zoom_label_->SetEnabledColor(theme->GetSystemColor(
+          ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor));
+      gfx::ImageSkia* full_screen_image =
+          ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+               IDR_FULLSCREEN_MENU_BUTTON);
+      SkColor fg_color = theme->GetSystemColor(
+          ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor);
+      gfx::ImageSkia hovered_fullscreen_image(
+          new HoveredImageSource(*full_screen_image, fg_color),
+          full_screen_image->size());
+      fullscreen_button_->SetImage(
+          ImageButton::STATE_HOVERED, &hovered_fullscreen_image);
+      fullscreen_button_->SetImage(
+          ImageButton::STATE_PRESSED, &hovered_fullscreen_image);
+    }
+  }
+
   // Overridden from ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE {
     if (sender->tag() == fullscreen_index_) {
       menu()->CancelAndEvaluate(menu_model(), sender->tag());
     } else {
       // Zoom buttons don't close the menu.
       menu_model()->ActivatedAt(sender->tag());
     }
   }
@@ skipping 224 matching lines @@
       model->RemoveObserver(this);
   }
   if (selected_menu_model_)
     selected_menu_model_->ActivatedAt(selected_index_);
 }
 
 bool WrenchMenu::IsShowing() {
   return menu_runner_.get() && menu_runner_->IsRunning();
 }
 
-const ui::NativeTheme* WrenchMenu::GetNativeTheme() const {
-  views::Widget* browser_widget = views::Widget::GetWidgetForNativeView(
-      browser_->window()->GetNativeWindow());
-  DCHECK(browser_widget);
-  return browser_widget->GetNativeTheme();
-}
-
-const views::MenuConfig& WrenchMenu::GetMenuConfig() const {
-  return MenuConfig::instance(GetNativeTheme());
-}
-
 void WrenchMenu::AddObserver(WrenchMenuObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void WrenchMenu::RemoveObserver(WrenchMenuObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 const gfx::FontList* WrenchMenu::GetLabelFontList(int command_id) const {
   if (IsRecentTabsCommand(command_id)) {
@@ skipping 223 matching lines @@
 
     // Add the menu item at the end.
     int menu_index = parent->HasSubmenu() ?
         parent->GetSubmenu()->child_count() : 0;
     MenuItemView* item = AddMenuItem(
         parent, menu_index, model, i, model->GetTypeAt(i), height);
 
     if (model->GetTypeAt(i) == MenuModel::TYPE_SUBMENU)
       PopulateMenu(item, model->GetSubmenuModelAt(i));
 
-    const ui::NativeTheme* native_theme = GetNativeTheme();
-
     switch (model->GetCommandIdAt(i)) {
       case IDC_CUT:
         DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(i));
         DCHECK_LT(i + 2, max);
         DCHECK_EQ(IDC_COPY, model->GetCommandIdAt(i + 1));
         DCHECK_EQ(IDC_PASTE, model->GetCommandIdAt(i + 2));
         item->SetTitle(l10n_util::GetStringUTF16(IDS_EDIT2));
-        item->AddChildView(new CutCopyPasteView(this, model, native_theme,
+        item->AddChildView(new CutCopyPasteView(this, model,
                                                 i, i + 1, i + 2));
         i += 2;
         break;
 
       case IDC_ZOOM_MINUS:
         DCHECK_EQ(MenuModel::TYPE_COMMAND, model->GetTypeAt(i));
         DCHECK_EQ(IDC_ZOOM_PLUS, model->GetCommandIdAt(i + 1));
         DCHECK_EQ(IDC_FULLSCREEN, model->GetCommandIdAt(i + 2));
         item->SetTitle(l10n_util::GetStringUTF16(IDS_ZOOM_MENU2));
-        item->AddChildView(new ZoomView(this, model, native_theme,
-                                        i, i + 1, i + 2));
+        item->AddChildView(new ZoomView(this, model, i, i + 1, i + 2));
         i += 2;
         break;
 
       case IDC_BOOKMARKS_MENU:
         DCHECK(!bookmark_menu_);
         bookmark_menu_ = item;
         break;
 
 #if defined(GOOGLE_CHROME_BUILD)
       case IDC_FEEDBACK:
@@ skipping 97 matching lines @@
                                 0,
                                 BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
                                 BOOKMARK_LAUNCH_LOCATION_WRENCH_MENU);
 }
 
 int WrenchMenu::ModelIndexFromCommandId(int command_id) const {
   CommandIDToEntry::const_iterator ix = command_id_to_entry_.find(command_id);
   DCHECK(ix != command_id_to_entry_.end());
   return ix->second.second;
 }