Update reposting of events from menus

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/macros.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 661 matching lines @@
 
   if (!part.submenu)
     return;
   part.submenu->OnGestureEvent(event);
 }
 
 void MenuController::OnTouchEvent(SubmenuView* source, ui::TouchEvent* event) {
   if (event->type() == ui::ET_TOUCH_PRESSED) {
     MenuPart part = GetMenuPart(source, event->location());
     if (part.type == MenuPart::NONE) {
-      RepostEvent(source, event);
+      RepostEventAndCancel(source, event);
       event->SetHandled();
     }
   }
 }
 
 View* MenuController::GetTooltipHandlerForPoint(SubmenuView* source,
                                                 const gfx::Point& point) {
   MenuHostRootView* root_view = GetRootView(source, point);
   return root_view ? root_view->ProcessGetTooltipHandlerForPoint(point)
                    : nullptr;
@@ skipping 301 matching lines @@
       (event->flags() & ui::EF_FROM_TOUCH))
     return;
 
   if (part.type == MenuPart::NONE ||
       (part.type == MenuPart::MENU_ITEM && part.menu &&
        part.menu->GetRootMenuItem() != state_.item->GetRootMenuItem())) {
     // Remember the time stamp of the current (press down) event. The owner can
     // then use this to figure out if this menu was finished with the same click
     // which is sent to it thereafter.
     closing_event_time_ = event->time_stamp();
-
-    // Mouse wasn't pressed over any menu, or the active menu, cancel.
-
-#if defined(OS_WIN)
-    // We're going to close and we own the mouse capture. We need to repost the
-    // mouse down, otherwise the window the user clicked on won't get the event.
-    RepostEvent(source, event);
-#endif
-
-    // And close.
-    ExitType exit_type = EXIT_ALL;
-    if (!menu_stack_.empty()) {
-      // We're running nested menus. Only exit all if the mouse wasn't over one
-      // of the menus from the last run.
-      gfx::Point screen_loc(event->location());
-      View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
-      MenuPart last_part = GetMenuPartByScreenCoordinateUsingMenu(
-          menu_stack_.back().first.item, screen_loc);
-      if (last_part.type != MenuPart::NONE)
-        exit_type = EXIT_OUTERMOST;
-    }
-    Cancel(exit_type);
-
-#if defined(OS_CHROMEOS)
-    // We're going to exit the menu and want to repost the event so that is
-    // is handled normally after the context menu has exited. We call
-    // RepostEvent after Cancel so that mouse capture has been released so
-    // that finding the event target is unaffected by the current capture.
-    RepostEvent(source, event);
-#endif
+    // Event wasn't pressed over any menu, or the active menu, cancel.
+    RepostEventAndCancel(source, event);
     // Do not repost events for Linux Aura because this behavior is more
     // consistent with the behavior of other Linux apps.
     return;
   }
 
   // On a press we immediately commit the selection, that way a submenu
   // pops up immediately rather than after a delay.
   int selection_types = SELECTION_UPDATE_IMMEDIATELY;
   if (!part.menu) {
     part.menu = part.parent;
@@ skipping 1137 matching lines @@
     item->GetSubmenu()->GetPrefixSelector()->InsertText(char_array);
   } else {
     // If no mnemonics found, look at first character of titles.
     details = FindChildForMnemonic(item, key, &TitleMatchesMnemonic);
     if (details.first_match != -1)
       AcceptOrSelect(item, details);
   }
 }
 
 void MenuController::RepostEvent(SubmenuView* source,
-                                 const ui::LocatedEvent* event) {
+                                 const ui::LocatedEvent* event,
+                                 const gfx::Point& screen_loc,
+                                 gfx::NativeView native_view,
+                                 gfx::NativeWindow window) {
   if (!event->IsMouseEvent() && !event->IsTouchEvent()) {
     // TODO(rbyers): Gesture event repost is tricky to get right
     // crbug.com/170987.
     DCHECK(event->IsGestureEvent());
     return;
   }
 
 #if defined(OS_WIN)
   if (!state_.item) {
     // We some times get an event after closing all the menus. Ignore it. Make
     // sure the menu is in fact not visible. If the menu is visible, then
     // we're in a bad state where we think the menu isn't visibile but it is.
     DCHECK(!source->GetWidget()->IsVisible());
     return;
   }
 
   state_.item->GetRootMenuItem()->GetSubmenu()->ReleaseCapture();
 #endif
 
-  gfx::Point screen_loc(event->location());
-  View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
-  gfx::NativeView native_view = source->GetWidget()->GetNativeView();
   if (!native_view)
     return;
 
-  gfx::Screen* screen = gfx::Screen::GetScreenFor(native_view);
-  gfx::NativeWindow window = screen->GetWindowAtScreenPoint(screen_loc);
-
 #if defined(OS_WIN)
   gfx::Point screen_loc_pixels = gfx::win::DIPToScreenPoint(screen_loc);
   HWND target_window = ::WindowFromPoint(screen_loc_pixels.ToPOINT());
   // If we don't find a native window for the HWND at the current location,
   // then attempt to find a native window from its parent if one exists.
   // There are HWNDs created outside views, which don't have associated
   // native windows.
   if (!window) {
     HWND parent = ::GetParent(target_window);
     if (parent) {
@@ skipping 57 matching lines @@
     return;
   }
 #endif
   // Non Aura window.
   if (!window)
     return;
 
   MenuMessageLoop::RepostEventToWindow(event, window, screen_loc);
 }
 
+void MenuController::RepostEventAndCancel(SubmenuView* source,
+                                          const ui::LocatedEvent* event) {
+  // Cancel can lead to the deletion |source| so we save the view and window to
+  // be used when reposting the event.
+  gfx::Point screen_loc(event->location());
+  View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
+  gfx::NativeView native_view = source->GetWidget()->GetNativeView();
+  gfx::NativeWindow window = nullptr;
+  if (native_view) {
+    gfx::Screen* screen = gfx::Screen::GetScreenFor(native_view);
+    window = screen->GetWindowAtScreenPoint(screen_loc);
+  }
+
+#if defined(OS_WIN)
+  // We're going to close and we own the event capture. We need to repost the
+  // event, otherwise the window the user clicked on won't get the event.
+  RepostEvent(source, event, screen_loc, native_view, window);
+#endif
+
+  // Determine target to see if a complete or partial close of the menu should
+  // occur.
+  ExitType exit_type = EXIT_ALL;
+  if (!menu_stack_.empty()) {
+    // We're running nested menus. Only exit all if the mouse wasn't over one
+    // of the menus from the last run.
+    MenuPart last_part = GetMenuPartByScreenCoordinateUsingMenu(
+        menu_stack_.back().first.item, screen_loc);
+    if (last_part.type != MenuPart::NONE)
+      exit_type = EXIT_OUTERMOST;
+  }
+  Cancel(exit_type);
+
+#if defined(OS_CHROMEOS)
+  // We're going to exit the menu and want to repost the event so that is
+  // is handled normally after the context menu has exited. We call
+  // RepostEvent after Cancel so that event capture has been released so
+  // that finding the event target is unaffected by the current capture.
+  RepostEvent(source, event, screen_loc, native_view, window);
+#endif
+}
+
 void MenuController::SetDropMenuItem(
     MenuItemView* new_target,
     MenuDelegate::DropPosition new_position) {
   if (new_target == drop_target_ && new_position == drop_position_)
     return;
 
   if (drop_target_) {
     drop_target_->GetParentMenuItem()->GetSubmenu()->SetDropMenuItem(
         NULL, MenuDelegate::DROP_NONE);
   }
@@ skipping 251 matching lines @@
   }
 }
 
 gfx::Screen* MenuController::GetScreen() {
   Widget* root = owner_ ? owner_->GetTopLevelWidget() : NULL;
   return root ? gfx::Screen::GetScreenFor(root->GetNativeView())
               : gfx::Screen::GetNativeScreen();
 }
 
 }  // namespace views