diff --git ui/base/models/menu_model.h ui/base/models/menu_model.h
index c746b37d6278..b6cebc24b73e 100644
--- ui/base/models/menu_model.h
+++ ui/base/models/menu_model.h
@@ -12,8 +12,11 @@
 #include "ui/base/models/menu_separator_types.h"
 #include "ui/gfx/native_widget_types.h"
 
+#include "third_party/skia/include/core/SkColor.h"
+
 namespace gfx {
 class FontList;
+class Point;
 }
 
 namespace ui {
@@ -133,6 +136,27 @@ class COMPONENT_EXPORT(UI_BASE) MenuModel
   // |event_flags| is a bit mask of ui::EventFlags.
   virtual void ActivatedAt(int index, int event_flags);
 
+  // Called when the user moves the mouse outside the menu and over the owning
+  // window.
+  virtual void MouseOutsideMenu(const gfx::Point& screen_point) {}
+
+  // Called on unhandled open/close submenu keyboard commands. |is_rtl| will be
+  // true if the menu is displaying a right-to-left language.
+  virtual void UnhandledOpenSubmenu(bool is_rtl) {}
+  virtual void UnhandledCloseSubmenu(bool is_rtl) {}
+
+  // Override the text/background color of a given menu item dependent on the
+  // |index| and its |is_hovered| state. |is_minor| will be true for accelerator
+  // text. Returns true if it chooses to override the color.
+  virtual bool GetTextColor(int index,
+                            bool is_minor,
+                            bool is_hovered,
+                            SkColor* override_color) const { return false; }
+  virtual bool GetBackgroundColor(int index,
+                                  bool is_hovered,
+                                  SkColor* override_color) const
+                                  { return false; }
+
   // Called when the menu is about to be shown.
   virtual void MenuWillShow() {}
 
diff --git ui/gfx/render_text.cc ui/gfx/render_text.cc
index 3dc9e4daf46d..f5b2eb00f36f 100644
--- ui/gfx/render_text.cc
+++ ui/gfx/render_text.cc
@@ -615,6 +615,14 @@ void RenderText::SetWhitespaceElision(base::Optional<bool> whitespace_elision) {
   }
 }
 
