Preserve the native mode when parsing external display modes

If the native mode is interlaced it can be replaced by a non-interlaced
mode (which will not show as native).

BUG=none

Review URL: https://codereview.chromium.org/635403002

Cr-Commit-Position: refs/heads/master@{#299114}

ash/display/display_change_observer_chromeos.cc

@@ -136,6 +136,18 @@ std::vector<DisplayMode> DisplayChangeObserver::GetExternalDisplayModeList(
     display_mode_list.push_back(iter->second);
   }
 
+  if (output.display->native_mode()) {
+    const std::pair<int, int> size(native_mode.size.width(),
+                                   native_mode.size.height());
+    DisplayModeMap::iterator it = display_mode_map.find(size);
+    DCHECK(it != display_mode_map.end())
+        << "Native mode must be part of the mode list.";
+
+    // If the native mode was replaced re-add it.
+    if (!it->second.native)
+      display_mode_list.push_back(native_mode);
+  }
+
   if (native_mode.size.width() >= kMinimumWidthFor4K) {
     for (size_t i = 0; i < arraysize(kAdditionalDeviceScaleFactorsFor4k);
          ++i) {

ash/display/display_change_observer_chromeos_unittest.cc

@@ -313,6 +313,7 @@ TEST_F(DisplayChangeObserverTest, GetExternalDisplayModeList4K) {
   // Outputs without any modes shouldn't cause a crash.
   modes.clear();
   display_snapshot.set_modes(modes.get());
+  display_snapshot.set_native_mode(NULL);
 
   display_modes = DisplayChangeObserver::GetExternalDisplayModeList(output);
   EXPECT_EQ(0u, display_modes.size());
@@ -343,4 +344,30 @@ TEST_F(DisplayChangeObserverTest, FindDeviceScaleFactor) {
   EXPECT_EQ(2.0f, DisplayChangeObserver::FindDeviceScaleFactor(10000.0f));
 }
 
+TEST_F(DisplayChangeObserverTest,
+       FindExternalDisplayNativeModeWhenOverwritten) {
+  ScopedVector<const ui::DisplayMode> modes;
+  modes.push_back(new ui::DisplayMode(gfx::Size(1920, 1080), true, 60));
+  modes.push_back(new ui::DisplayMode(gfx::Size(1920, 1080), false, 60));
+
+  ui::TestDisplaySnapshot display_snapshot;
+  display_snapshot.set_modes(modes.get());
+  display_snapshot.set_native_mode(modes[0]);
+  DisplayConfigurator::DisplayState output;
+  output.display = &display_snapshot;
+
+  std::vector<DisplayMode> display_modes =
+      DisplayChangeObserver::GetExternalDisplayModeList(output);
+  ASSERT_EQ(2u, display_modes.size());
+  EXPECT_EQ("1920x1080", display_modes[0].size.ToString());
+  EXPECT_FALSE(display_modes[0].interlaced);
+  EXPECT_FALSE(display_modes[0].native);
+  EXPECT_EQ(display_modes[0].refresh_rate, 60);
+
+  EXPECT_EQ("1920x1080", display_modes[1].size.ToString());
+  EXPECT_TRUE(display_modes[1].interlaced);
+  EXPECT_TRUE(display_modes[1].native);
+  EXPECT_EQ(display_modes[1].refresh_rate, 60);
+}
+
 }  // namespace ash

ash/touch/touch_transformer_controller.cc

@@ -95,22 +95,11 @@ bool TouchTransformerController::ShouldComputeMirrorModeTouchTransformer(
   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 (!info || info->size_in_pixel() == info->GetNativeModeSize() ||
-      !info->is_aspect_preserving_scaling()) {
+  if (touch_display.size_in_pixel() == touch_display.GetNativeModeSize() ||
+      !touch_display.is_aspect_preserving_scaling()) {
     return false;
   }
+
   return true;
 }
 
@@ -129,26 +118,16 @@ gfx::Transform TouchTransformerController::GetMirrorModeTouchTransformer(
 
   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.