Fix moving the mouse between two displays after the secondary display becomes primary.

ash/display/extended_mouse_warp_controller.cc

 // Copyright 2015 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/extended_mouse_warp_controller.h"
 
 #include <cmath>
 
 #include "ash/display/display_manager.h"
 #include "ash/display/display_util.h"
@@ skipping 34 matching lines @@
   return Shell::GetScreen()->GetDisplayNearestWindow(window);
 }
 
 }  // namespace
 
 ExtendedMouseWarpController::WarpRegion::WarpRegion(
     int64_t a_display_id,
     int64_t b_display_id,
     const gfx::Rect& a_indicator_bounds,
     const gfx::Rect& b_indicator_bounds)
-    : a_display_id(a_display_id),
-      b_display_id(b_display_id),
-      a_indicator_bounds(a_indicator_bounds),
-      b_indicator_bounds(b_indicator_bounds),
-      shared_display_edge_indicator(nullptr) {
+    : a_display_id_(a_display_id),
+      b_display_id_(b_display_id),
+      a_indicator_bounds_(a_indicator_bounds),
+      b_indicator_bounds_(b_indicator_bounds),
+      shared_display_edge_indicator_(nullptr) {
   // Initialize edge bounds from indicator bounds.
   aura::Window* a_window = GetRootWindowForDisplayId(a_display_id);
   aura::Window* b_window = GetRootWindowForDisplayId(b_display_id);
 
   AshWindowTreeHost* a_ash_host = GetRootWindowController(a_window)->ash_host();
   AshWindowTreeHost* b_ash_host = GetRootWindowController(b_window)->ash_host();
 
-  a_edge_bounds_in_native = GetNativeEdgeBounds(a_ash_host, a_indicator_bounds);
-  b_edge_bounds_in_native = GetNativeEdgeBounds(b_ash_host, b_indicator_bounds);
+  a_edge_bounds_in_native_ =
+      GetNativeEdgeBounds(a_ash_host, a_indicator_bounds);
+  b_edge_bounds_in_native_ =
+      GetNativeEdgeBounds(b_ash_host, b_indicator_bounds);
 }
 
 ExtendedMouseWarpController::WarpRegion::~WarpRegion() {}
 
 ExtendedMouseWarpController::ExtendedMouseWarpController(
     aura::Window* drag_source)
     : drag_source_root_(drag_source),
       allow_non_native_event_(false) {
   ash::DisplayManager* display_manager =
       Shell::GetInstance()->display_manager();
 
   // For the time being, 3 or more displays are always always laid out
   // horizontally, with each display being RIGHT of the previous one.
   if (display_manager->GetNumDisplays() > 2) {
     for (size_t i = 1; i < display_manager->GetNumDisplays(); ++i) {
       const gfx::Display& left = display_manager->GetDisplayAt(i - 1);
       const gfx::Display& right = display_manager->GetDisplayAt(i);
 
       AddWarpRegion(CreateVerticalEdgeBounds(left, right, DisplayLayout::RIGHT),
                     drag_source != nullptr);
     }
   } else {
+    // Make sure to set |a| as the primary display, and |b| as the secondary
+    // display. DisplayLayout::Position is defined in terms of primary.
     DisplayLayout::Position position =
         display_manager->GetCurrentDisplayLayout().position;
-    const gfx::Display& a = display_manager->GetDisplayAt(0);
-    const gfx::Display& b = display_manager->GetDisplayAt(1);
+    const gfx::Display& a = Shell::GetScreen()->GetPrimaryDisplay();
+    const gfx::Display& b = ScreenUtil::GetSecondaryDisplay();
 
     // TODO(oshima): Use ComputeBondary instead.
-    if (position == DisplayLayout::TOP || position == DisplayLayout::BOTTOM)
+    if (position == DisplayLayout::TOP || position == DisplayLayout::BOTTOM) {
       AddWarpRegion(CreateHorizontalEdgeBounds(a, b, position),
                     drag_source != nullptr);
-    else
+    } else {
       AddWarpRegion(CreateVerticalEdgeBounds(a, b, position),
                     drag_source != nullptr);
+    }
   }
 }
 
 ExtendedMouseWarpController::~ExtendedMouseWarpController() {
 }
 
 bool ExtendedMouseWarpController::WarpMouseCursor(ui::MouseEvent* event) {
   if (Shell::GetScreen()->GetNumDisplays() <= 1 || !enabled_)
     return false;
 
@@ skipping 28 matching lines @@
 
   return WarpMouseCursorInNativeCoords(point_in_native, point_in_screen, false);
 }
 
 void ExtendedMouseWarpController::SetEnabled(bool enabled) {
   enabled_ = enabled;
 }
 
 void ExtendedMouseWarpController::AddWarpRegion(
     scoped_ptr<WarpRegion> warp_region,
-    bool drag_source) {
-  if (drag_source) {
-    warp_region->shared_display_edge_indicator.reset(
+    bool has_drag_source) {
+  if (has_drag_source) {
+    warp_region->shared_display_edge_indicator_.reset(
         new SharedDisplayEdgeIndicator);
-    warp_region->shared_display_edge_indicator->Show(
-        warp_region->a_indicator_bounds, warp_region->b_indicator_bounds);
+    warp_region->shared_display_edge_indicator_->Show(
+        warp_region->a_indicator_bounds_, warp_region->b_indicator_bounds_);
   }
 
   warp_regions_.emplace_back(std::move(warp_region));
 }
 
 bool ExtendedMouseWarpController::WarpMouseCursorInNativeCoords(
     const gfx::Point& point_in_native,
     const gfx::Point& point_in_screen,
     bool update_mouse_location_now) {
   for (const scoped_ptr<WarpRegion>& warp : warp_regions_) {
-    bool in_a_edge = warp->a_edge_bounds_in_native.Contains(point_in_native);
-    bool in_b_edge = warp->b_edge_bounds_in_native.Contains(point_in_native);
+    bool in_a_edge = warp->a_edge_bounds_in_native_.Contains(point_in_native);
+    bool in_b_edge = warp->b_edge_bounds_in_native_.Contains(point_in_native);
     if (!in_a_edge && !in_b_edge)
       continue;
 
     // The mouse must move.
     aura::Window* dst_window = GetRootWindowForDisplayId(
-        in_a_edge ? warp->b_display_id : warp->a_display_id);
+        in_a_edge ? warp->b_display_id_ : warp->a_display_id_);
     AshWindowTreeHost* target_ash_host =
         GetRootWindowController(dst_window)->ash_host();
 
     MoveCursorTo(target_ash_host, point_in_screen, update_mouse_location_now);
     return true;
   }
 
   return false;
 }
 
@@ skipping 80 matching lines @@
     upper_indicator_y = std::max(upper_indicator_y, upper_shared_y);
   }
   a_indicator_bounds.set_y(upper_indicator_y);
   a_indicator_bounds.set_height(lower_indicator_y - upper_indicator_y);
 
   return make_scoped_ptr(
       new WarpRegion(a.id(), b.id(), a_indicator_bounds, b_indicator_bounds));
 }
 
 }  // namespace ash