Make ash::DisplayMode more like ui::DisplayMode

ash/display/display_manager_unittest.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 "ash/accelerators/accelerator_commands_aura.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/display/display_info.h"
 #include "ash/common/material_design/material_design_controller.h"
@@ skipping 886 matching lines @@
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ("0,0 100x100", GetDisplayForId(10).bounds().ToString());
 }
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, DontRememberBestResolution) {
   int display_id = 1000;
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
-  std::vector<DisplayMode> display_modes;
-  display_modes.push_back(
-      DisplayMode(gfx::Size(1000, 500), 58.0f, false, true));
-  display_modes.push_back(
-      DisplayMode(gfx::Size(800, 300), 59.0f, false, false));
-  display_modes.push_back(
-      DisplayMode(gfx::Size(400, 500), 60.0f, false, false));
+  DisplayInfo::DisplayModeList display_modes;
+  display_modes.push_back(make_scoped_refptr(
+      new DisplayMode(gfx::Size(1000, 500), 58.0f, false, true)));
+  display_modes.push_back(make_scoped_refptr(
+      new DisplayMode(gfx::Size(800, 300), 59.0f, false, false)));
+  display_modes.push_back(make_scoped_refptr(
+      new DisplayMode(gfx::Size(400, 500), 60.0f, false, false)));
 
   native_display_info.SetDisplayModes(display_modes);
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
-  DisplayMode mode;
-  DisplayMode expected_mode;
-  expected_mode.size = gfx::Size(1000, 500);
-  EXPECT_FALSE(
-      display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  scoped_refptr<DisplayMode> mode;
+  scoped_refptr<DisplayMode> expected_mode(
+      new DisplayMode(gfx::Size(1000, 500), 0.0f, false, false));
+
+  mode = display_manager()->GetSelectedModeForDisplayId(display_id);
+  EXPECT_FALSE(!!mode);
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
   // Unsupported resolution.
   test::SetDisplayResolution(display_id, gfx::Size(800, 4000));
-  EXPECT_FALSE(
-      display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  mode = display_manager()->GetSelectedModeForDisplayId(display_id);
+  EXPECT_FALSE(!!mode);
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
   // Supported resolution.
   test::SetDisplayResolution(display_id, gfx::Size(800, 300));
-  EXPECT_TRUE(
-      display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
-  EXPECT_EQ("800x300", mode.size.ToString());
-  EXPECT_EQ(59.0f, mode.refresh_rate);
-  EXPECT_FALSE(mode.native);
-  expected_mode.size = gfx::Size(800, 300);
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  mode = display_manager()->GetSelectedModeForDisplayId(display_id);
+  EXPECT_TRUE(!!mode);
+  EXPECT_EQ("800x300", mode->size().ToString());
+  EXPECT_EQ(59.0f, mode->refresh_rate());
+  EXPECT_FALSE(mode->native());
+
+  expected_mode = new DisplayMode(gfx::Size(800, 300), 0.0f, false, false);
+
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
   // Best resolution.
   test::SetDisplayResolution(display_id, gfx::Size(1000, 500));
-  EXPECT_TRUE(
-      display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
-  EXPECT_EQ("1000x500", mode.size.ToString());
-  EXPECT_EQ(58.0f, mode.refresh_rate);
-  EXPECT_TRUE(mode.native);
-  expected_mode.size = gfx::Size(1000, 500);
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  mode = display_manager()->GetSelectedModeForDisplayId(display_id);
+  EXPECT_TRUE(!!mode);
+  EXPECT_EQ("1000x500", mode->size().ToString());
+  EXPECT_EQ(58.0f, mode->refresh_rate());
+  EXPECT_TRUE(mode->native());
+
+  expected_mode = new DisplayMode(gfx::Size(1000, 500), 0.0f, false, false);
+
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
 #endif  // defined(OS_CHROMEOS)
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, ResolutionFallback) {
   int display_id = 1000;
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
-  std::vector<DisplayMode> display_modes;
-  display_modes.push_back(
-      DisplayMode(gfx::Size(1000, 500), 58.0f, false, true));
-  display_modes.push_back(
-      DisplayMode(gfx::Size(800, 300), 59.0f, false, false));
-  display_modes.push_back(
-      DisplayMode(gfx::Size(400, 500), 60.0f, false, false));
+  DisplayInfo::DisplayModeList display_modes;
+  display_modes.push_back(make_scoped_refptr(
+      new DisplayMode(gfx::Size(1000, 500), 58.0f, false, true)));
+  display_modes.push_back(make_scoped_refptr(
+      new DisplayMode(gfx::Size(800, 300), 59.0f, false, false)));
+  display_modes.push_back(make_scoped_refptr(
+      new DisplayMode(gfx::Size(400, 500), 60.0f, false, false)));
 
-  std::vector<DisplayMode> copy = display_modes;
+  DisplayInfo::DisplayModeList copy = display_modes;
   native_display_info.SetDisplayModes(copy);
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   {
     test::SetDisplayResolution(display_id, gfx::Size(800, 300));
     DisplayInfo new_native_display_info =
         CreateDisplayInfo(display_id, gfx::Rect(0, 0, 400, 500));
     copy = display_modes;
     new_native_display_info.SetDisplayModes(copy);
     std::vector<DisplayInfo> new_display_info_list;
     new_display_info_list.push_back(new_native_display_info);
     display_manager()->OnNativeDisplaysChanged(new_display_info_list);
 
-    DisplayMode mode;
-    EXPECT_TRUE(
-        display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
-    EXPECT_EQ("400x500", mode.size.ToString());
-    EXPECT_EQ(60.0f, mode.refresh_rate);
-    EXPECT_FALSE(mode.native);
+    scoped_refptr<DisplayMode> mode =
+        display_manager()->GetSelectedModeForDisplayId(display_id);
+    EXPECT_TRUE(!!mode);
+    EXPECT_EQ("400x500", mode->size().ToString());
+    EXPECT_EQ(60.0f, mode->refresh_rate());
+    EXPECT_FALSE(mode->native());
   }
   {
     // Best resolution should find itself on the resolutions list.
     test::SetDisplayResolution(display_id, gfx::Size(800, 300));
     DisplayInfo new_native_display_info =
         CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
-    std::vector<DisplayMode> copy = display_modes;
+    DisplayInfo::DisplayModeList copy = display_modes;
     new_native_display_info.SetDisplayModes(copy);
     std::vector<DisplayInfo> new_display_info_list;
     new_display_info_list.push_back(new_native_display_info);
     display_manager()->OnNativeDisplaysChanged(new_display_info_list);
 
-    DisplayMode mode;
-    EXPECT_TRUE(
-        display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
-    EXPECT_EQ("1000x500", mode.size.ToString());
-    EXPECT_EQ(58.0f, mode.refresh_rate);
-    EXPECT_TRUE(mode.native);
+    scoped_refptr<DisplayMode> mode =
+        display_manager()->GetSelectedModeForDisplayId(display_id);
+    EXPECT_TRUE(!!mode);
+    EXPECT_EQ("1000x500", mode->size().ToString());
+    EXPECT_EQ(58.0f, mode->refresh_rate());
+    EXPECT_TRUE(mode->native());
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, Rotate) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("100x200/r,300x400/l");
   EXPECT_EQ("1,1 100x200", GetDisplayInfoAt(0).bounds_in_native().ToString());
@@ skipping 171 matching lines @@
   EXPECT_EQ("1280x850", display.bounds().size().ToString());
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, UIScaleWithDisplayMode) {
   int display_id = 1000;
 
   // Setup the display modes with UI-scale.
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1280, 800));
-  const DisplayMode base_mode(gfx::Size(1280, 800), 60.0f, false, false);
-  std::vector<DisplayMode> mode_list = CreateInternalDisplayModeList(base_mode);
+  const scoped_refptr<DisplayMode>& base_mode(
+      new DisplayMode(gfx::Size(1280, 800), 60.0f, false, false));
+  DisplayInfo::DisplayModeList mode_list =
+      CreateInternalDisplayModeList(base_mode);
   native_display_info.SetDisplayModes(mode_list);
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
-  DisplayMode expected_mode = base_mode;
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  scoped_refptr<DisplayMode> expected_mode = base_mode;
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 
   test::ScopedSetInternalDisplayId set_internal(display_id);
 
   SetDisplayUIScale(display_id, 1.5f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 1.125f);
   EXPECT_EQ(1.125f, GetDisplayInfoAt(0).configured_ui_scale());
-  expected_mode.ui_scale = 1.125f;
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+
+  expected_mode = new DisplayMode(
+      expected_mode->size(), expected_mode->refresh_rate(),
+      expected_mode->is_interlaced(), expected_mode->native(),
+      1.125f /* ui_scale */, expected_mode->device_scale_factor());
+
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
-  expected_mode.ui_scale = 0.8f;
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+
+  expected_mode = new DisplayMode(
+      expected_mode->size(), expected_mode->refresh_rate(),
+      expected_mode->is_interlaced(), expected_mode->native(),
+      0.8f /* ui_scale */, expected_mode->device_scale_factor());
+
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.75f);
   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.625f);
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
-  expected_mode.ui_scale = 0.625f;
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+
+  expected_mode = new DisplayMode(
+      expected_mode->size(), expected_mode->refresh_rate(),
+      expected_mode->is_interlaced(), expected_mode->native(),
+      0.625f /* ui_scale */, expected_mode->device_scale_factor());
+
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.6f);
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.5f);
   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).configured_ui_scale());
