Fixed tab dragging which was broken on high DPI windows for scales other than 100%.

chrome/browser/ui/views/tabs/window_finder_win.cc

 // Copyright 2014 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/tabs/window_finder.h"
 
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/windows_version.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/screen.h"
+#include "ui/gfx/win/dpi.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h"
 #include "ui/views/win/hwnd_util.h"
 
 #if defined(USE_ASH)
 aura::Window* GetLocalProcessWindowAtPointAsh(
     const gfx::Point& screen_point,
     const std::set<aura::Window*>& ignore);
 #endif
 
 namespace {
@@ skipping 98 matching lines @@
     // Stop iterating if the region contains the point.
     return !!is_point_in_region;
   }
 
  private:
   TopMostFinder(HWND window,
                 const gfx::Point& screen_loc,
                 const std::set<HWND>& ignore)
       : BaseWindowFinder(ignore),
         target_(window),
-        screen_loc_(screen_loc),
         is_top_most_(false),
         tmp_region_(CreateRectRgn(0, 0, 0, 0)) {
+    screen_loc_ = gfx::win::DIPToScreenPoint(screen_loc);
     EnumWindows(WindowCallbackProc, as_lparam());
   }
 
   // The window we're looking for.
   HWND target_;
 
-  // Location of window to find.
+  // Location of window to find in pixel coordinates.
   gfx::Point screen_loc_;
 
   // Is target_ the top most window? This is initially false but set to true
   // in ShouldStopIterating if target_ is passed in.
   bool is_top_most_;
 
   base::win::ScopedRegion tmp_region_;
 
   DISALLOW_COPY_AND_ASSIGN(TopMostFinder);
 };
 
 // WindowFinder ---------------------------------------------------------------
 
 // Helper class to determine if a particular point contains a window from our
 // process.
 class LocalProcessWindowFinder : public BaseWindowFinder {
  public:
   // Returns the hwnd from our process at screen_loc that is not obscured by
   // another window. Returns NULL otherwise.
   static gfx::NativeWindow GetProcessWindowAtPoint(
       const gfx::Point& screen_loc,
       const std::set<HWND>& ignore) {
     LocalProcessWindowFinder finder(screen_loc, ignore);
     // Windows 8 has a window that appears first in the list of iterated
     // windows, yet is not visually on top of everything.
     // TODO(sky): figure out a better way to ignore this window.
     if (finder.result_ &&
         ((base::win::OSInfo::GetInstance()->version() >=
           base::win::VERSION_WIN8) ||
-         TopMostFinder::IsTopMostWindowAtPoint(finder.result_, screen_loc,
+         TopMostFinder::IsTopMostWindowAtPoint(finder.result_,
+                                               screen_loc,
                                                ignore))) {
       return views::DesktopWindowTreeHostWin::GetContentWindowForHWND(
           finder.result_);
     }
     return NULL;
   }
 
  protected:
   virtual bool ShouldStopIterating(HWND hwnd) {
     RECT r;
     if (IsWindowVisible(hwnd) && GetWindowRect(hwnd, &r) &&
         PtInRect(&r, screen_loc_.ToPOINT())) {
       result_ = hwnd;
       return true;
     }
     return false;
   }
 
  private:
   LocalProcessWindowFinder(const gfx::Point& screen_loc,
                            const std::set<HWND>& ignore)
       : BaseWindowFinder(ignore),
-        screen_loc_(screen_loc),
         result_(NULL) {
+    screen_loc_ = gfx::win::DIPToScreenPoint(screen_loc);
     EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, as_lparam());
   }
 
-  // Position of the mouse.
+  // Position of the mouse in pixel coordinates.
   gfx::Point screen_loc_;
 
   // The resulting window. This is initially null but set to true in
   // ShouldStopIterating if an appropriate window is found.
   HWND result_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalProcessWindowFinder);
 };
 
 std::set<HWND> RemapIgnoreSet(const std::set<gfx::NativeView>& ignore) {
@@ skipping 13 matching lines @@
     chrome::HostDesktopType host_desktop_type,
     const gfx::Point& screen_point,
     const std::set<aura::Window*>& ignore) {
 #if defined(USE_ASH)
   if (host_desktop_type == chrome::HOST_DESKTOP_TYPE_ASH)
     return GetLocalProcessWindowAtPointAsh(screen_point, ignore);
 #endif
   return LocalProcessWindowFinder::GetProcessWindowAtPoint(
           screen_point, RemapIgnoreSet(ignore));
 }