Re-write many calls to WrapUnique() with MakeUnique()

ash/display/display_change_observer_chromeos_unittest.cc

 // Copyright 2013 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_change_observer_chromeos.h"
 
 #include "ash/common/display/display_info.h"
 #include "base/memory/ptr_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/chromeos/display_configurator.h"
 #include "ui/display/chromeos/test/test_display_snapshot.h"
 #include "ui/display/types/display_mode.h"
 
 using ui::DisplayConfigurator;
 
 typedef testing::Test DisplayChangeObserverTest;
 
 namespace ash {
 
 TEST_F(DisplayChangeObserverTest, GetExternalDisplayModeList) {
   std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1200), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1200), false, 60));
 
   // All non-interlaced (as would be seen with different refresh rates).
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), false, 80)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), false, 80));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), false, 70)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), false, 70));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), false, 60));
 
   // Interlaced vs non-interlaced.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1280, 720), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1280, 720), true, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1280, 720), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1280, 720), false, 60));
 
   // Interlaced only.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 768), true, 70)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 768), true, 70));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 768), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 768), true, 60));
 
   // Mixed.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 600), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 600), true, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 600), false, 70)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 600), false, 70));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 600), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 600), false, 60));
 
   // Just one interlaced mode.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(640, 480), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(640, 480), true, 60));
 
   ui::TestDisplaySnapshot display_snapshot;
   display_snapshot.set_modes(std::move(modes));
 
   DisplayInfo::DisplayModeList display_modes =
       DisplayChangeObserver::GetExternalDisplayModeList(display_snapshot);
   ASSERT_EQ(6u, display_modes.size());
   EXPECT_EQ("640x480", display_modes[0]->size().ToString());
   EXPECT_TRUE(display_modes[0]->is_interlaced());
   EXPECT_EQ(display_modes[0]->refresh_rate(), 60);
@@ skipping 24 matching lines @@
 
   display_modes =
       DisplayChangeObserver::GetExternalDisplayModeList(display_snapshot);
   EXPECT_EQ(0u, display_modes.size());
 }
 
 TEST_F(DisplayChangeObserverTest, GetInternalDisplayModeList) {
   std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
   // Data picked from peppy.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1366, 768), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1366, 768), false, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 768), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 768), false, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(800, 600), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(800, 600), false, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(600, 600), false, 56.2)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(600, 600), false, 56.2));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(640, 480), false, 59.9)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(640, 480), false, 59.9));
 
   ui::TestDisplaySnapshot display_snapshot;
   display_snapshot.set_native_mode(modes[0].get());
   display_snapshot.set_modes(std::move(modes));
 
   DisplayInfo info(1, "", false);
   info.SetBounds(gfx::Rect(0, 0, 1366, 768));
 
   DisplayInfo::DisplayModeList display_modes =
       DisplayChangeObserver::GetInternalDisplayModeList(info, display_snapshot);
@@ skipping 21 matching lines @@
   EXPECT_EQ("1366x768", display_modes[4]->size().ToString());
   EXPECT_FALSE(display_modes[4]->native());
   EXPECT_NEAR(display_modes[4]->ui_scale(), 1.125, 0.01);
   EXPECT_EQ(display_modes[4]->refresh_rate(), 60);
 }
 
 TEST_F(DisplayChangeObserverTest, GetInternalHiDPIDisplayModeList) {
   std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
   // Data picked from peppy.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(2560, 1700), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(2560, 1700), false, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(2048, 1536), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(2048, 1536), false, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1440), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1440), false, 60));
 
   ui::TestDisplaySnapshot display_snapshot;
   display_snapshot.set_native_mode(modes[0].get());
   display_snapshot.set_modes(std::move(modes));
 
   DisplayInfo info(1, "", false);
   info.SetBounds(gfx::Rect(0, 0, 2560, 1700));
   info.set_device_scale_factor(2.0f);
 
   DisplayInfo::DisplayModeList display_modes =
@@ skipping 37 matching lines @@
   EXPECT_EQ("2560x1700", display_modes[7]->size().ToString());
   EXPECT_TRUE(display_modes[7]->native());
   EXPECT_NEAR(display_modes[7]->ui_scale(), 2.0, 0.01);
   EXPECT_EQ(display_modes[7]->refresh_rate(), 60);
 }
 
 TEST_F(DisplayChangeObserverTest, GetInternalDisplayModeList1_25) {
   std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
   // Data picked from peppy.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), false, 60));
 
   ui::TestDisplaySnapshot display_snapshot;
   display_snapshot.set_native_mode(modes[0].get());
   display_snapshot.set_modes(std::move(modes));
 
   DisplayInfo info(1, "", false);
   info.SetBounds(gfx::Rect(0, 0, 1920, 1080));
   info.set_device_scale_factor(1.25);
 
   DisplayInfo::DisplayModeList display_modes =
@@ skipping 21 matching lines @@
 
   EXPECT_EQ("1920x1080", display_modes[4]->size().ToString());
   EXPECT_FALSE(display_modes[4]->native());
   EXPECT_NEAR(display_modes[4]->ui_scale(), 1.25, 0.01);
   EXPECT_EQ(display_modes[4]->refresh_rate(), 60);
 }
 
 TEST_F(DisplayChangeObserverTest, GetExternalDisplayModeList4K) {
   std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(3840, 2160), false, 30)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(3840, 2160), false, 30));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1200), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1200), false, 60));
 
   // All non-interlaced (as would be seen with different refresh rates).
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), false, 80)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), false, 80));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), false, 70)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), false, 70));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), false, 60));
 
   // Interlaced vs non-interlaced.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1280, 720), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1280, 720), true, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1280, 720), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1280, 720), false, 60));
 
   // Interlaced only.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 768), true, 70)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 768), true, 70));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 768), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 768), true, 60));
 
   // Mixed.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 600), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 600), true, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 600), false, 70)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 600), false, 70));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1024, 600), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1024, 600), false, 60));
 
   // Just one interlaced mode.
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(640, 480), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(640, 480), true, 60));
 
   ui::TestDisplaySnapshot display_snapshot;
   display_snapshot.set_native_mode(modes[0].get());
   display_snapshot.set_modes(std::move(modes));
 
   DisplayInfo::DisplayModeList display_modes =
       DisplayChangeObserver::GetExternalDisplayModeList(display_snapshot);
   DisplayInfo info(1, "", false);
   info.SetDisplayModes(display_modes);  // Sort as external display.
   display_modes = info.display_modes();
@@ skipping 87 matching lines @@
   // Erroneous values should still work.
   EXPECT_EQ(1.0f, DisplayChangeObserver::FindDeviceScaleFactor(-100.0f));
   EXPECT_EQ(1.0f, DisplayChangeObserver::FindDeviceScaleFactor(0.0f));
   EXPECT_EQ(2.0f, DisplayChangeObserver::FindDeviceScaleFactor(10000.0f));
 }
 
 TEST_F(DisplayChangeObserverTest,
        FindExternalDisplayNativeModeWhenOverwritten) {
   std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), true, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), true, 60));
   modes.push_back(
-      base::WrapUnique(new ui::DisplayMode(gfx::Size(1920, 1080), false, 60)));
+      base::MakeUnique<ui::DisplayMode>(gfx::Size(1920, 1080), false, 60));
 
   ui::TestDisplaySnapshot display_snapshot;
   display_snapshot.set_native_mode(modes[0].get());
   display_snapshot.set_modes(std::move(modes));
 
   DisplayInfo::DisplayModeList display_modes =
       DisplayChangeObserver::GetExternalDisplayModeList(display_snapshot);
   ASSERT_EQ(2u, display_modes.size());
   EXPECT_EQ("1920x1080", display_modes[0]->size().ToString());
   EXPECT_FALSE(display_modes[0]->is_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]->is_interlaced());
   EXPECT_TRUE(display_modes[1]->native());
   EXPECT_EQ(display_modes[1]->refresh_rate(), 60);
 }
 
 }  // namespace ash