+void RenderText::SetDrawStringsFlags(int flags) {
+  if (draw_strings_flags_ == flags)
+    return;
+  draw_strings_flags_ = flags;
+  cached_bounds_and_offset_valid_ = false;
+  OnTextAttributeChanged();
+}
+
 void RenderText::SetDisplayRect(const Rect& r) {
   if (r != display_rect_) {
     display_rect_ = r;
@@ -1966,6 +1974,19 @@ void RenderText::OnTextAttributeChanged() {
 
   layout_text_up_to_date_ = false;
 
+  if (draw_strings_flags_ != 0) {
+    // Compute layout size with the mnemonic character underlined since it might
+    // be larger than with the underline hidden.
+    int char_pos = -1;
+    int char_span = 0;
+    layout_text_ =
+        gfx::RemoveAcceleratorChar(layout_text_, '&', &char_pos, &char_span);
+    if (char_pos != -1) {
+      gfx::Range range(char_pos, char_pos + char_span);
+      styles_[TEXT_STYLE_UNDERLINE].ApplyValue(true, range);
+    }
+  }
+
   OnLayoutTextAttributeChanged(true);
 }
 
diff --git ui/gfx/render_text.h ui/gfx/render_text.h
index 4b39abb9d16c..c3b5debf995b 100644
--- ui/gfx/render_text.h
+++ ui/gfx/render_text.h
@@ -346,6 +346,10 @@ class GFX_EXPORT RenderText {
     return whitespace_elision_;
   }
 
+  // Get or set the flags that control display of accelerator characters.
+  void SetDrawStringsFlags(int flags);
+  int draw_strings_flags() const { return draw_strings_flags_; }
+
   const Rect& display_rect() const { return display_rect_; }
   void SetDisplayRect(const Rect& r);
 
@@ -1049,6 +1053,8 @@ class GFX_EXPORT RenderText {
   // Tell whether or not the |layout_text_| needs an update or is up to date.
   mutable bool layout_text_up_to_date_ = false;
 
+  int draw_strings_flags_ = 0;
+
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
diff --git ui/views/animation/ink_drop_host_view.h ui/views/animation/ink_drop_host_view.h
index 7a6dda99623b..7476e8966285 100644
--- ui/views/animation/ink_drop_host_view.h
+++ ui/views/animation/ink_drop_host_view.h
@@ -142,6 +142,8 @@ class VIEWS_EXPORT InkDropHostView : public View {
   // changes, to trigger the corresponding property change notification here.
   void OnInkDropHighlightedChanged();
 
+  InkDropMode ink_drop_mode() const { return ink_drop_mode_; }
+
  protected:
   // Size used for the default SquareInkDropRipple.
   static constexpr gfx::Size kDefaultInkDropSize = gfx::Size(24, 24);
diff --git ui/views/controls/button/label_button.cc ui/views/controls/button/label_button.cc
index b8dada677222..87d790657722 100644
--- ui/views/controls/button/label_button.cc
+++ ui/views/controls/button/label_button.cc
@@ -513,6 +513,12 @@ void LabelButton::OnThemeChanged() {
   SchedulePaint();
 }
 
+void LabelButton::SetFontList(const gfx::FontList& font_list) {
+  cached_normal_font_list_ = font_list;
+  cached_default_button_font_list_ = font_list;
+  label_->SetFontList(cached_normal_font_list_);
+}
+
 void LabelButton::StateChanged(ButtonState old_state) {
   Button::StateChanged(old_state);
   ResetLabelEnabledColor();
diff --git ui/views/controls/button/label_button.h ui/views/controls/button/label_button.h
index 4990f7e6ee48..c111e11f5100 100644
--- ui/views/controls/button/label_button.h
+++ ui/views/controls/button/label_button.h
@@ -134,6 +134,9 @@ class VIEWS_EXPORT LabelButton : public Button, public NativeThemeDelegate {
   ui::NativeTheme::State GetForegroundThemeState(
       ui::NativeTheme::ExtraParams* params) const override;
 
+  // Sets the font list used by this button.
+  void SetFontList(const gfx::FontList& font_list);
+
  protected:
   ImageView* image() const { return image_; }
   Label* label() const { return label_; }
diff --git ui/views/controls/label.cc ui/views/controls/label.cc
index 66ce6e76618b..ac584d47cea9 100644
--- ui/views/controls/label.cc
+++ ui/views/controls/label.cc
@@ -47,12 +47,27 @@ enum LabelPropertyKey {
   kLabelLineHeight,
   kLabelObscured,
   kLabelAllowCharacterBreak,
+  kLabelDrawStringsFlags,
 };
 
 bool IsOpaque(SkColor color) {
   return SkColorGetA(color) == SK_AlphaOPAQUE;
 }
 
+// Strips accelerator character prefixes in |text| if needed, based on |flags|.
+// Returns a range in |text| to underline or Range::InvalidRange() if
+// underlining is not needed.
+gfx::Range StripAcceleratorChars(int flags, base::string16* text) {
+  if (flags & (gfx::Canvas::SHOW_PREFIX | gfx::Canvas::HIDE_PREFIX)) {
+    int char_pos = -1;
+    int char_span = 0;
+    *text = gfx::RemoveAcceleratorChar(*text, '&', &char_pos, &char_span);
+    if ((flags & gfx::Canvas::SHOW_PREFIX) && char_pos != -1)
+      return gfx::Range(char_pos, char_pos + char_span);
+  }
+  return gfx::Range::InvalidRange();
+}
+
 }  // namespace
 
 namespace views {
@@ -353,6 +368,15 @@ base::string16 Label::GetTooltipText() const {
   return tooltip_text_;
 }
 
+void Label::SetDrawStringsFlags(int flags) {
+  if (draw_strings_flags_ == flags)
+    return;
+  draw_strings_flags_ = flags;
+  full_text_->SetDrawStringsFlags(draw_strings_flags_);
+  OnPropertyChanged(&full_text_ + kLabelDrawStringsFlags,
+                    kPropertyEffectsPreferredSizeChanged);
+}
+
 void Label::SetTooltipText(const base::string16& tooltip_text) {
   DCHECK(handles_tooltips_);
   if (tooltip_text_ == tooltip_text)
@@ -619,7 +643,19 @@ std::unique_ptr<gfx::RenderText> Label::CreateRenderText() const {
   render_text->SetFontList(font_list());
   render_text->set_shadows(GetShadows());
   render_text->SetCursorEnabled(false);
-  render_text->SetText(GetText());
+
+  if (draw_strings_flags_ != 0) {
+    base::string16 text_str = GetText();
+    gfx::Range range = StripAcceleratorChars(draw_strings_flags_, &text_str);
+    render_text->SetText(text_str);
+    if (range.IsValid()) {
+      render_text->SetDisplayRect(bounds());
+      render_text->ApplyStyle(gfx::TEXT_STYLE_UNDERLINE, true, range);
+    }
+  } else {
+    render_text->SetText(GetText());
+  }
+
   const bool multiline = GetMultiLine();
   render_text->SetMultiline(multiline);
   render_text->SetMaxLines(multiline ? GetMaxLines() : 0);
diff --git ui/views/controls/label.h ui/views/controls/label.h
index f5b59c83c526..da238ea0a4ae 100644
--- ui/views/controls/label.h
+++ ui/views/controls/label.h
@@ -199,6 +199,10 @@ class VIEWS_EXPORT Label : public View,
   gfx::ElideBehavior GetElideBehavior() const;
   void SetElideBehavior(gfx::ElideBehavior elide_behavior);
 
+  // Get or set the flags that control display of accelerator characters.
+  void SetDrawStringsFlags(int flags);
+  int GetDrawStringsFlags() const { return draw_strings_flags_; }
+
   // Gets/Sets the tooltip text.  Default behavior for a label (single-line) is
   // to show the full text if it is wider than its bounds.  Calling this
   // overrides the default behavior and lets you set a custom tooltip.  To
@@ -433,6 +437,7 @@ class VIEWS_EXPORT Label : public View,
   bool collapse_when_hidden_ = false;
   int fixed_width_ = 0;
   int max_width_ = 0;
+  int draw_strings_flags_ = 0;
 
   std::unique_ptr<SelectionController> selection_controller_;
 
diff --git ui/views/controls/menu/menu_controller.cc ui/views/controls/menu/menu_controller.cc
index e6a96689ef60..5dd54e402ce8 100644
--- ui/views/controls/menu/menu_controller.cc
+++ ui/views/controls/menu/menu_controller.cc
@@ -2689,8 +2689,13 @@ MenuItemView* MenuController::FindNextSelectableMenuItem(
 
 void MenuController::OpenSubmenuChangeSelectionIfCan() {
   MenuItemView* item = pending_state_.item;
-  if (!item->HasSubmenu() || !item->GetEnabled())
+  if (!item->HasSubmenu() || !item->GetEnabled() || !item->GetParentMenuItem()) {
+    MenuItemView* submenu_item =
+        item->GetParentMenuItem() ? item->GetParentMenuItem() : item;
+    submenu_item->GetDelegate()->OnUnhandledOpenSubmenu(submenu_item,
+                                                        base::i18n::IsRTL());
     return;
+  }
   MenuItemView* to_select = nullptr;
   if (!item->GetSubmenu()->GetMenuItems().empty())
     to_select = FindInitialSelectableMenuItem(item, INCREMENT_SELECTION_DOWN);
@@ -2709,8 +2714,10 @@ void MenuController::OpenSubmenuChangeSelectionIfCan() {
 void MenuController::CloseSubmenu() {
   MenuItemView* item = state_.item;
   DCHECK(item);
-  if (!item->GetParentMenuItem())
+  if (!item->GetParentMenuItem()) {
+    item->GetDelegate()->OnUnhandledCloseSubmenu(item, base::i18n::IsRTL());
     return;
+  }
   if (item->SubmenuIsShowing())
     SetSelection(item, SELECTION_UPDATE_IMMEDIATELY);
   else if (item->GetParentMenuItem()->GetParentMenuItem())
diff --git ui/views/controls/menu/menu_delegate.h ui/views/controls/menu/menu_delegate.h
index 158724b4752c..c82192848584 100644
--- ui/views/controls/menu/menu_delegate.h
+++ ui/views/controls/menu/menu_delegate.h
@@ -80,6 +80,22 @@ class VIEWS_EXPORT MenuDelegate {
   // parts of |style| or leave it unmodified.
   virtual void GetLabelStyle(int id, LabelStyle* style) const;
 
+  // Override the text color of a given menu item dependent on the |command_id|
+  // and its |is_hovered| state. |is_minor| will be true for accelerator text.
+  // Returns true if it chooses to override the color.
+  virtual bool GetTextColor(int command_id,
+                            bool is_minor,
+                            bool is_hovered,
+                            SkColor* override_color) const { return false; }
+
+  // Override the background color of a given menu item dependent on the
+  // |command_id| and its |is_hovered| state. Returns true if it chooses to
+  // override the color.
+  virtual bool GetBackgroundColor(int command_id,
+                                  bool is_hovered,
+                                  SkColor* override_color) const
+                                  { return false; }
+
   // The tooltip shown for the menu item. This is invoked when the user
   // hovers over the item, and no tooltip text has been set for that item.
   virtual base::string16 GetTooltipText(int id,
@@ -206,6 +222,11 @@ class VIEWS_EXPORT MenuDelegate {
                                        bool* has_mnemonics,
                                        MenuButton** button);
 
+  // Called on unhandled open/close submenu keyboard commands. |is_rtl| will be
+  // true if the menu is displaying a right-to-left language.
+  virtual void OnUnhandledOpenSubmenu(MenuItemView* menu, bool is_rtl) {}
+  virtual void OnUnhandledCloseSubmenu(MenuItemView* menu, bool is_rtl) {}
+
   // Returns the max width menus can grow to be.
   virtual int GetMaxWidthForMenu(MenuItemView* menu);
 
diff --git ui/views/controls/menu/menu_item_view.cc ui/views/controls/menu/menu_item_view.cc
index aaaddc97e057..2a335d26c3f9 100644
--- ui/views/controls/menu/menu_item_view.cc
+++ ui/views/controls/menu/menu_item_view.cc
@@ -1075,6 +1075,15 @@ void MenuItemView::PaintBackground(gfx::Canvas* canvas,
     spilling_rect.set_y(spilling_rect.y() - corner_radius_);
     spilling_rect.set_height(spilling_rect.height() + corner_radius_);
     canvas->DrawRoundRect(spilling_rect, corner_radius_, flags);
+    return;
+  }
+
+  MenuDelegate *delegate = GetDelegate();
+  SkColor override_color;
+  if (delegate && delegate->GetBackgroundColor(GetCommand(),
+                                               render_selection,
+                                               &override_color)) {
+    canvas->DrawColor(override_color);
   } else if (render_selection) {
     gfx::Rect item_bounds = GetLocalBounds();
     if (type_ == Type::kActionableSubMenu) {
@@ -1142,6 +1151,13 @@ void MenuItemView::PaintMinorIconAndText(
 }
 
 SkColor MenuItemView::GetTextColor(bool minor, bool render_selection) const {
+  SkColor text_color;
+  const MenuDelegate *delegate = GetDelegate();
+  if (delegate && delegate->GetTextColor(GetCommand(), minor, render_selection,
+                                         &text_color)) {
+    return text_color;
+  }
+
   style::TextContext context =
       GetMenuController() && GetMenuController()->use_touchable_layout()
           ? style::CONTEXT_TOUCH_MENU
diff --git ui/views/controls/menu/menu_model_adapter.cc ui/views/controls/menu/menu_model_adapter.cc
index b0b1cf9a7a79..17b37e84e933 100644
--- ui/views/controls/menu/menu_model_adapter.cc
+++ ui/views/controls/menu/menu_model_adapter.cc
@@ -240,6 +240,77 @@ bool MenuModelAdapter::IsItemChecked(int id) const {
   return false;
 }
 
+MenuItemView* MenuModelAdapter::GetSiblingMenu(MenuItemView* menu,
+                                               const gfx::Point& screen_point,
+                                               MenuAnchorPosition* anchor,
+                                               bool* has_mnemonics,
+                                               MenuButton** button) {
+  // Look up the menu model for this menu.
+  const std::map<MenuItemView*, ui::MenuModel*>::const_iterator map_iterator =
+      menu_map_.find(menu);
+  if (map_iterator != menu_map_.end()) {
+    map_iterator->second->MouseOutsideMenu(screen_point);
+    return nullptr;
+  }
+
+  NOTREACHED();
+  return nullptr;
+}
+
+void MenuModelAdapter::OnUnhandledOpenSubmenu(MenuItemView* menu,
+                                              bool is_rtl) {
+  // Look up the menu model for this menu.
+  const std::map<MenuItemView*, ui::MenuModel*>::const_iterator map_iterator =
+      menu_map_.find(menu);
+  if (map_iterator != menu_map_.end()) {
+    map_iterator->second->UnhandledOpenSubmenu(is_rtl);
+    return;
+  }
+
+  NOTREACHED();
+}
+
+void MenuModelAdapter::OnUnhandledCloseSubmenu(MenuItemView* menu,
+                                               bool is_rtl) {
+  // Look up the menu model for this menu.
+  const std::map<MenuItemView*, ui::MenuModel*>::const_iterator map_iterator =
+      menu_map_.find(menu);
+  if (map_iterator != menu_map_.end()) {
+    map_iterator->second->UnhandledCloseSubmenu(is_rtl);
+    return;
+  }
+
+  NOTREACHED();
+}
+
+bool MenuModelAdapter::GetTextColor(int command_id,
+                                    bool is_minor,
+                                    bool is_hovered,
+                                    SkColor* override_color) const {
+  ui::MenuModel* model = menu_model_;
+  int index = 0;
+  if (ui::MenuModel::GetModelAndIndexForCommandId(command_id, &model, &index))
+    return model->GetTextColor(index, is_minor, is_hovered, override_color);
+
+  NOTREACHED();
+  return false;
+}
+
+bool MenuModelAdapter::GetBackgroundColor(int command_id,
+                                          bool is_hovered,
+                                          SkColor* override_color) const {
+  if (command_id == -1)
+    return menu_model_->GetBackgroundColor(-1, is_hovered, override_color);
+
+  ui::MenuModel* model = menu_model_;
+  int index = 0;
+  if (ui::MenuModel::GetModelAndIndexForCommandId(command_id, &model, &index))
+    return model->GetBackgroundColor(index, is_hovered, override_color);
+
+  NOTREACHED();
+  return false;
+}
+
 void MenuModelAdapter::WillShowMenu(MenuItemView* menu) {
   // Look up the menu model for this menu.
   const std::map<MenuItemView*, ui::MenuModel*>::const_iterator map_iterator =
diff --git ui/views/controls/menu/menu_model_adapter.h ui/views/controls/menu/menu_model_adapter.h
index 78f832fd3acf..cb030c991614 100644
--- ui/views/controls/menu/menu_model_adapter.h
+++ ui/views/controls/menu/menu_model_adapter.h
@@ -84,6 +84,20 @@ class VIEWS_EXPORT MenuModelAdapter : public MenuDelegate,
   bool IsCommandEnabled(int id) const override;
   bool IsCommandVisible(int id) const override;
   bool IsItemChecked(int id) const override;
+  MenuItemView* GetSiblingMenu(MenuItemView* menu,
+                               const gfx::Point& screen_point,
+                               MenuAnchorPosition* anchor,
+                               bool* has_mnemonics,
+                               MenuButton** button) override;
+  void OnUnhandledOpenSubmenu(MenuItemView* menu, bool is_rtl) override;
+  void OnUnhandledCloseSubmenu(MenuItemView* menu, bool is_rtl) override;
+  bool GetTextColor(int command_id,
+                    bool is_minor,
+                    bool is_hovered,
+                    SkColor* override_color) const override;
+  bool GetBackgroundColor(int command_id,
+                          bool is_hovered,
+                          SkColor* override_color) const override;
   void WillShowMenu(MenuItemView* menu) override;
   void WillHideMenu(MenuItemView* menu) override;
   void OnMenuClosed(MenuItemView* menu) override;
diff --git ui/views/controls/menu/menu_scroll_view_container.cc ui/views/controls/menu/menu_scroll_view_container.cc
index 979e2222ad7c..3644db9f087d 100644
--- ui/views/controls/menu/menu_scroll_view_container.cc
+++ ui/views/controls/menu/menu_scroll_view_container.cc
@@ -200,6 +200,11 @@ MenuScrollViewContainer::MenuScrollViewContainer(SubmenuView* content_view)
   scroll_down_button_ =
       AddChildView(std::make_unique<MenuScrollButton>(content_view, false));
 
+  SkColor override_color;
+  MenuDelegate* delegate = content_view_->GetMenuItem()->GetDelegate();
+  if (delegate && delegate->GetBackgroundColor(-1, false, &override_color))
+    SetBackground(views::CreateSolidBackground(override_color));
+
   arrow_ = BubbleBorderTypeFromAnchor(
       content_view_->GetMenuItem()->GetMenuController()->GetAnchorPosition());
 
diff --git ui/views/test/ui_controls_factory_desktop_aurax11.cc ui/views/test/ui_controls_factory_desktop_aurax11.cc
index 82135658e188..53674f44d5d1 100644
--- ui/views/test/ui_controls_factory_desktop_aurax11.cc
+++ ui/views/test/ui_controls_factory_desktop_aurax11.cc
@@ -135,10 +135,6 @@ class UIControlsDesktopX11 : public UIControlsAura {
         aura::test::QueryLatestMousePositionRequestInHost(host);
     host->ConvertPixelsToDIP(&root_current_location);
 
-    auto* screen = views::test::TestDesktopScreenX11::GetInstance();
-    DCHECK_EQ(screen, display::Screen::GetScreen());
-    screen->set_cursor_screen_point(gfx::Point(screen_x, screen_y));
-
     if (root_location != root_current_location && button_down_mask == 0) {
       // Move the cursor because EnterNotify/LeaveNotify are generated with the
       // current mouse position as a result of XGrabPointer()
diff --git ui/views/view.h ui/views/view.h
index ff42e9282492..b1f65d8e2c4d 100644
--- ui/views/view.h
+++ ui/views/view.h
@@ -24,6 +24,7 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
+#include "base/supports_user_data.h"
 #include "build/build_config.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/accessibility/ax_enums.mojom-forward.h"
@@ -274,6 +275,7 @@ class VIEWS_EXPORT View : public ui::LayerDelegate,
                           public ui::EventTarget,
                           public ui::EventHandler,
                           public ui::PropertyHandler,
+                          public base::SupportsUserData,
                           public views::metadata::MetaDataProvider {
  public:
   using Views = std::vector<View*>;