Preserve the native mode when parsing external display modes

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"
@@ skipping 77 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;
 
-  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 (touch_display.size_in_pixel() == touch_display.GetNativeModeSize() ||
+      !touch_display.is_aspect_preserving_scaling()) {
+    return false;
   }
 
-  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
 // have negative coordinates and touch events within the chrome region
 // have the correct positive coordinates.
 gfx::Transform TouchTransformerController::GetMirrorModeTouchTransformer(
     const DisplayInfo& touch_display) const {
   gfx::Transform ctm;
   if (!ShouldComputeMirrorModeTouchTransformer(touch_display))
     return ctm;
 
   float mirror_width = touch_display.bounds_in_native().width();
   float mirror_height = touch_display.bounds_in_native().height();
-  float native_width = 0;
-  float native_height = 0;
-
-  std::vector<DisplayMode> modes = touch_display.display_modes();
-  for (size_t i = 0; i < modes.size(); i++) {
-       if (modes[i].native) {
-         native_width = modes[i].size.width();
-         native_height = modes[i].size.height();
-         break;
-       }
-  }
+  gfx::Size native_mode_size = touch_display.GetNativeModeSize();
+  float native_width = native_mode_size.width();
+  float native_height = native_mode_size.height();
 
   if (native_height == 0.0 || mirror_height == 0.0 ||
       native_width == 0.0 || mirror_width == 0.0)
     return ctm;
 
-  float native_ar = static_cast<float>(native_width) /
-      static_cast<float>(native_height);
-  float mirror_ar = static_cast<float>(mirror_width) /
-      static_cast<float>(mirror_height);
+  float native_ar = native_width / native_height;
+  float mirror_ar = mirror_width / mirror_height;
 
   if (mirror_ar > native_ar) {  // Letterboxing
     // Translate before scale.
     ctm.Translate(0.0, (1.0 - mirror_ar / native_ar) * 0.5 * mirror_height);
     ctm.Scale(1.0, mirror_ar / native_ar);
     return ctm;
   }
 
   if (native_ar > mirror_ar) {  // Pillarboxing
     // Translate before scale.
@@ skipping 131 matching lines @@
 
 void TouchTransformerController::OnDisplaysInitialized() {
   UpdateTouchTransformer();
 }
 
 void TouchTransformerController::OnDisplayConfigurationChanged() {
   UpdateTouchTransformer();
 }
 
 }  // namespace ash