Correctly convert warp bounds from screen to native.

ash/display/display_util.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 "ash/display/display_util.h"
 
 #include <algorithm>
 
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
@@ skipping 146 matching lines @@
       break;
     }
   }
 }
 
 gfx::Rect GetNativeEdgeBounds(AshWindowTreeHost* ash_host,
                               const gfx::Rect& bounds_in_screen) {
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
   gfx::Rect native_bounds = host->GetBounds();
   native_bounds.Inset(ash_host->GetHostInsets());
-
-  bool vertical = bounds_in_screen.width() < bounds_in_screen.height();
-  gfx::Point start_in_native;
-  gfx::Point end_in_native;
-
-  if (vertical) {
-    start_in_native = bounds_in_screen.origin();
-    end_in_native = start_in_native;
-    end_in_native.set_y(bounds_in_screen.bottom());
-  } else {
-    start_in_native = bounds_in_screen.origin();
-    end_in_native = start_in_native;
-    end_in_native.set_x(bounds_in_screen.right());
-  }
+  gfx::Point start_in_native = bounds_in_screen.origin();
+  gfx::Point end_in_native = bounds_in_screen.bottom_right();
 
   ConvertPointFromScreenToNative(host, &start_in_native);
   ConvertPointFromScreenToNative(host, &end_in_native);
-  if (vertical) {
+
+  if (std::abs(start_in_native.x() - end_in_native.x()) <
+      std::abs(start_in_native.y() - end_in_native.y())) {
     // vertical in native
     int x = std::abs(native_bounds.x() - start_in_native.x()) <
                     std::abs(native_bounds.right() - start_in_native.x())
                 ? native_bounds.x()
                 : native_bounds.right() - 1;
     return gfx::Rect(x, std::min(start_in_native.y(), end_in_native.y()), 1,
-                     end_in_native.y() - start_in_native.y());
+                     std::abs(end_in_native.y() - start_in_native.y()));
   } else {
     // horizontal in native
     int y = std::abs(native_bounds.y() - start_in_native.y()) <
                     std::abs(native_bounds.bottom() - start_in_native.y())
                 ? native_bounds.y()
                 : native_bounds.bottom() - 1;
     return gfx::Rect(std::min(start_in_native.x(), end_in_native.x()), y,
-                     end_in_native.x() - start_in_native.x(), 1);
+                     std::abs(end_in_native.x() - start_in_native.x()), 1);
   }
 }
 
 // Moves the cursor to the point inside the root that is closest to
 // the point_in_screen, which is outside of the root window.
 void MoveCursorTo(AshWindowTreeHost* ash_host,
                   const gfx::Point& point_in_screen,
                   bool update_last_location_now) {
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
   gfx::Point point_in_native = point_in_screen;
@@ skipping 36 matching lines @@
 int FindDisplayIndexContainingPoint(const std::vector<gfx::Display>& displays,
                                     const gfx::Point& point_in_screen) {
   auto iter = std::find_if(displays.begin(), displays.end(),
                            [point_in_screen](const gfx::Display& display) {
                              return display.bounds().Contains(point_in_screen);
                            });
   return iter == displays.end() ? -1 : (iter - displays.begin());
 }
 
 }  // namespace ash