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

ash/display/display_manager.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 "ash/display/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <string>
@@ skipping 306 matching lines @@
       } else {
         info.set_clear_overscan_insets(false);
         info.SetOverscanInsets(insets_in_dip);
       }
       update = true;
     }
     display_info_list.push_back(info);
   }
   if (update) {
     AddMirrorDisplayInfoIfAny(&display_info_list);
-    UpdateDisplays(display_info_list);
+    UpdateDisplaysWith(display_info_list);
   } else {
     display_info_[display_id].SetOverscanInsets(insets_in_dip);
   }
 }
 
 void DisplayManager::SetDisplayRotation(int64_t display_id,
                                         gfx::Display::Rotation rotation,
                                         gfx::Display::RotationSource source) {
   if (IsInUnifiedMode())
     return;
 
   DisplayInfoList display_info_list;
   bool is_active = false;
   for (const auto& display : active_display_list_) {
     DisplayInfo info = GetDisplayInfo(display.id());
     if (info.id() == display_id) {
       if (info.GetRotation(source) == rotation &&
           info.GetActiveRotation() == rotation) {
         return;
       }
       info.SetRotation(rotation, source);
       is_active = true;
     }
     display_info_list.push_back(info);
   }
   if (is_active) {
     AddMirrorDisplayInfoIfAny(&display_info_list);
-    UpdateDisplays(display_info_list);
+    UpdateDisplaysWith(display_info_list);
   } else if (display_info_.find(display_id) != display_info_.end()) {
     // Inactive displays can reactivate, ensure they have been updated.
     display_info_[display_id].SetRotation(rotation, source);
   }
 }
 
 bool DisplayManager::SetDisplayMode(int64_t display_id,
                                     const DisplayMode& display_mode) {
   bool change_ui_scale = GetDisplayIdForUIScaling() == display_id;
 
@@ skipping 24 matching lines @@
         if (info.device_scale_factor() != display_mode.device_scale_factor) {
           info.set_device_scale_factor(display_mode.device_scale_factor);
           display_property_changed = true;
         }
       }
     }
     display_info_list.push_back(info);
   }
   if (display_property_changed) {
     AddMirrorDisplayInfoIfAny(&display_info_list);
-    UpdateDisplays(display_info_list);
+    UpdateDisplaysWith(display_info_list);
   }
   if (resolution_changed && IsInUnifiedMode()) {
     ReconfigureDisplays();
 #if defined(OS_CHROMEOS)
   } else if (resolution_changed && base::SysInfo::IsRunningOnChromeOS()) {
     Shell::GetInstance()->display_configurator()->OnConfigurationChanged();
 #endif
   }
   return resolution_changed || display_property_changed;
 }
@@ skipping 214 matching lines @@
     DisplayIdPair pair = CreateDisplayIdPair(new_display_info_list[0].id(),
                                              new_display_info_list[1].id());
     DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(pair);
     // Mirror mode is set by DisplayConfigurator on the device.
     // Emulate it when running on linux desktop.
     if (layout.mirrored)
       SetMultiDisplayMode(MIRRORING);
   }
 #endif
 
-  UpdateDisplays(new_display_info_list);
+  UpdateDisplaysWith(new_display_info_list);
 }
 
 void DisplayManager::UpdateDisplays() {
   DisplayInfoList display_info_list;
   for (const auto& display : active_display_list_)
     display_info_list.push_back(GetDisplayInfo(display.id()));
   AddMirrorDisplayInfoIfAny(&display_info_list);
-  UpdateDisplays(display_info_list);
+  UpdateDisplaysWith(display_info_list);
 }
 
-void DisplayManager::UpdateDisplays(
+void DisplayManager::UpdateDisplaysWith(
     const std::vector<DisplayInfo>& updated_display_info_list) {
 #if defined(OS_WIN)
   DCHECK_EQ(1u, updated_display_info_list.size()) <<
       ": Multiple display test does not work on Windows bots. Please "
       "skip (don't disable) the test using SupportsMultipleDisplays()";
 #endif
 
   DisplayInfoList new_display_info_list = updated_display_info_list;
   std::sort(active_display_list_.begin(), active_display_list_.end(),
             DisplaySortFunctor());
@@ skipping 307 matching lines @@
     // Layout the 2nd display below the primary as with the real device.
     gfx::Rect host_bounds = first_display.bounds_in_native();
     new_display_info_list.push_back(
         DisplayInfo::CreateFromSpec(base::StringPrintf(
             "%d+%d-600x%d", host_bounds.x(),
             host_bounds.bottom() + kVerticalOffsetPx, host_bounds.height())));
   }
   num_connected_displays_ = new_display_info_list.size();
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
-  UpdateDisplays(new_display_info_list);
+  UpdateDisplaysWith(new_display_info_list);
 }
 
 void DisplayManager::ToggleDisplayScaleFactor() {
   DCHECK(!active_display_list_.empty());
   std::vector<DisplayInfo> new_display_info_list;
   for (DisplayList::const_iterator iter = active_display_list_.begin();
        iter != active_display_list_.end(); ++iter) {
     DisplayInfo display_info = GetDisplayInfo(iter->id());
     display_info.set_device_scale_factor(
         display_info.device_scale_factor() == 1.0f ? 2.0f : 1.0f);
     new_display_info_list.push_back(display_info);
   }
   AddMirrorDisplayInfoIfAny(&new_display_info_list);
-  UpdateDisplays(new_display_info_list);
+  UpdateDisplaysWith(new_display_info_list);
 }
 
 #if defined(OS_CHROMEOS)
 void DisplayManager::SetSoftwareMirroring(bool enabled) {
   SetMultiDisplayMode(enabled ? MIRRORING
                               : current_default_multi_display_mode_);
 }
 
 bool DisplayManager::SoftwareMirroringEnabled() const {
   return software_mirroring_enabled();
@@ skipping 19 matching lines @@
   DisplayInfoList display_info_list;
   for (const gfx::Display& display : active_display_list_) {
     if (display.id() == kUnifiedDisplayId)
       continue;
     display_info_list.push_back(GetDisplayInfo(display.id()));
   }
   for (const gfx::Display& display : software_mirroring_display_list_)
     display_info_list.push_back(GetDisplayInfo(display.id()));
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
-  UpdateDisplays(display_info_list);
+  UpdateDisplaysWith(display_info_list);
 }
 
 bool DisplayManager::UpdateDisplayBounds(int64_t display_id,
                                          const gfx::Rect& new_bounds) {
   if (change_display_upon_host_resize_) {
     display_info_[display_id].SetBounds(new_bounds);
     // Don't notify observers if the mirrored window has changed.
     if (software_mirroring_enabled() && mirroring_display_id_ == display_id)
       return false;
     gfx::Display* display = FindDisplayForId(display_id);
@@ skipping 361 matching lines @@
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash