Moving input device hotplug event processing outside of ui/display

ash/touch/touch_transformer_controller.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/touch/touch_transformer_controller.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/display/chromeos/display_configurator.h"
 #include "ui/display/types/chromeos/display_snapshot.h"
 #include "ui/events/device_data_manager.h"
 #include "ui/events/x/device_data_manager_x11.h"
 
 namespace ash {
 
 namespace {
 
 DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
 }  // namespace
 
-
 // This is to compute the scale ratio for the TouchEvent's radius. The
 // configured resolution of the display is not always the same as the touch
 // screen's reporting resolution, e.g. the display could be set as
 // 1920x1080 while the touchscreen is reporting touch position range at
 // 32767x32767. Touch radius is reported in the units the same as touch position
 // so we need to scale the touch radius to be compatible with the display's
 // resolution. We compute the scale as
 // sqrt of (display_area / touchscreen_area)
 double TouchTransformerController::GetTouchResolutionScale(
     const DisplayInfo& touch_display) const {
@@ skipping 50 matching lines @@
 }
 
 bool TouchTransformerController::ShouldComputeMirrorModeTouchTransformer(
     const DisplayInfo& touch_display) const {
   if (force_compute_mirror_mode_touch_transformer_)
     return true;
 
   if (touch_display.touch_device_id() == 0)
     return false;
 
-  const ui::DisplayConfigurator::DisplayState* state = NULL;
-  const std::vector<ui::DisplayConfigurator::DisplayState>& cached_displays =
-      Shell::GetInstance()->display_configurator()->cached_displays();
-  for (size_t i = 0; i < cached_displays.size(); i++) {
-    if (cached_displays[i].touch_device_id == touch_display.touch_device_id()) {
-      state = &cached_displays[i];
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+  const std::vector<gfx::Display>& displays = display_manager->displays();
+  const DisplayInfo* info = NULL;
+  for (size_t i = 0; i < displays.size(); i++) {
+    const DisplayInfo& current_info =
+        display_manager->GetDisplayInfo(displays[i].id());
+    if (current_info.touch_device_id() == touch_display.touch_device_id()) {
+      info = &current_info;
       break;
     }
   }
 
-  if (!state || state->mirror_mode == state->display->native_mode() ||
-      !state->display->is_aspect_preserving_scaling()) {
+  if (!info || info->size_in_pixel() == info->GetNativeModeSize() ||
+      !info->is_aspect_preserving_scaling()) {
     return false;
   }
   return true;
 }
 
 // This function computes the mirror mode TouchTransformer for |touch_display|.
 // When internal monitor is applied a resolution that does not have
 // the same aspect ratio as its native resolution, there would be
 // blank regions in the letterboxing/pillarboxing mode.
 // The TouchTransformer will make sure the touch events on the blank region
@@ skipping 171 matching lines @@
 
 void TouchTransformerController::OnDisplaysInitialized() {
   UpdateTouchTransformer();
 }
 
 void TouchTransformerController::OnDisplayConfigurationChanged() {
   UpdateTouchTransformer();
 }
 
 }  // namespace ash