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 94 matching lines @@
       pref.Enlarge(insets.width(), insets.height());
     }
     return pref;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FullscreenButton);
 };
 
 // Border for buttons contained in the menu. This is only used for getting the
-// insets, the actual painting is done in MenuButtonBackground.
+// insets, the actual painting is done in InMenuButtonBackground.
 class MenuButtonBorder : public views::Border {
  public:
   MenuButtonBorder(const MenuConfig& config, bool use_new_menu)
       : horizontal_padding_(use_new_menu ?
                             kHorizontalTouchPadding : kHorizontalPadding),
         insets_(config.item_top_margin, horizontal_padding_,
                 config.item_bottom_margin, horizontal_padding_) {
   }
 
   // Overridden from views::Border.
   virtual void Paint(const View& view, gfx::Canvas* canvas) OVERRIDE {
-    // Painting of border is done in MenuButtonBackground.
+    // Painting of border is done in InMenuButtonBackground.
   }
 
   virtual gfx::Insets GetInsets() const OVERRIDE {
     return insets_;
   }
 
   virtual gfx::Size GetMinimumSize() const OVERRIDE {
-    // This size is sufficient for MenuButtonBackground::Paint() to draw any of
-    // the button types.
+    // This size is sufficient for InMenuButtonBackground::Paint() to draw any
+    // of the button types.
     return gfx::Size(4, 4);
   }
 
  private:
   // The horizontal padding dependent on the layout.
   const int horizontal_padding_;
 
   const gfx::Insets insets_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuButtonBorder);
 };
 
 // Combination border/background for the buttons contained in the menu. The
 // painting of the border/background is done here as TextButton does not always
 // paint the border.
-class MenuButtonBackground : public views::Background {
+class InMenuButtonBackground : public views::Background {
  public:
   enum ButtonType {
     LEFT_BUTTON,
     CENTER_BUTTON,
     RIGHT_BUTTON,
     SINGLE_BUTTON,
   };
 
-  MenuButtonBackground(ButtonType type, bool use_new_menu)
+  InMenuButtonBackground(ButtonType type, bool use_new_menu)
       : type_(type),
         use_new_menu_(use_new_menu),
         left_button_(NULL),
         right_button_(NULL) {}
 
   // Used when the type is CENTER_BUTTON to determine if the left/right edge
   // needs to be rendered selected.
-  void SetOtherButtons(CustomButton* left_button, CustomButton* right_button) {
+  void SetOtherButtons(const CustomButton* left_button,
+                       const CustomButton* right_button) {
     if (base::i18n::IsRTL()) {
       left_button_ = right_button;
       right_button_ = left_button;
     } else {
       left_button_ = left_button;
       right_button_ = right_button;
     }
   }
 
   // Overridden from views::Background.
@@ skipping 131 matching lines @@
       case RIGHT_BUTTON:  return LEFT_BUTTON;
       default:            break;
     }
     return type_;
   }
 
   const ButtonType type_;
   const bool use_new_menu_;
 
   // See description above setter for details.
-  CustomButton* left_button_;
-  CustomButton* right_button_;
+  const CustomButton* left_button_;
+  const CustomButton* right_button_;
 
-  DISALLOW_COPY_AND_ASSIGN(MenuButtonBackground);
+  DISALLOW_COPY_AND_ASSIGN(InMenuButtonBackground);
 };
 
 base::string16 GetAccessibleNameForWrenchMenuItem(
       MenuModel* model, int item_index, int accessible_string_id) {
   base::string16 accessible_name =
       l10n_util::GetStringUTF16(accessible_string_id);
   base::string16 accelerator_text;
 
   ui::Accelerator menu_accelerator;
   if (model->GetAcceleratorAt(item_index, &menu_accelerator)) {
     accelerator_text =
         ui::Accelerator(menu_accelerator.key_code(),
                         menu_accelerator.modifiers()).GetShortcutText();
   }
 
   return MenuItemView::GetAccessibleNameForMenuItem(
       accessible_name, accelerator_text);
 }
 
+// A button that lives inside a menu item.
+class InMenuButton : public LabelButton {
+ public:
+  InMenuButton(views::ButtonListener* listener,
+               const base::string16& text,
+               bool use_new_menu)
+      : LabelButton(listener, text),
+        use_new_menu_(use_new_menu),
+        in_menu_background_(NULL) {}
+  virtual ~InMenuButton() {}
+
+  void Init(InMenuButtonBackground::ButtonType type) {
+    SetFocusable(true);
+    set_request_focus_on_press(false);
+    SetHorizontalAlignment(gfx::ALIGN_CENTER);
+
+    in_menu_background_ = new InMenuButtonBackground(type, use_new_menu_);
+    set_background(in_menu_background_);
+
+    OnNativeThemeChanged(NULL);
+  }
+
+  void SetOtherButtons(const InMenuButton* left, const InMenuButton* right) {
+    in_menu_background_->SetOtherButtons(left, right);
+  }
+
+  // views::LabelButton
+  virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) OVERRIDE {
+    const MenuConfig& menu_config = MenuConfig::instance(theme);
+    SetBorder(scoped_ptr<views::Border>(
+        new MenuButtonBorder(menu_config, use_new_menu_)));
+    SetFontList(menu_config.font_list);
+
+    if (theme) {
+      SetTextColor(
+          views::Button::STATE_DISABLED,
+          theme->GetSystemColor(
+              ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor));
+      SetTextColor(
+          views::Button::STATE_HOVERED,
+          theme->GetSystemColor(
+              ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor));
+      SetTextColor(
+          views::Button::STATE_PRESSED,
+          theme->GetSystemColor(
+              ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor));
+      SetTextColor(
+          views::Button::STATE_NORMAL,
+          theme->GetSystemColor(
+              ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor));
+    }
+  }
+
+ private:
+  bool use_new_menu_;
+
+  InMenuButtonBackground* in_menu_background_;
+
+  DISALLOW_COPY_AND_ASSIGN(InMenuButton);
+};
+
 // WrenchMenuView is a view that can contain label buttons.
 class WrenchMenuView : public views::View,
                        public views::ButtonListener,
                        public WrenchMenuObserver {
  public:
   WrenchMenuView(WrenchMenu* menu, MenuModel* menu_model)
       : menu_(menu),
         menu_model_(menu_model) {
     menu_->AddObserver(this);
   }
 
   virtual ~WrenchMenuView() {
     if (menu_)
       menu_->RemoveObserver(this);
   }
 
   // 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
+    // SchedulePaint. As part of the button border (InMenuButtonBackground) 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,
-                                        MenuButtonBackground::ButtonType type,
-                                        int index,
-                                        MenuButtonBackground** background) {
-    return CreateButtonWithAccName(
-        native_theme, string_id, type, index, background, string_id);
+  InMenuButton* CreateAndConfigureButton(
+      int string_id,
+      InMenuButtonBackground::ButtonType type,
+      int index) {
+    return CreateButtonWithAccName(string_id, type, index, string_id);
   }
 
-  LabelButton* CreateButtonWithAccName(const ui::NativeTheme* native_theme,
-                                       int string_id,
-                                       MenuButtonBackground::ButtonType type,
-                                       int index,
-                                       MenuButtonBackground** background,
-                                       int acc_string_id) {
+  InMenuButton* CreateButtonWithAccName(int string_id,
+                                        InMenuButtonBackground::ButtonType type,
+                                        int index,
+                                        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));
+    InMenuButton* button = new InMenuButton(
+        this,
+        gfx::RemoveAcceleratorChar(l10n_util::GetStringUTF16(string_id),
+                                   '&',
+                                   NULL,
+                                   NULL),
+        use_new_menu());
+    button->Init(type);
     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));
     return button;
   }
 
   // Overridden from WrenchMenuObserver:
   virtual void WrenchMenuDestroyed() OVERRIDE {
     menu_->RemoveObserver(this);
@@ skipping 18 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WrenchMenuView);
 };
 
 class ButtonContainerMenuItemView : public MenuItemView {
  public:
   // Constructor for use with button containing menu items which have a
   // different height then normal items.
   ButtonContainerMenuItemView(MenuItemView* parent, int command_id, int height)
       : MenuItemView(parent, command_id, MenuItemView::NORMAL),
-        height_(height) {
-  };
+        height_(height) {}
 
   // Overridden from MenuItemView.
   virtual gfx::Size GetChildPreferredSize() const OVERRIDE {
     gfx::Size size = MenuItemView::GetChildPreferredSize();
     // When there is a height override given, we need to deduct our spacing
     // above and below to get to the correct height to return here for the
     // child item.
     int height = height_ - GetTopMargin() - GetBottomMargin();
     if (height > size.height())
       size.set_height(height);
@@ skipping 45 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);
-    MenuButtonBackground* copy_background = NULL;
-    CreateAndConfigureButton(
-        native_theme, IDS_COPY, MenuButtonBackground::CENTER_BUTTON,
-        copy_index, &copy_background);
-    LabelButton* paste = CreateAndConfigureButton(
-        native_theme,
+    InMenuButton* cut = CreateAndConfigureButton(
+        IDS_CUT, InMenuButtonBackground::LEFT_BUTTON,
+        cut_index);
+    InMenuButton* copy = CreateAndConfigureButton(
+        IDS_COPY, InMenuButtonBackground::CENTER_BUTTON,
+        copy_index);
+    InMenuButton* paste = CreateAndConfigureButton(
         IDS_PASTE,
         menu->use_new_menu() && menu->supports_new_separators_ ?
-            MenuButtonBackground::CENTER_BUTTON :
-            MenuButtonBackground::RIGHT_BUTTON,
-        paste_index,
-        NULL);
-    copy_background->SetOtherButtons(cut, paste);
+            InMenuButtonBackground::CENTER_BUTTON :
+            InMenuButtonBackground::RIGHT_BUTTON,
+        paste_index);
+    copy->SetOtherButtons(cut, paste);
   }
 
   // Overridden from View.
   virtual gfx::Size GetPreferredSize() const OVERRIDE {
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview.
     return gfx::Size(GetMaxChildViewPreferredWidth() * child_count(), 0);
   }
 
   virtual void Layout() OVERRIDE {
@@ skipping 27 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,
-        decrement_index, NULL, IDS_ACCNAME_ZOOM_MINUS2);
+        IDS_ZOOM_MINUS2, InMenuButtonBackground::LEFT_BUTTON,
+        decrement_index, 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(
+    InMenuButtonBackground* center_bg = new InMenuButtonBackground(
         menu->use_new_menu() && menu->supports_new_separators_ ?
-            MenuButtonBackground::RIGHT_BUTTON :
-            MenuButtonBackground::CENTER_BUTTON,
+            InMenuButtonBackground::RIGHT_BUTTON :
+            InMenuButtonBackground::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,
-        increment_index, NULL, IDS_ACCNAME_ZOOM_PLUS2);
+        IDS_ZOOM_PLUS2, InMenuButtonBackground::RIGHT_BUTTON,
+        increment_index, 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()));
+        new InMenuButtonBackground(InMenuButtonBackground::SINGLE_BUTTON,
+                                   menu->use_new_menu()));
     fullscreen_button_->SetAccessibleName(
         GetAccessibleNameForWrenchMenuItem(
             menu_model, fullscreen_index, IDS_ACCNAME_FULLSCREEN));
     AddChildView(fullscreen_button_);
 
+    // Need to set a font list for the zoom label width calculations.
+    OnNativeThemeChanged(NULL);
     UpdateZoomControls();
   }
 
   virtual ~ZoomView() {}
 
   // Overridden from View.
   virtual gfx::Size GetPreferredSize() const 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() + (use_new_menu() ? 0 : kZoomPadding);
     bounds.set_x(x);
     bounds.set_width(fullscreen_button_->GetPreferredSize().width() +
                      (use_new_menu() ? kTouchZoomPadding : 0));
     fullscreen_button_->SetBoundsRect(bounds);
   }
 
+  virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) OVERRIDE {
+    WrenchMenuView::OnNativeThemeChanged(theme);
+
+    const MenuConfig& menu_config = MenuConfig::instance(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 227 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 224 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;
 }