Ensure that mouse events on Windows reposted by the menu_controller are converted to pixel.

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/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 21 matching lines @@
 #include "ui/views/mouse_constants.h"
 #include "ui/views/view.h"
 #include "ui/views/view_constants.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "ui/base/win/internal_constants.h"
+#include "ui/gfx/win/dpi.h"
 #include "ui/views/win/hwnd_util.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using ui::OSExchangeData;
 
 // Period of the scroll timer (in milliseconds).
 static const int kScrollTimerMS = 30;
 
@@ skipping 30 matching lines @@
 // Returns true if |menu| doesn't have a mnemonic and first character of the its
 // title is |key|.
 bool TitleMatchesMnemonic(MenuItemView* menu, base::char16 key) {
   if (menu->GetMnemonic())
     return false;
 
   base::string16 lower_title = base::i18n::ToLower(menu->title());
   return !lower_title.empty() && lower_title[0] == key;
 }
 
+// Returns the window and the screen location for the coordinates identified
+// by |event|. The window is returned in the output parameter |window| and
+// the screen location is returned in the output parameter |screen_location|.
+void PlatformGetWindowAtLocation(const ui::LocatedEvent& event,
+                                 SubmenuView* source,
+                                 gfx::NativeView native_view,
+                                 gfx::NativeWindow* window,
+                                 gfx::Point* screen_location) {
+  gfx::Point screen_loc(event.location());
+  View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
+  gfx::Screen* screen = gfx::Screen::GetScreenFor(native_view);
+#if defined(OS_WIN)
+  // On Windows convert the coordinates from DIP to pixel to ensure that we
+  // get the correct window.
+  screen_loc = gfx::win::DIPToScreenPoint(screen_loc);
+#endif
+  *window = screen->GetWindowAtScreenPoint(screen_loc);

[sky, 2014/06/18 22:20:26]

Something seems wrong here. Why does GetWindowAtScreenPoint want pixel points?
It seems wrong that ConvertPointToScreen returns DIPs yet screen functions want
pixels. Is that right?

[oshima, 2014/06/18 22:27:51]

Yes, both must be in DIP.

[ananta, 2014/06/18 22:57:10]

I updated the patch to fix ScreenWin::GetWindowAtScreenPoint to convert to
pixels
before calling WindowFromPoint. The other change is in menu_controller.cc to
convert screen_loc to pixels in the #if defined(OS_WIN) block in RepostEvent.
Added comments as to why that is needed.

PTAL.

+  *screen_location = screen_loc;
+}
+
 }  // namespace
 
 // Returns the first descendant of |view| that is hot tracked.
 static CustomButton* GetFirstHotTrackedView(View* view) {
   if (!view)
     return NULL;
   CustomButton* button = CustomButton::AsCustomButton(view);
   if (button) {
     if (button->IsHotTracked())
       return button;
@@ skipping 1933 matching lines @@
     // 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);
+  gfx::NativeWindow window = NULL;
+  gfx::Point screen_loc;
 
+  PlatformGetWindowAtLocation(event, source, native_view, &window,
+                              &screen_loc);
 #if defined(OS_WIN)
   // PostMessage() to metro windows isn't allowed (access will be denied). Don't
   // try to repost with Win32 if the window under the mouse press is in metro.
   if (!ViewsDelegate::views_delegate ||
       !ViewsDelegate::views_delegate->IsWindowInMetro(window)) {
     HWND target_window = window ? HWNDForNativeWindow(window) :
                                   WindowFromPoint(screen_loc.ToPOINT());
     HWND source_window = HWNDForNativeView(native_view);
     if (!target_window || !source_window ||
         GetWindowThreadProcessId(source_window, NULL) !=
         GetWindowThreadProcessId(target_window, NULL)) {
       // Even though we have mouse capture, windows generates a mouse event if
       // the other window is in a separate thread. Only repost an event if
       // |target_window| and |source_window| were created on the same thread,
       // else double events can occur and lead to bad behavior.
       return;
     }
-
     // Determine whether the click was in the client area or not.
     // NOTE: WM_NCHITTEST coordinates are relative to the screen.
     LPARAM coords = MAKELPARAM(screen_loc.x(), screen_loc.y());
     LRESULT nc_hit_result = SendMessage(target_window, WM_NCHITTEST, 0, coords);
     const bool client_area = nc_hit_result == HTCLIENT;
 
     // TODO(sky): this isn't right. The event to generate should correspond with
     // the event we just got. MouseEvent only tells us what is down, which may
     // differ. Need to add ability to get changed button from MouseEvent.
     int event_type;
@@ skipping 205 matching lines @@
   }
 }
 
 gfx::Screen* MenuController::GetScreen() {
   Widget* root = owner_ ? owner_->GetTopLevelWidget() : NULL;
   return root ? gfx::Screen::GetScreenFor(root->GetNativeView())
               : gfx::Screen::GetNativeScreen();
 }
 
 }  // namespace views