Change to address default selection of menu item

ui/views/controls/menu/menu_controller.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_controller.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/run_loop.h"
 #include "base/time.h"
@@ skipping 235 matching lines @@
   // currently selected item whose mnemonic matches. This may remain -1 even
   // though there are matches.
   int next_match;
 };
 
 // MenuController:State ------------------------------------------------------
 
 MenuController::State::State()
     : item(NULL),
       submenu_open(false),
-      anchor(views::MenuItemView::TOPLEFT) {}
+      anchor(views::MenuItemView::TOPLEFT),
+      context_menu(false) {}
 
 MenuController::State::~State() {}
 
 // MenuController ------------------------------------------------------------
 
 // static
 MenuController* MenuController::active_instance_ = NULL;
 
 // static
 MenuController* MenuController::GetActiveInstance() {
   return active_instance_;
 }
 
 MenuItemView* MenuController::Run(Widget* parent,
                                   MenuButton* button,
                                   MenuItemView* root,
                                   const gfx::Rect& bounds,
                                   MenuItemView::AnchorPosition position,
+                                  bool context_menu,
                                   int* result_mouse_event_flags) {
   exit_type_ = EXIT_NONE;
   possible_drag_ = false;
   drag_in_progress_ = false;
 
   bool nested_menu = showing_;
   if (showing_) {
     // Only support nesting of blocking_run menus, nesting of
     // blocking/non-blocking shouldn't be needed.
     DCHECK(blocking_run_);
 
     // We're already showing, push the current state.
     menu_stack_.push_back(state_);
 
     // The context menu should be owned by the same parent.
     DCHECK_EQ(owner_, parent);
   } else {
     showing_ = true;
   }
 
   // Reset current state.
   pending_state_ = State();
   state_ = State();
-  UpdateInitialLocation(bounds, position);
+  UpdateInitialLocation(bounds, position, context_menu);
 
   owner_ = parent;
 
   // Set the selection, which opens the initial menu.
   SetSelection(root, SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
 
   if (!blocking_run_) {
     // Start the timer to hide the menu. This is needed as we get no
     // notification when the drag has finished.
     StartCancelAllTimer();
@@ skipping 764 matching lines @@
   if (hot_view->GetClassName() == CustomButton::kViewClassName) {
     CustomButton* button = static_cast<CustomButton*>(hot_view);
     button->SetHotTracked(true);
   }
   return (exit_type_ == EXIT_NONE) ?
       ACCELERATOR_PROCESSED : ACCELERATOR_PROCESSED_EXIT;
 }
 
 void MenuController::UpdateInitialLocation(
     const gfx::Rect& bounds,
-    MenuItemView::AnchorPosition position) {
+    MenuItemView::AnchorPosition position,
+    bool context_menu) {
+  pending_state_.context_menu = context_menu;
   pending_state_.initial_bounds = bounds;
   if (bounds.height() > 1) {
     // Inset the bounds slightly, otherwise drag coordinates don't line up
     // nicely and menus close prematurely.
     pending_state_.initial_bounds.Inset(0, 1);
   }
 
   // Reverse anchor position for RTL languages.
   if (base::i18n::IsRTL()) {
     pending_state_.anchor = position == MenuItemView::TOPRIGHT ?
@@ skipping 80 matching lines @@
   menu_button_->SchedulePaint();
 
   // Need to reset capture when we show the menu again, otherwise we aren't
   // going to get any events.
   did_capture_ = false;
   gfx::Point screen_menu_loc;
   View::ConvertPointToScreen(button, &screen_menu_loc);
   // Subtract 1 from the height to make the popup flush with the button border.
   UpdateInitialLocation(gfx::Rect(screen_menu_loc.x(), screen_menu_loc.y(),
                                   button->width(), button->height() - 1),
-                        anchor);
+                        anchor, state_.context_menu);
   alt_menu->PrepareForRun(
-      has_mnemonics,
-      source->GetMenuItem()->GetRootMenuItem()->show_mnemonics_);
+      has_mnemonics, source->GetMenuItem()->GetRootMenuItem()->show_mnemonics_);
   alt_menu->controller_ = this;
   SetSelection(alt_menu, SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
   return true;
 }
 
 bool MenuController::ShowContextMenu(MenuItemView* menu_item,
                                      SubmenuView* source,
                                      const ui::LocatedEvent& event) {
   // Set the selection immediately, making sure the submenu is only open
   // if it already was.
@@ skipping 345 matching lines @@
     pref.set_width(std::min(pref.width(), state_.monitor_bounds.width()));
 
   // Assume we can honor prefer_leading.
   *is_leading = prefer_leading;
 
   int x, y;
 
   if (!item->GetParentMenuItem()) {
     // First item, position relative to initial location.
     x = state_.initial_bounds.x();
+
+    // Offsets for context menu prevent menu items being selected by
+    // simply opening the menu (bug 142992).
+    if (MenuConfig::instance().offset_context_menus && state_.context_menu)
+      x += 1;
+
     y = state_.initial_bounds.bottom();
-    if (state_.anchor == MenuItemView::TOPRIGHT)
+    if (state_.anchor == MenuItemView::TOPRIGHT) {
       x = x + state_.initial_bounds.width() - pref.width();
+      if (MenuConfig::instance().offset_context_menus && state_.context_menu)
+        x -= 1;
+    }
 
     if (!state_.monitor_bounds.IsEmpty() &&
         y + pref.height() > state_.monitor_bounds.bottom()) {
       // The menu doesn't fit fully below the button on the screen. The menu
       // position with respect to the bounds will be preserved if it has
       // already been drawn. When the requested positioning is below the bounds
       // it will shrink the menu to make it fit below.
       // If the requested positioning is best fit, it will first try to fit the
       // menu below. If that does not fit it will try to place it above. If
       // that will not fit it will place it at the bottom of the work area and
@@ skipping 50 matching lines @@
         item->set_actual_menu_position(MenuItemView::POSITION_ABOVE_BOUNDS);
       }
     } else if (item->actual_menu_position() ==
                MenuItemView::POSITION_ABOVE_BOUNDS) {
       pref.set_height(std::min(pref.height(),
           state_.initial_bounds.y() - state_.monitor_bounds.y()));
       y = state_.initial_bounds.y() - pref.height();
     } else {
       item->set_actual_menu_position(MenuItemView::POSITION_BELOW_BOUNDS);
     }
+    if (state_.monitor_bounds.width() != 0 &&
+        MenuConfig::instance().offset_context_menus && state_.context_menu) {
+      if (x + pref.width() > state_.monitor_bounds.right())
+        x = state_.initial_bounds.x() - pref.width() - 1;
+      if (x < state_.monitor_bounds.x())
+        x = state_.monitor_bounds.x();
+    }
   } else {
     // Not the first menu; position it relative to the bounds of the menu
     // item.
     gfx::Point item_loc;
     View::ConvertPointToScreen(item, &item_loc);
 
     // We must make sure we take into account the UI layout. If the layout is
     // RTL, then a 'leading' menu is positioned to the left of the parent menu
     // item and not to the right.
     bool layout_is_rtl = base::i18n::IsRTL();
@@ skipping 469 matching lines @@
 
 #if defined(USE_AURA)
 void MenuController::OnWindowActivated(aura::Window* active,
                                        aura::Window* old_active) {
   if (!drag_in_progress_)
     Cancel(EXIT_ALL);
 }
 #endif
 
 }  // namespace views