-  expected_mode.ui_scale = 0.5f;
-  EXPECT_TRUE(expected_mode.IsEquivalent(
+
+  expected_mode = new DisplayMode(
+      expected_mode->size(), expected_mode->refresh_rate(),
+      expected_mode->is_interlaced(), expected_mode->native(),
+      0.5f /* ui_scale */, expected_mode->device_scale_factor());
+
+  EXPECT_TRUE(expected_mode->IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
 
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, Use125DSFForUIScaling) {
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   test::ScopedSetInternalDisplayId set_internal(display_id);
   UpdateDisplay("1920x1080*1.25");
@@ skipping 23 matching lines @@
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   display_id++;
   test::ScopedSetInternalDisplayId set_internal(display_id);
 
   // Setup the display modes with UI-scale.
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1920, 1080));
   native_display_info.set_device_scale_factor(1.25);
 
-  const DisplayMode base_mode(gfx::Size(1920, 1080), 60.0f, false, false);
-  std::vector<DisplayMode> mode_list = CreateInternalDisplayModeList(base_mode);
+  const scoped_refptr<DisplayMode>& base_mode(
+      new DisplayMode(gfx::Size(1920, 1080), 60.0f, false, false));
+  DisplayInfo::DisplayModeList mode_list =
+      CreateInternalDisplayModeList(base_mode);
   native_display_info.SetDisplayModes(mode_list);
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
 
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 }
@@ skipping 11 matching lines @@
   const gfx::Insets dummy_overscan_insets;
   display_manager()->RegisterDisplayProperty(
       display_id, display::Display::ROTATE_0, 1.0f, &dummy_overscan_insets,
       gfx::Size(), 1.0f, ui::ColorCalibrationProfile());
 
   // Setup the display modes with UI-scale.
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1920, 1080));
   native_display_info.set_device_scale_factor(1.25);
 
