Delete TestDisplaySnapshot and update tests.

Replace TestDisplaySnapshot with FakeDisplaySnapshot in tests.
FakeDisplaySnapshot has builder that makes it more readable. Delete an
unncessary build target along with TestDisplaySnapshot.

Tests should be unchanged for the most part. One test was split into two
tests where two very different behaviours were being checked.

Also update tests to use C++11 features where possible. Mostly replacing
raw pointers with unique_ptr<> and NULL with nullptr.

BUG=none

Review-Url: https://codereview.chromium.org/2407153008
Cr-Commit-Position: refs/heads/master@{#427147}

ash/BUILD.gn

@@ -1167,7 +1167,6 @@ test("ash_content_unittests") {
       "//ui/chromeos",
       "//ui/display",
       "//ui/display:test_support",
-      "//ui/display:test_util",
     ]
   }
 }
@@ -1408,7 +1407,6 @@ test("ash_unittests") {
       "//ui/chromeos",
       "//ui/display",
       "//ui/display:test_support",
-      "//ui/display:test_util",
     ]
   } else {
     sources -= [

ash/display/display_color_manager_chromeos_unittest.cc

@@ -17,13 +17,14 @@
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/chromeos/test/action_logger_util.h"
-#include "ui/display/chromeos/test/test_display_snapshot.h"
 #include "ui/display/chromeos/test/test_native_display_delegate.h"
+#include "ui/display/fake_display_snapshot.h"
 
 namespace ash {
 
 namespace {
 
+constexpr gfx::Size kDisplaySize(1024, 768);
 const char kResetGammaAction[] = "*set_color_correction(id=123)";
 const char kSetGammaAction[] =
     "set_color_correction(id=123,gamma[0]*gamma[255]=???????????\?)";
@@ -165,21 +166,16 @@ class DisplayColorManagerTest : public testing::Test {
 };
 
 TEST_F(DisplayColorManagerTest, VCGTOnly) {
-  std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
-  ui::DisplayMode mode(gfx::Size(1024, 768), false, 60.0f);
-  modes.push_back(mode.Clone());
-  const ui::DisplayMode* mode_ptr = modes.back().get();
-  ui::TestDisplaySnapshot snapshot(
-      123, gfx::Point(0, 0),                /* origin */
-      gfx::Size(0, 0),                      /* physical_size */
-      ui::DISPLAY_CONNECTION_TYPE_INTERNAL, /* type */
-      false,                                /* is_aspect_preserving_scaling */
-      0x06af5c10,                           /* product_id */
-      false,                                /* has_color_correction_matrix */
-      std::move(modes),                     /* modes */
-      mode_ptr /* current_mode */, mode_ptr /* native_mode */);
-  std::vector<ui::DisplaySnapshot*> outputs;
-  outputs.push_back(&snapshot);
+  std::unique_ptr<ui::DisplaySnapshot> snapshot =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(123)
+          .SetNativeMode(kDisplaySize)
+          .SetCurrentMode(kDisplaySize)
+          .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+          .SetHasColorCorrectionMatrix(false)
+          .SetProductId(0x06af5c10)
+          .Build();
+  std::vector<ui::DisplaySnapshot*> outputs({snapshot.get()});
   native_display_delegate_->set_outputs(outputs);
 
   configurator_.OnConfigurationChanged();
@@ -192,21 +188,16 @@ TEST_F(DisplayColorManagerTest, VCGTOnly) {
 }
 
 TEST_F(DisplayColorManagerTest, VCGTOnlyWithPlatformCTM) {
-  std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
-  ui::DisplayMode mode(gfx::Size(1024, 768), false, 60.0f);
-  modes.push_back(mode.Clone());
-  const ui::DisplayMode* mode_ptr = modes.back().get();
-  ui::TestDisplaySnapshot snapshot(
-      123, gfx::Point(0, 0),                /* origin */
-      gfx::Size(0, 0),                      /* physical_size */
-      ui::DISPLAY_CONNECTION_TYPE_INTERNAL, /* type */
-      false,                                /* is_aspect_preserving_scaling */
-      0x06af5c10,                           /* product_id */
-      true,                                 /* has_color_correction_matrix */
-      std::move(modes),                     /* modes */
-      mode_ptr /* current_mode */, mode_ptr /* native_mode */);
-  std::vector<ui::DisplaySnapshot*> outputs;
-  outputs.push_back(&snapshot);
+  std::unique_ptr<ui::DisplaySnapshot> snapshot =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(123)
+          .SetNativeMode(kDisplaySize)
+          .SetCurrentMode(kDisplaySize)
+          .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+          .SetHasColorCorrectionMatrix(true)
+          .SetProductId(0x06af5c10)
+          .Build();
+  std::vector<ui::DisplaySnapshot*> outputs({snapshot.get()});
   native_display_delegate_->set_outputs(outputs);
 
   log_->GetActionsAndClear();
@@ -220,21 +211,16 @@ TEST_F(DisplayColorManagerTest, VCGTOnlyWithPlatformCTM) {
 }
 
 TEST_F(DisplayColorManagerTest, FullWithPlatformCTM) {
-  std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
-  ui::DisplayMode mode(gfx::Size(1024, 768), false, 60.0f);
-  modes.push_back(mode.Clone());
-  const ui::DisplayMode* mode_ptr = modes.back().get();
-  ui::TestDisplaySnapshot snapshot(
-      123, gfx::Point(0, 0),                /* origin */
-      gfx::Size(0, 0),                      /* physical_size */
-      ui::DISPLAY_CONNECTION_TYPE_INTERNAL, /* type */
-      false,                                /* is_aspect_preserving_scaling */
-      0x4c834a42,                           /* product_id */
-      true,                                 /* has_color_correction_matrix */
-      std::move(modes),                     /* modes */
-      mode_ptr /* current_mode */, mode_ptr /* native_mode */);
-  std::vector<ui::DisplaySnapshot*> outputs;
-  outputs.push_back(&snapshot);
+  std::unique_ptr<ui::DisplaySnapshot> snapshot =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(123)
+          .SetNativeMode(kDisplaySize)
+          .SetCurrentMode(kDisplaySize)
+          .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+          .SetHasColorCorrectionMatrix(true)
+          .SetProductId(0x4c834a42)
+          .Build();
+  std::vector<ui::DisplaySnapshot*> outputs({snapshot.get()});
   native_display_delegate_->set_outputs(outputs);
 
   configurator_.OnConfigurationChanged();
@@ -248,21 +234,16 @@ TEST_F(DisplayColorManagerTest, FullWithPlatformCTM) {
 }
 
 TEST_F(DisplayColorManagerTest, FullWithoutPlatformCTM) {
-  std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
-  ui::DisplayMode mode(gfx::Size(1024, 768), false, 60.0f);
-  modes.push_back(mode.Clone());
-  const ui::DisplayMode* mode_ptr = modes.back().get();
-  ui::TestDisplaySnapshot snapshot(
-      123, gfx::Point(0, 0),                /* origin */
-      gfx::Size(0, 0),                      /* physical_size */
-      ui::DISPLAY_CONNECTION_TYPE_INTERNAL, /* type */
-      false,                                /* is_aspect_preserving_scaling */
-      0x4c834a42,                           /* product_id */
-      false,                                /* has_color_correction_matrix */
-      std::move(modes),                     /* modes */
-      mode_ptr /* current_mode */, mode_ptr /* native_mode */);
-  std::vector<ui::DisplaySnapshot*> outputs;
-  outputs.push_back(&snapshot);
+  std::unique_ptr<ui::DisplaySnapshot> snapshot =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(123)
+          .SetNativeMode(kDisplaySize)
+          .SetCurrentMode(kDisplaySize)
+          .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+          .SetHasColorCorrectionMatrix(false)
+          .SetProductId(0x4c834a42)
+          .Build();
+  std::vector<ui::DisplaySnapshot*> outputs({snapshot.get()});
   native_display_delegate_->set_outputs(outputs);
 
   configurator_.OnConfigurationChanged();
@@ -275,21 +256,16 @@ TEST_F(DisplayColorManagerTest, FullWithoutPlatformCTM) {
 }
 
 TEST_F(DisplayColorManagerTest, NoMatchProductID) {
-  std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
-  ui::DisplayMode mode(gfx::Size(1024, 768), false, 60.0f);
-  modes.push_back(mode.Clone());
-  const ui::DisplayMode* mode_ptr = modes.back().get();
-  ui::TestDisplaySnapshot snapshot(
-      123, gfx::Point(0, 0),                /* origin */
-      gfx::Size(0, 0),                      /* physical_size */
-      ui::DISPLAY_CONNECTION_TYPE_INTERNAL, /* type */
-      false,                                /* is_aspect_preserving_scaling */
-      0,                                    /* product_id */
-      false,                                /* has_color_correction_matrix */
-      std::move(modes),                     /* modes */
-      mode_ptr /* current_mode */, mode_ptr /* native_mode */);
-  std::vector<ui::DisplaySnapshot*> outputs;
-  outputs.push_back(&snapshot);
+  std::unique_ptr<ui::DisplaySnapshot> snapshot =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(123)
+          .SetNativeMode(kDisplaySize)
+          .SetCurrentMode(kDisplaySize)
+          .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+          .SetHasColorCorrectionMatrix(false)
+          .SetProductId(0)
+          .Build();
+  std::vector<ui::DisplaySnapshot*> outputs({snapshot.get()});
   native_display_delegate_->set_outputs(outputs);
 
   configurator_.OnConfigurationChanged();
@@ -303,21 +279,16 @@ TEST_F(DisplayColorManagerTest, NoMatchProductID) {
 }
 
 TEST_F(DisplayColorManagerTest, NoVCGT) {
-  std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
-  ui::DisplayMode mode(gfx::Size(1024, 768), false, 60.0f);
-  modes.push_back(mode.Clone());
-  const ui::DisplayMode* mode_ptr = modes.back().get();
-  ui::TestDisplaySnapshot snapshot(
-      123, gfx::Point(0, 0),                /* origin */
-      gfx::Size(0, 0),                      /* physical_size */
-      ui::DISPLAY_CONNECTION_TYPE_INTERNAL, /* type */
-      false,                                /* is_aspect_preserving_scaling */
-      0x0dae3211,                           /* product_id */
-      false,                                /* has_color_correction_matrix */
-      std::move(modes),                     /* modes */
-      mode_ptr /* current_mode */, mode_ptr /* native_mode */);
-  std::vector<ui::DisplaySnapshot*> outputs;
-  outputs.push_back(&snapshot);
+  std::unique_ptr<ui::DisplaySnapshot> snapshot =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(123)
+          .SetNativeMode(kDisplaySize)
+          .SetCurrentMode(kDisplaySize)
+          .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+          .SetHasColorCorrectionMatrix(false)
+          .SetProductId(0x0dae3211)
+          .Build();
+  std::vector<ui::DisplaySnapshot*> outputs({snapshot.get()});
   native_display_delegate_->set_outputs(outputs);
 
   configurator_.OnConfigurationChanged();

ash/display/projecting_observer_chromeos_unittest.cc

@@ -7,21 +7,25 @@
 #include "base/memory/scoped_vector.h"
 #include "chromeos/dbus/fake_power_manager_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/display/chromeos/test/test_display_snapshot.h"
+#include "ui/display/fake_display_snapshot.h"
 
 namespace ash {
 namespace {
 
-ui::TestDisplaySnapshot* CreateInternalSnapshot() {
-  ui::TestDisplaySnapshot* output = new ui::TestDisplaySnapshot();
-  output->set_type(ui::DISPLAY_CONNECTION_TYPE_INTERNAL);
-  return output;
+std::unique_ptr<ui::DisplaySnapshot> CreateInternalSnapshot() {
+  return display::FakeDisplaySnapshot::Builder()
+      .SetId(123)
+      .SetNativeMode(gfx::Size(1024, 768))
+      .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+      .Build();
 }
 
-ui::TestDisplaySnapshot* CreateVGASnapshot() {
-  ui::TestDisplaySnapshot* output = new ui::TestDisplaySnapshot();
-  output->set_type(ui::DISPLAY_CONNECTION_TYPE_VGA);
-  return output;
+std::unique_ptr<ui::DisplaySnapshot> CreateVGASnapshot() {
+  return display::FakeDisplaySnapshot::Builder()
+      .SetId(456)
+      .SetNativeMode(gfx::Size(1024, 768))
+      .SetType(ui::DISPLAY_CONNECTION_TYPE_VGA)
+      .Build();
 }
 
 class ProjectingObserverTest : public testing::Test {

ash/wm/lock_state_controller_unittest.cc

@@ -24,7 +24,7 @@
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "ui/display/chromeos/display_configurator.h"
-#include "ui/display/chromeos/test/test_display_snapshot.h"
+#include "ui/display/fake_display_snapshot.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/size.h"
@@ -887,30 +887,30 @@ TEST_F(LockStateControllerTest, IgnorePowerButtonIfScreenIsOff) {
 }
 
 TEST_F(LockStateControllerTest, HonorPowerButtonInDockedMode) {
-  std::vector<std::unique_ptr<const ui::DisplayMode>> modes;
-  modes.push_back(
-      base::MakeUnique<ui::DisplayMode>(gfx::Size(1, 1), false, 60.0f));
-
   // Create two outputs, the first internal and the second external.
   ui::DisplayConfigurator::DisplayStateList outputs;
-  ui::TestDisplaySnapshot internal_display;
-  internal_display.set_type(ui::DISPLAY_CONNECTION_TYPE_INTERNAL);
-  internal_display.set_modes(std::move(modes));
-  outputs.push_back(&internal_display);
-
-  modes.clear();
-  modes.push_back(
-      base::MakeUnique<ui::DisplayMode>(gfx::Size(1, 1), false, 60.0f));
-  ui::TestDisplaySnapshot external_display;
-  external_display.set_type(ui::DISPLAY_CONNECTION_TYPE_HDMI);
-  external_display.set_modes(std::move(modes));
-  outputs.push_back(&external_display);
+
+  std::unique_ptr<ui::DisplaySnapshot> internal_display =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(123)
+          .SetNativeMode(gfx::Size(1, 1))
+          .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+          .Build();
+  outputs.push_back(internal_display.get());
+
+  std::unique_ptr<ui::DisplaySnapshot> external_display =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(456)
+          .SetNativeMode(gfx::Size(1, 1))
+          .SetType(ui::DISPLAY_CONNECTION_TYPE_HDMI)
+          .Build();
+  outputs.push_back(external_display.get());
 
   // When all of the displays are turned off (e.g. due to user inactivity), the
   // power button should be ignored.
   power_button_controller_->OnScreenBrightnessChanged(0.0);
-  internal_display.set_current_mode(nullptr);
-  external_display.set_current_mode(nullptr);
+  internal_display->set_current_mode(nullptr);
+  external_display->set_current_mode(nullptr);
   power_button_controller_->OnDisplayModeChanged(outputs);
   PressPowerButton();
   EXPECT_FALSE(test_api_->is_animating_lock());
@@ -919,7 +919,7 @@ TEST_F(LockStateControllerTest, HonorPowerButtonInDockedMode) {
   // When the screen brightness is 0% but the external display is still turned
   // on (indicating either docked mode or the user having manually decreased the
   // brightness to 0%), the power button should still be handled.
-  external_display.set_current_mode(external_display.modes().back().get());
+  external_display->set_current_mode(external_display->modes().back().get());
   power_button_controller_->OnDisplayModeChanged(outputs);
   PressPowerButton();
   EXPECT_TRUE(test_api_->is_animating_lock());

ui/display/BUILD.gn

@@ -126,28 +126,6 @@ component("display") {
   }
 }
 
-if (is_chromeos) {
-  component("test_util") {
-    output_name = "display_test_util"
-    sources = [
-      "chromeos/test/test_display_snapshot.cc",
-      "chromeos/test/test_display_snapshot.h",
-    ]
-
-    defines = [ "DISPLAY_IMPLEMENTATION" ]
-
-    public_deps = [
-      ":display",
-    ]
-    deps = [
-      "//base",
-      "//ui/display/types",
-      "//ui/gfx",
-      "//ui/gfx/geometry",
-    ]
-  }
-}
-
 static_library("test_support") {
   testonly = true
   sources = [
@@ -220,10 +198,6 @@ test("display_unittests") {
     "//ui/gfx/geometry",
   ]
 
-  if (is_chromeos) {
-    deps += [ ":test_util" ]
-  }
-
   if (use_aura) {
     sources -= [ "screen_unittest.cc" ]
   }

ui/display/chromeos/apply_content_protection_task_unittest.cc

@@ -13,8 +13,8 @@
 #include "ui/display/chromeos/display_layout_manager.h"
 #include "ui/display/chromeos/test/action_logger_util.h"
 #include "ui/display/chromeos/test/test_display_layout_manager.h"
-#include "ui/display/chromeos/test/test_display_snapshot.h"
 #include "ui/display/chromeos/test/test_native_display_delegate.h"
+#include "ui/display/fake_display_snapshot.h"
 
 namespace ui {
 namespace test {
@@ -24,11 +24,11 @@ namespace {
 std::unique_ptr<DisplaySnapshot> CreateDisplaySnapshot(
     int64_t id,
     DisplayConnectionType type) {
-  std::unique_ptr<TestDisplaySnapshot> display(new TestDisplaySnapshot());
-  display->set_display_id(id);
-  display->set_type(type);
-
-  return std::move(display);
+  return display::FakeDisplaySnapshot::Builder()
+      .SetId(id)
+      .SetNativeMode(gfx::Size(1024, 768))
+      .SetType(type)
+      .Build();
 }
 
 }  // namespace

ui/display/chromeos/configure_displays_task_unittest.cc

@@ -11,8 +11,8 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/chromeos/configure_displays_task.h"
 #include "ui/display/chromeos/test/action_logger_util.h"
-#include "ui/display/chromeos/test/test_display_snapshot.h"
 #include "ui/display/chromeos/test/test_native_display_delegate.h"
+#include "ui/display/fake_display_snapshot.h"
 
 namespace ui {
 namespace test {
@@ -27,20 +27,18 @@ class ConfigureDisplaysTaskTest : public testing::Test {
         status_(ConfigureDisplaysTask::ERROR),
         small_mode_(gfx::Size(1366, 768), false, 60.0f),
         big_mode_(gfx::Size(2560, 1600), false, 60.0f) {
-    std::vector<std::unique_ptr<const DisplayMode>> modes;
-    modes.push_back(small_mode_.Clone());
-    displays_[0].set_current_mode(modes.front().get());
-    displays_[0].set_native_mode(modes.front().get());
-    displays_[0].set_modes(std::move(modes));
-    displays_[0].set_display_id(123);
-
-    modes.clear();
-    modes.push_back(small_mode_.Clone());
-    modes.push_back(big_mode_.Clone());
-    displays_[1].set_current_mode(modes.back().get());
-    displays_[1].set_native_mode(modes.back().get());
-    displays_[1].set_modes(std::move(modes));
-    displays_[1].set_display_id(456);
+    displays_[0] = display::FakeDisplaySnapshot::Builder()
+                       .SetId(123)
+                       .SetNativeMode(small_mode_.Clone())
+                       .SetCurrentMode(small_mode_.Clone())
+                       .Build();
+
+    displays_[1] = display::FakeDisplaySnapshot::Builder()
+                       .SetId(456)
+                       .SetNativeMode(big_mode_.Clone())
+                       .SetCurrentMode(big_mode_.Clone())
+                       .AddMode(small_mode_.Clone())
+                       .Build();
   }
   ~ConfigureDisplaysTaskTest() override {}
 
@@ -60,7 +58,7 @@ class ConfigureDisplaysTaskTest : public testing::Test {
   const DisplayMode small_mode_;
   const DisplayMode big_mode_;
 
-  TestDisplaySnapshot displays_[2];
+  std::unique_ptr<DisplaySnapshot> displays_[2];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConfigureDisplaysTaskTest);
@@ -87,13 +85,14 @@ TEST_F(ConfigureDisplaysTaskTest, ConfigureWithOneDisplay) {
       &ConfigureDisplaysTaskTest::ConfigureCallback, base::Unretained(this));
 
   std::vector<DisplayConfigureRequest> requests(
-      1, DisplayConfigureRequest(&displays_[0], &small_mode_, gfx::Point()));
+      1,
+      DisplayConfigureRequest(displays_[0].get(), &small_mode_, gfx::Point()));
   ConfigureDisplaysTask task(&delegate_, requests, callback);
   task.Run();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(ConfigureDisplaysTask::SUCCESS, status_);
-  EXPECT_EQ(GetCrtcAction(displays_[0], &small_mode_, gfx::Point()),
+  EXPECT_EQ(GetCrtcAction(*displays_[0], &small_mode_, gfx::Point()),
             log_.GetActionsAndClear());
 }
 
@@ -104,7 +103,7 @@ TEST_F(ConfigureDisplaysTaskTest, ConfigureWithTwoDisplay) {
   std::vector<DisplayConfigureRequest> requests;
   for (size_t i = 0; i < arraysize(displays_); ++i) {
     requests.push_back(DisplayConfigureRequest(
-        &displays_[i], displays_[i].native_mode(), gfx::Point()));
+        displays_[i].get(), displays_[i]->native_mode(), gfx::Point()));
   }
 
   ConfigureDisplaysTask task(&delegate_, requests, callback);
@@ -114,8 +113,9 @@ TEST_F(ConfigureDisplaysTaskTest, ConfigureWithTwoDisplay) {
   EXPECT_EQ(ConfigureDisplaysTask::SUCCESS, status_);
   EXPECT_EQ(
       JoinActions(
-          GetCrtcAction(displays_[0], &small_mode_, gfx::Point()).c_str(),
-          GetCrtcAction(displays_[1], &big_mode_, gfx::Point()).c_str(), NULL),
+          GetCrtcAction(*displays_[0], &small_mode_, gfx::Point()).c_str(),
+          GetCrtcAction(*displays_[1], &big_mode_, gfx::Point()).c_str(),
+          nullptr),
       log_.GetActionsAndClear());
 }
 
@@ -126,16 +126,16 @@ TEST_F(ConfigureDisplaysTaskTest, DisableDisplayFails) {
   delegate_.set_max_configurable_pixels(1);
 
   std::vector<DisplayConfigureRequest> requests(
-      1, DisplayConfigureRequest(&displays_[0], nullptr, gfx::Point()));
+      1, DisplayConfigureRequest(displays_[0].get(), nullptr, gfx::Point()));
   ConfigureDisplaysTask task(&delegate_, requests, callback);
   task.Run();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(ConfigureDisplaysTask::ERROR, status_);
-  EXPECT_EQ(JoinActions(
-                GetCrtcAction(displays_[0], nullptr, gfx::Point()).c_str(),
-                NULL),
-            log_.GetActionsAndClear());
+  EXPECT_EQ(
+      JoinActions(GetCrtcAction(*displays_[0], nullptr, gfx::Point()).c_str(),
+                  nullptr),
+      log_.GetActionsAndClear());
 }
 
 TEST_F(ConfigureDisplaysTaskTest, ConfigureWithOneDisplayFails) {
@@ -145,17 +145,18 @@ TEST_F(ConfigureDisplaysTaskTest, ConfigureWithOneDisplayFails) {
   delegate_.set_max_configurable_pixels(1);
 
   std::vector<DisplayConfigureRequest> requests(
-      1, DisplayConfigureRequest(&displays_[1], &big_mode_, gfx::Point()));
+      1, DisplayConfigureRequest(displays_[1].get(), &big_mode_, gfx::Point()));
   ConfigureDisplaysTask task(&delegate_, requests, callback);
   task.Run();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(ConfigureDisplaysTask::ERROR, status_);
-  EXPECT_EQ(JoinActions(
-                GetCrtcAction(displays_[1], &big_mode_, gfx::Point()).c_str(),
-                GetCrtcAction(displays_[1], &small_mode_, gfx::Point()).c_str(),
-                NULL),
-            log_.GetActionsAndClear());
+  EXPECT_EQ(
+      JoinActions(
+          GetCrtcAction(*displays_[1], &big_mode_, gfx::Point()).c_str(),
+          GetCrtcAction(*displays_[1], &small_mode_, gfx::Point()).c_str(),
+          nullptr),
+      log_.GetActionsAndClear());
 }
 
 TEST_F(ConfigureDisplaysTaskTest, ConfigureWithTwoDisplayFails) {
@@ -167,7 +168,7 @@ TEST_F(ConfigureDisplaysTaskTest, ConfigureWithTwoDisplayFails) {
   std::vector<DisplayConfigureRequest> requests;
   for (size_t i = 0; i < arraysize(displays_); ++i) {
     requests.push_back(DisplayConfigureRequest(
-        &displays_[i], displays_[i].native_mode(), gfx::Point()));
+        displays_[i].get(), displays_[i]->native_mode(), gfx::Point()));
   }
 
   ConfigureDisplaysTask task(&delegate_, requests, callback);
@@ -175,12 +176,13 @@ TEST_F(ConfigureDisplaysTaskTest, ConfigureWithTwoDisplayFails) {
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(ConfigureDisplaysTask::ERROR, status_);
-  EXPECT_EQ(JoinActions(
-                GetCrtcAction(displays_[0], &small_mode_, gfx::Point()).c_str(),
-                GetCrtcAction(displays_[1], &big_mode_, gfx::Point()).c_str(),
-                GetCrtcAction(displays_[1], &small_mode_, gfx::Point()).c_str(),
-                NULL),
-            log_.GetActionsAndClear());
+  EXPECT_EQ(
+      JoinActions(
+          GetCrtcAction(*displays_[0], &small_mode_, gfx::Point()).c_str(),
+          GetCrtcAction(*displays_[1], &big_mode_, gfx::Point()).c_str(),
+          GetCrtcAction(*displays_[1], &small_mode_, gfx::Point()).c_str(),
+          nullptr),
+      log_.GetActionsAndClear());
 }
 
 TEST_F(ConfigureDisplaysTaskTest, ConfigureWithTwoDisplaysPartialSuccess) {
@@ -192,7 +194,7 @@ TEST_F(ConfigureDisplaysTaskTest, ConfigureWithTwoDisplaysPartialSuccess) {
   std::vector<DisplayConfigureRequest> requests;
   for (size_t i = 0; i < arraysize(displays_); ++i) {
     requests.push_back(DisplayConfigureRequest(
-        &displays_[i], displays_[i].native_mode(), gfx::Point()));
+        displays_[i].get(), displays_[i]->native_mode(), gfx::Point()));
   }
 
   ConfigureDisplaysTask task(&delegate_, requests, callback);
@@ -200,12 +202,13 @@ TEST_F(ConfigureDisplaysTaskTest, ConfigureWithTwoDisplaysPartialSuccess) {
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(ConfigureDisplaysTask::PARTIAL_SUCCESS, status_);
-  EXPECT_EQ(JoinActions(
-                GetCrtcAction(displays_[0], &small_mode_, gfx::Point()).c_str(),
-                GetCrtcAction(displays_[1], &big_mode_, gfx::Point()).c_str(),
-                GetCrtcAction(displays_[1], &small_mode_, gfx::Point()).c_str(),
-                NULL),
-            log_.GetActionsAndClear());
+  EXPECT_EQ(
+      JoinActions(
+          GetCrtcAction(*displays_[0], &small_mode_, gfx::Point()).c_str(),
+          GetCrtcAction(*displays_[1], &big_mode_, gfx::Point()).c_str(),
+          GetCrtcAction(*displays_[1], &small_mode_, gfx::Point()).c_str(),
+          nullptr),
+      log_.GetActionsAndClear());
 }
 
 TEST_F(ConfigureDisplaysTaskTest, AsyncConfigureWithTwoDisplaysPartialSuccess) {
@@ -218,7 +221,7 @@ TEST_F(ConfigureDisplaysTaskTest, AsyncConfigureWithTwoDisplaysPartialSuccess) {
   std::vector<DisplayConfigureRequest> requests;
   for (size_t i = 0; i < arraysize(displays_); ++i) {
     requests.push_back(DisplayConfigureRequest(
-        &displays_[i], displays_[i].native_mode(), gfx::Point()));
+        displays_[i].get(), displays_[i]->native_mode(), gfx::Point()));
   }
 
   ConfigureDisplaysTask task(&delegate_, requests, callback);
@@ -229,12 +232,13 @@ TEST_F(ConfigureDisplaysTaskTest, AsyncConfigureWithTwoDisplaysPartialSuccess) {
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(ConfigureDisplaysTask::PARTIAL_SUCCESS, status_);
-  EXPECT_EQ(JoinActions(
-                GetCrtcAction(displays_[0], &small_mode_, gfx::Point()).c_str(),
-                GetCrtcAction(displays_[1], &big_mode_, gfx::Point()).c_str(),
-                GetCrtcAction(displays_[1], &small_mode_, gfx::Point()).c_str(),
-                NULL),
-            log_.GetActionsAndClear());
+  EXPECT_EQ(
+      JoinActions(
+          GetCrtcAction(*displays_[0], &small_mode_, gfx::Point()).c_str(),
+          GetCrtcAction(*displays_[1], &big_mode_, gfx::Point()).c_str(),
+          GetCrtcAction(*displays_[1], &small_mode_, gfx::Point()).c_str(),
+          nullptr),
+      log_.GetActionsAndClear());
 }
 
 }  // namespace test

ui/display/chromeos/query_content_protection_task_unittest.cc

@@ -13,8 +13,8 @@
 #include "ui/display/chromeos/display_layout_manager.h"
 #include "ui/display/chromeos/test/action_logger_util.h"
 #include "ui/display/chromeos/test/test_display_layout_manager.h"
-#include "ui/display/chromeos/test/test_display_snapshot.h"
 #include "ui/display/chromeos/test/test_native_display_delegate.h"
+#include "ui/display/fake_display_snapshot.h"
 
 namespace ui {
 namespace test {
@@ -24,11 +24,11 @@ namespace {
 std::unique_ptr<DisplaySnapshot> CreateDisplaySnapshot(
     int64_t id,
     DisplayConnectionType type) {
-  std::unique_ptr<TestDisplaySnapshot> display(new TestDisplaySnapshot());
-  display->set_display_id(id);
-  display->set_type(type);
-
-  return std::move(display);
+  return display::FakeDisplaySnapshot::Builder()
+      .SetId(id)
+      .SetNativeMode(gfx::Size(1024, 768))
+      .SetType(type)
+      .Build();
 }
 
 }  // namespace

ui/display/chromeos/test/test_display_snapshot.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 "ui/display/chromeos/test/test_display_snapshot.h"
-
-namespace ui {
-TestDisplaySnapshot::TestDisplaySnapshot()
-    : DisplaySnapshot(0,
-                      gfx::Point(0, 0),
-                      gfx::Size(0, 0),
-                      DISPLAY_CONNECTION_TYPE_UNKNOWN,
-                      false,
-                      false,
-                      false,
-                      std::string(),
-                      base::FilePath(),
-                      std::vector<std::unique_ptr<const DisplayMode>>(),
-                      std::vector<uint8_t>(),
-                      NULL,
-                      NULL) {}
-
-TestDisplaySnapshot::TestDisplaySnapshot(
-    int64_t display_id,
-    const gfx::Point& origin,
-    const gfx::Size& physical_size,
-    DisplayConnectionType type,
-    bool is_aspect_preserving_scaling,
-    int64_t product_id,
-    bool has_color_correction_matrix,
-    std::vector<std::unique_ptr<const DisplayMode>> modes,
-    const DisplayMode* current_mode,
-    const DisplayMode* native_mode)
-    : DisplaySnapshot(display_id,
-                      origin,
-                      physical_size,
-                      type,
-                      is_aspect_preserving_scaling,
-                      false,
-                      has_color_correction_matrix,
-                      std::string(),
-                      base::FilePath(),
-                      std::move(modes),
-                      std::vector<uint8_t>(),
-                      current_mode,
-                      native_mode) {
-  product_id_ = product_id;
-}
-
-TestDisplaySnapshot::~TestDisplaySnapshot() {}
-
-std::string TestDisplaySnapshot::ToString() const { return ""; }
-
-}  // namespace ui

ui/display/chromeos/test/test_display_snapshot.h

-// 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.
-
-#ifndef UI_DISPLAY_CHROMEOS_TEST_TEST_DISPLAY_SNAPSHOT_H_
-#define UI_DISPLAY_CHROMEOS_TEST_TEST_DISPLAY_SNAPSHOT_H_
-
-#include <stdint.h>
-
-#include "base/macros.h"
-#include "ui/display/display_export.h"
-#include "ui/display/types/display_snapshot.h"
-
-namespace ui {
-
-class DISPLAY_EXPORT TestDisplaySnapshot : public DisplaySnapshot {
- public:
-  TestDisplaySnapshot();
-  TestDisplaySnapshot(int64_t display_id,
-                      const gfx::Point& origin,
-                      const gfx::Size& physical_size,
-                      DisplayConnectionType type,
-                      bool is_aspect_preserving_scaling,
-                      int64_t product_id,
-                      bool has_color_correction_matrix,
-                      std::vector<std::unique_ptr<const DisplayMode>> modes,
-                      const DisplayMode* current_mode,
-                      const DisplayMode* native_mode);
-  ~TestDisplaySnapshot() override;
-
-  void set_type(DisplayConnectionType type) { type_ = type; }
-  void set_modes(std::vector<std::unique_ptr<const DisplayMode>> modes) {
-    modes_ = std::move(modes);
-  }
-  void set_native_mode(const ui::DisplayMode* mode) { native_mode_ = mode; }
-  void set_is_aspect_preserving_scaling(bool state) {
-    is_aspect_preserving_scaling_ = state;
-  }
-  void set_display_id(int64_t id) { display_id_ = id; }
-
-  // DisplaySnapshot overrides:
-  std::string ToString() const override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestDisplaySnapshot);
-};
-
-}  // namespace ui
-
-#endif  // UI_DISPLAY_CHROMEOS_TEST_TEST_DISPLAY_SNAPSHOT_H_