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"
 
 namespace ash {
 
 namespace {
 
 DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
+gfx::Size GetNativeModeSize(const DisplayInfo& display) {
+  const std::vector<DisplayMode>& modes = display.display_modes();
+  for (size_t i = 0; i < modes.size(); ++i) {
+    if (modes[i].native) {

[Daniel Erat, 2014/06/17 21:59:18]

nit: remove these curly brackets

[dnicoara, 2014/06/20 17:01:05]

Done.

+      return modes[i].size;
+    }
+  }
+
+  return gfx::Size();
+}
+
 }  // namespace
 
 // This function computes the extended mode TouchTransformer for
 // |touch_display|. The TouchTransformer maps the touch event position
 // from framebuffer size to the display size.
 gfx::Transform
 TouchTransformerController::GetExtendedModeTouchTransformer(
     const DisplayInfo& touch_display, const gfx::Size& fb_size) const {
   gfx::Transform ctm;
   if (touch_display.touch_device_id() == 0 ||
       fb_size.width() == 0.0 ||
       fb_size.height() == 0.0)
     return ctm;
   float width = touch_display.bounds_in_native().width();
   float height = touch_display.bounds_in_native().height();
   ctm.Scale(width / fb_size.width(), height / fb_size.height());
   return ctm;
 }
 
 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() == GetNativeModeSize(*info) ||
+      !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 146 matching lines @@
 
 void TouchTransformerController::OnDisplaysInitialized() {
   UpdateTouchTransformer();
 }
 
 void TouchTransformerController::OnDisplayConfigurationChanged() {
   UpdateTouchTransformer();
 }
 
 }  // namespace ash