-  const DisplayMode base_mode(gfx::Size(1920, 1080), 60.0f, false, false);
-  std::vector<DisplayMode> mode_list = CreateInternalDisplayModeList(base_mode);
+  const scoped_refptr<DisplayMode>& base_mode(
+      new DisplayMode(gfx::Size(1920, 1080), 60.0f, false, false));
+  DisplayInfo::DisplayModeList mode_list =
+      CreateInternalDisplayModeList(base_mode);
   native_display_info.SetDisplayModes(mode_list);
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
 
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, ResolutionChangeInUnifiedMode) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   display_manager()->SetUnifiedDesktopEnabled(true);
 
   UpdateDisplay("200x200, 400x400");
 
   int64_t unified_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   DisplayInfo info = display_manager()->GetDisplayInfo(unified_id);
   ASSERT_EQ(2u, info.display_modes().size());
-  EXPECT_EQ("400x200", info.display_modes()[0].size.ToString());
-  EXPECT_TRUE(info.display_modes()[0].native);
-  EXPECT_EQ("800x400", info.display_modes()[1].size.ToString());
-  EXPECT_FALSE(info.display_modes()[1].native);
+  EXPECT_EQ("400x200", info.display_modes()[0]->size().ToString());
+  EXPECT_TRUE(info.display_modes()[0]->native());
+  EXPECT_EQ("800x400", info.display_modes()[1]->size().ToString());
+  EXPECT_FALSE(info.display_modes()[1]->native());
   EXPECT_EQ(
       "400x200",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
-  DisplayMode active_mode =
+  scoped_refptr<DisplayMode> active_mode =
       display_manager()->GetActiveModeForDisplayId(unified_id);
-  EXPECT_EQ(1.0f, active_mode.ui_scale);
-  EXPECT_EQ("400x200", active_mode.size.ToString());
+  EXPECT_EQ(1.0f, active_mode->ui_scale());
+  EXPECT_EQ("400x200", active_mode->size().ToString());
 
   EXPECT_TRUE(test::SetDisplayResolution(unified_id, gfx::Size(800, 400)));
   EXPECT_EQ(
       "800x400",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
 
   active_mode = display_manager()->GetActiveModeForDisplayId(unified_id);
-  EXPECT_EQ(1.0f, active_mode.ui_scale);
-  EXPECT_EQ("800x400", active_mode.size.ToString());
+  EXPECT_EQ(1.0f, active_mode->ui_scale());
+  EXPECT_EQ("800x400", active_mode->size().ToString());
 
   // resolution change will not persist in unified desktop mode.
   UpdateDisplay("600x600, 200x200");
   EXPECT_EQ(
       "1200x600",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
   active_mode = display_manager()->GetActiveModeForDisplayId(unified_id);
-  EXPECT_EQ(1.0f, active_mode.ui_scale);
-  EXPECT_TRUE(active_mode.native);
-  EXPECT_EQ("1200x600", active_mode.size.ToString());
+  EXPECT_EQ(1.0f, active_mode->ui_scale());
+  EXPECT_TRUE(active_mode->native());
+  EXPECT_EQ("1200x600", active_mode->size().ToString());
 }
 
 // TODO(scottmg): RootWindow doesn't get resized on Windows
 // Ash. http://crbug.com/247916.
 #if defined(OS_CHROMEOS)
 TEST_P(DisplayManagerTest, UpdateMouseCursorAfterRotateZoom) {
   // Make sure just rotating will not change native location.
   UpdateDisplay("300x200,200x150");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   aura::Env* env = aura::Env::GetInstance();
@@ skipping 501 matching lines @@
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   display_manager()->SetUnifiedDesktopEnabled(true);
   display::Screen* screen = display::Screen::GetScreen();
 
   // 2nd display is 2x.
   UpdateDisplay("400x500,1000x800*2");
   DisplayInfo info =
       display_manager()->GetDisplayInfo(screen->GetPrimaryDisplay().id());
   EXPECT_EQ(2u, info.display_modes().size());
-  EXPECT_EQ("1640x800", info.display_modes()[0].size.ToString());
-  EXPECT_EQ(2.0f, info.display_modes()[0].device_scale_factor);
-  EXPECT_EQ("1025x500", info.display_modes()[1].size.ToString());
-  EXPECT_EQ(1.0f, info.display_modes()[1].device_scale_factor);
+  EXPECT_EQ("1640x800", info.display_modes()[0]->size().ToString());
+  EXPECT_EQ(2.0f, info.display_modes()[0]->device_scale_factor());
+  EXPECT_EQ("1025x500", info.display_modes()[1]->size().ToString());
+  EXPECT_EQ(1.0f, info.display_modes()[1]->device_scale_factor());
 
   // For 1x, 400 + 500 / 800 * 100 = 1025.
   EXPECT_EQ("1025x500", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("1025x500",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   accelerators::ZoomInternalDisplay(false);
   // (800 / 500 * 400 + 500) /2 = 820
   EXPECT_EQ("820x400", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("820x400",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 
   // 1st display is 2x.
   UpdateDisplay("1200x800*2,1000x1000");
   info = display_manager()->GetDisplayInfo(screen->GetPrimaryDisplay().id());
   EXPECT_EQ(2u, info.display_modes().size());
-  EXPECT_EQ("2000x800", info.display_modes()[0].size.ToString());
-  EXPECT_EQ(2.0f, info.display_modes()[0].device_scale_factor);
-  EXPECT_EQ("2500x1000", info.display_modes()[1].size.ToString());
-  EXPECT_EQ(1.0f, info.display_modes()[1].device_scale_factor);
+  EXPECT_EQ("2000x800", info.display_modes()[0]->size().ToString());
+  EXPECT_EQ(2.0f, info.display_modes()[0]->device_scale_factor());
+  EXPECT_EQ("2500x1000", info.display_modes()[1]->size().ToString());
+  EXPECT_EQ(1.0f, info.display_modes()[1]->device_scale_factor());
 
   // For 2x, (800 / 1000 * 1000 + 1200) / 2 = 1000
   EXPECT_EQ("1000x400", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("1000x400",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   accelerators::ZoomInternalDisplay(true);
   // 1000 / 800 * 1200 + 1000 = 2500
   EXPECT_EQ("2500x1000", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("2500x1000",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 
   // Both displays are 2x.
   // 1st display is 2x.
   UpdateDisplay("1200x800*2,1000x1000*2");
   info = display_manager()->GetDisplayInfo(screen->GetPrimaryDisplay().id());
   EXPECT_EQ(2u, info.display_modes().size());
-  EXPECT_EQ("2000x800", info.display_modes()[0].size.ToString());
-  EXPECT_EQ(2.0f, info.display_modes()[0].device_scale_factor);
-  EXPECT_EQ("2500x1000", info.display_modes()[1].size.ToString());
-  EXPECT_EQ(2.0f, info.display_modes()[1].device_scale_factor);
+  EXPECT_EQ("2000x800", info.display_modes()[0]->size().ToString());
+  EXPECT_EQ(2.0f, info.display_modes()[0]->device_scale_factor());
+  EXPECT_EQ("2500x1000", info.display_modes()[1]->size().ToString());
+  EXPECT_EQ(2.0f, info.display_modes()[1]->device_scale_factor());
 
   EXPECT_EQ("1000x400", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("1000x400",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   accelerators::ZoomInternalDisplay(true);
   EXPECT_EQ("1250x500", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("1250x500",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 
   // Both displays have the same physical height, with the first display
   // being 2x.
   UpdateDisplay("1000x800*2,300x800");
   info = display_manager()->GetDisplayInfo(screen->GetPrimaryDisplay().id());
   EXPECT_EQ(2u, info.display_modes().size());
-  EXPECT_EQ("1300x800", info.display_modes()[0].size.ToString());
-  EXPECT_EQ(2.0f, info.display_modes()[0].device_scale_factor);
-  EXPECT_EQ("1300x800", info.display_modes()[1].size.ToString());
-  EXPECT_EQ(1.0f, info.display_modes()[1].device_scale_factor);
+  EXPECT_EQ("1300x800", info.display_modes()[0]->size().ToString());
+  EXPECT_EQ(2.0f, info.display_modes()[0]->device_scale_factor());
+  EXPECT_EQ("1300x800", info.display_modes()[1]->size().ToString());
+  EXPECT_EQ(1.0f, info.display_modes()[1]->device_scale_factor());
 
   EXPECT_EQ("650x400", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("650x400",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   accelerators::ZoomInternalDisplay(true);
   EXPECT_EQ("1300x800", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("1300x800",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 
   // Both displays have the same physical height, with the second display
   // being 2x.
   UpdateDisplay("1000x800,300x800*2");
   EXPECT_EQ(2u, info.display_modes().size());
-  EXPECT_EQ("1300x800", info.display_modes()[0].size.ToString());
-  EXPECT_EQ(2.0f, info.display_modes()[0].device_scale_factor);
-  EXPECT_EQ("1300x800", info.display_modes()[1].size.ToString());
-  EXPECT_EQ(1.0f, info.display_modes()[1].device_scale_factor);
+  EXPECT_EQ("1300x800", info.display_modes()[0]->size().ToString());
+  EXPECT_EQ(2.0f, info.display_modes()[0]->device_scale_factor());
+  EXPECT_EQ("1300x800", info.display_modes()[1]->size().ToString());
+  EXPECT_EQ(1.0f, info.display_modes()[1]->device_scale_factor());
 
   EXPECT_EQ("1300x800", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("1300x800",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   accelerators::ZoomInternalDisplay(false);
   EXPECT_EQ("650x400", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("650x400",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 }
 
@@ skipping 89 matching lines @@
 
   display_info_list.clear();
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->active_display_list().size());
 
   EXPECT_TRUE(display_manager()->IsActiveDisplayId(external_id));
   EXPECT_FALSE(display_manager()->IsActiveDisplayId(internal_id));
 
   const DisplayInfo& info = display_manager()->GetDisplayInfo(internal_id);
-  DisplayMode mode;
 
-  EXPECT_FALSE(GetDisplayModeForNextUIScale(info, true, &mode));
-  EXPECT_FALSE(GetDisplayModeForNextUIScale(info, false, &mode));
+  EXPECT_FALSE(!!GetDisplayModeForNextUIScale(info, true));
+  EXPECT_FALSE(!!GetDisplayModeForNextUIScale(info, false));
   EXPECT_FALSE(SetDisplayUIScale(internal_id, 1.0f));
 
   DisplayInfo invalid_info;
-  EXPECT_FALSE(GetDisplayModeForNextUIScale(invalid_info, true, &mode));
-  EXPECT_FALSE(GetDisplayModeForNextUIScale(invalid_info, false, &mode));
+  EXPECT_FALSE(!!GetDisplayModeForNextUIScale(invalid_info, true));
+  EXPECT_FALSE(!!GetDisplayModeForNextUIScale(invalid_info, false));
   EXPECT_FALSE(SetDisplayUIScale(display::Display::kInvalidDisplayID, 1.0f));
 }
 
 // Make sure that bad layout information is ignored and does not crash.
 TEST_P(DisplayManagerTest, DontRegisterBadConfig) {
   if (!SupportsMultipleDisplays())
     return;
   display::DisplayIdList list = ash::test::CreateDisplayIdList2(1, 2);
   display::DisplayLayoutBuilder builder(1);
   builder.AddDisplayPlacement(2, 1, display::DisplayPlacement::LEFT, 0);
@@ skipping 213 matching lines @@
   const display::DisplayLayout& stored =
       layout_store->GetRegisteredDisplayLayout(list);
 
   EXPECT_EQ(id1, stored.placement_list[0].parent_display_id);
   EXPECT_EQ(id2, stored.placement_list[0].display_id);
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash