Fix app menu borders for RTL

chrome/browser/ui/views/toolbar/app_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/app_menu.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 120 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(FullscreenButton);
 };
 
 // Combination border/background for the buttons contained in the menu. The
 // painting of the border/background is done here as LabelButton does not always
 // paint the border.
 class InMenuButtonBackground : public views::Background {
  public:
   enum ButtonType {
-    // A rectangular button with no neighbor on the left.
-    LEFT_BUTTON,
+    // A rectangular button with no drawn border.
+    NO_BORDER,
 
-    // A rectangular button with neighbors on both sides.
-    CENTER_BUTTON,
+    // A rectangular button with a border drawn along the leading (left) side.
+    LEADING_BORDER,
 
-    // A rectangular button with no neighbor on the right.
-    RIGHT_BUTTON,
-
-    // A rectangular button that is not a member in a group.
-    SINGLE_BUTTON,
-
-    // A button with no group neighbors and a rounded background.
+    // A button with no drawn border and a rounded background.
     ROUNDED_BUTTON,
   };
 
-  explicit InMenuButtonBackground(ButtonType type)
-      : type_(type), 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(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;
-    }
-  }
+  explicit InMenuButtonBackground(ButtonType type) : type_(type) {}
 
   // Overridden from views::Background.
   void Paint(gfx::Canvas* canvas, View* view) const override {
     CustomButton* button = CustomButton::AsCustomButton(view);
     views::Button::ButtonState state =
         button ? button->state() : views::Button::STATE_NORMAL;
     int h = view->height();
 
-    // Normal buttons get a border drawn on the right side and the rest gets
-    // filled in. The left or rounded buttons however do not get a line to
-    // combine buttons.
+    // Draw leading border where needed. This is along the left edge unless the
+    // layout is RTL and the button isn't mirroring itself.
     gfx::Rect bounds(view->GetLocalBounds());
-    if (type_ != RIGHT_BUTTON && type_ != ROUNDED_BUTTON) {
-      canvas->FillRect(gfx::Rect(0, 0, 1, h),
-                       BorderColor(view, views::Button::STATE_NORMAL));
+    if (type_ == LEADING_BORDER) {
+      gfx::Rect rect = view->FlipCanvasOnPaintForRTLUI()
+          ? gfx::Rect(0, 0, 1, h)
+          : gfx::Rect(view->GetMirroredXWithWidthInView(0, 1), 0, 1, h);
+      canvas->FillRect(rect, BorderColor(view, views::Button::STATE_NORMAL));
       bounds.Inset(gfx::Insets(0, 1, 0, 0));
     }
 
+    // Fill in background for state.
     bounds.set_x(view->GetMirroredXForRect(bounds));
     DrawBackground(canvas, view, bounds, state);
   }
 
  private:
   static SkColor BorderColor(View* view, views::Button::ButtonState state) {
     ui::NativeTheme* theme = view->GetNativeTheme();
     switch (state) {
       case views::Button::STATE_HOVERED:
         return theme->GetSystemColor(
@@ skipping 36 matching lines @@
         // Consistent with a hover corner radius (kInkDropSmallCornerRadius).
         const int kBackgroundCornerRadius = 2;
         params.menu_item.corner_radius = kBackgroundCornerRadius;
       }
       view->GetNativeTheme()->Paint(canvas->sk_canvas(),
                                     ui::NativeTheme::kMenuItemBackground,
                                     ui::NativeTheme::kHovered, bounds, params);
     }
   }
 
-  ButtonType TypeAdjustedForRTL() const {
-    if (!base::i18n::IsRTL())
-      return type_;
-
-    switch (type_) {
-      case LEFT_BUTTON:   return RIGHT_BUTTON;
-      case RIGHT_BUTTON:  return LEFT_BUTTON;
-      default:            break;
-    }
-    return type_;
-  }
-
   const ButtonType type_;
 
-  // See description above setter for details.
-  const CustomButton* left_button_;
-  const CustomButton* right_button_;
-
   DISALLOW_COPY_AND_ASSIGN(InMenuButtonBackground);
 };
 
 base::string16 GetAccessibleNameForAppMenuItem(ButtonMenuItemModel* model,
                                                int item_index,
                                                int accessible_string_id) {
   base::string16 accessible_name =
       l10n_util::GetStringUTF16(accessible_string_id);
   base::string16 accelerator_text;
 
@@ skipping 21 matching lines @@
     SetFocusBehavior(FocusBehavior::ALWAYS);
     SetHorizontalAlignment(gfx::ALIGN_CENTER);
 
     in_menu_background_ = new InMenuButtonBackground(type);
     set_background(in_menu_background_);
     SetBorder(views::Border::CreateEmptyBorder(0, kHorizontalPadding, 0,
                                                kHorizontalPadding));
     SetFontList(MenuConfig::instance().font_list);
   }
 
-  void SetOtherButtons(const InMenuButton* left, const InMenuButton* right) {
-    in_menu_background_->SetOtherButtons(left, right);
-  }
-
   void GetAccessibleState(ui::AXViewState* state) override {
     LabelButton::GetAccessibleState(state);
     state->role = ui::AX_ROLE_MENU_ITEM;
   }
 
   // views::LabelButton
   void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
     if (theme) {
       SetTextColor(
           views::Button::STATE_DISABLED,
@@ skipping 140 matching lines @@
 
 // CutCopyPasteView is the view containing the cut/copy/paste buttons.
 class AppMenu::CutCopyPasteView : public AppMenuView {
  public:
   CutCopyPasteView(AppMenu* menu,
                    ButtonMenuItemModel* menu_model,
                    int cut_index,
                    int copy_index,
                    int paste_index)
       : AppMenuView(menu, menu_model) {
-    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, InMenuButtonBackground::CENTER_BUTTON, paste_index);
-    copy->SetOtherButtons(cut, paste);
+    CreateAndConfigureButton(IDS_CUT, InMenuButtonBackground::LEADING_BORDER,
+                             cut_index);
+    CreateAndConfigureButton(IDS_COPY, InMenuButtonBackground::LEADING_BORDER,
+                             copy_index);
+    CreateAndConfigureButton(IDS_PASTE, InMenuButtonBackground::LEADING_BORDER,
+                             paste_index);
   }
 
   // Overridden from View.
   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);
   }
 
   void Layout() override {
@@ skipping 42 matching lines @@
         zoom_label_max_width_(0),
         zoom_label_max_width_valid_(false) {
     browser_zoom_subscription_ =
         ui_zoom::ZoomEventManager::GetForBrowserContext(
             menu->browser_->profile())
             ->AddZoomLevelChangedCallback(
                 base::Bind(&AppMenu::ZoomView::OnZoomLevelChanged,
                            base::Unretained(this)));
 
     decrement_button_ = CreateButtonWithAccName(
-        IDS_ZOOM_MINUS2, InMenuButtonBackground::LEFT_BUTTON,
+        IDS_ZOOM_MINUS2, InMenuButtonBackground::LEADING_BORDER,
         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);
 
     InMenuButtonBackground* center_bg =
-        new InMenuButtonBackground(InMenuButtonBackground::RIGHT_BUTTON);
+        new InMenuButtonBackground(InMenuButtonBackground::NO_BORDER);
     zoom_label_->set_background(center_bg);
 
     AddChildView(zoom_label_);
     zoom_label_max_width_valid_ = false;
 
     increment_button_ = CreateButtonWithAccName(
-        IDS_ZOOM_PLUS2, InMenuButtonBackground::RIGHT_BUTTON,
-        increment_index, IDS_ACCNAME_ZOOM_PLUS2);
-
-    center_bg->SetOtherButtons(decrement_button_, increment_button_);
+        IDS_ZOOM_PLUS2, InMenuButtonBackground::NO_BORDER, increment_index,
+        IDS_ACCNAME_ZOOM_PLUS2);
 
     fullscreen_button_ = new FullscreenButton(this);
     // all buttons on menu should must be a custom button in order for
-    // the keyboard nativigation work.
+    // the keyboard navigation 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);
 
     // Since |fullscreen_button_| will reside in a menu, make it ALWAYS
     // focusable regardless of the platform.
     fullscreen_button_->SetFocusBehavior(FocusBehavior::ALWAYS);
     fullscreen_button_->set_tag(fullscreen_index);
     fullscreen_button_->SetImageAlignment(
         ImageButton::ALIGN_CENTER, ImageButton::ALIGN_MIDDLE);
     fullscreen_button_->set_background(
-        new InMenuButtonBackground(InMenuButtonBackground::SINGLE_BUTTON));
+        new InMenuButtonBackground(InMenuButtonBackground::LEADING_BORDER));
     fullscreen_button_->SetAccessibleName(GetAccessibleNameForAppMenuItem(
         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();
   }
 
   ~ZoomView() override {}
@@ skipping 716 matching lines @@
                                 0,
                                 BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
                                 BOOKMARK_LAUNCH_LOCATION_APP_MENU);
 }
 
 int AppMenu::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;
 }