Delete TestDisplaySnapshot and update tests.

ui/display/chromeos/display_configurator_unittest.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/display_configurator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.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"
 #include "ui/display/util/display_util.h"
 
 namespace ui {
 namespace test {
 
 namespace {
 
+int64_t kDisplayIds[3] = {123, 456, 789};
+
+std::unique_ptr<ui::DisplayMode> MakeDisplayMode(int width,
+                                                 int height,
+                                                 bool is_interlaced,
+                                                 float refresh_rate) {
+  return base::MakeUnique<ui::DisplayMode>(gfx::Size(width, height),
+                                           is_interlaced, refresh_rate);
+}
+
 class TestObserver : public DisplayConfigurator::Observer {
  public:
   explicit TestObserver(DisplayConfigurator* configurator)
       : configurator_(configurator) {
     Reset();
     configurator_->AddObserver(this);
   }
   ~TestObserver() override { configurator_->RemoveObserver(this); }
 
   int num_changes() const { return num_changes_; }
@@ skipping 106 matching lines @@
   void SetUp() override {
     log_.reset(new ActionLogger());
 
     native_display_delegate_ = new TestNativeDisplayDelegate(log_.get());
     configurator_.SetDelegateForTesting(
         std::unique_ptr<NativeDisplayDelegate>(native_display_delegate_));
 
     configurator_.set_state_controller(&state_controller_);
     configurator_.set_mirroring_controller(&mirroring_controller_);
 
-    std::vector<std::unique_ptr<const DisplayMode>> modes;
-    modes.push_back(small_mode_.Clone());
+    outputs_[0] = display::FakeDisplaySnapshot::Builder()
+                      .SetId(kDisplayIds[0])
+                      .SetNativeMode(small_mode_.Clone())
+                      .SetCurrentMode(small_mode_.Clone())
+                      .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
+                      .SetIsAspectPerservingScaling(true)
+                      .Build();
 
-    TestDisplaySnapshot* o = &outputs_[0];
-    o->set_current_mode(modes.front().get());
-    o->set_native_mode(modes.front().get());
-    o->set_modes(std::move(modes));
-    o->set_type(DISPLAY_CONNECTION_TYPE_INTERNAL);
-    o->set_is_aspect_preserving_scaling(true);
-    o->set_display_id(123);
+    outputs_[1] = display::FakeDisplaySnapshot::Builder()
+                      .SetId(kDisplayIds[1])
+                      .SetNativeMode(big_mode_.Clone())
+                      .SetCurrentMode(big_mode_.Clone())
+                      .AddMode(small_mode_.Clone())
+                      .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
+                      .SetIsAspectPerservingScaling(true)
+                      .Build();
 
-    modes.clear();
-    modes.push_back(small_mode_.Clone());
-    modes.push_back(big_mode_.Clone());
-    o = &outputs_[1];
-    o->set_current_mode(modes.back().get());
-    o->set_native_mode(modes.back().get());
-    o->set_modes(std::move(modes));
-    o->set_type(DISPLAY_CONNECTION_TYPE_HDMI);
-    o->set_is_aspect_preserving_scaling(true);
-    o->set_display_id(456);
-
-    modes.clear();
-    modes.push_back(small_mode_.Clone());
-    o = &outputs_[2];
-    o->set_current_mode(modes.back().get());
-    o->set_native_mode(modes.back().get());
-    o->set_modes(std::move(modes));
-    o->set_type(DISPLAY_CONNECTION_TYPE_HDMI);
-    o->set_is_aspect_preserving_scaling(true);
-    o->set_display_id(789);
+    outputs_[2] = display::FakeDisplaySnapshot::Builder()
+                      .SetId(kDisplayIds[2])
+                      .SetNativeMode(small_mode_.Clone())
+                      .SetCurrentMode(small_mode_.Clone())
+                      .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
+                      .SetIsAspectPerservingScaling(true)
+                      .Build();
 
     UpdateOutputs(2, false);
   }
 
   void OnConfiguredCallback(bool status) {
     callback_result_ = (status ? CALLBACK_SUCCESS : CALLBACK_FAILURE);
   }
 
   void OnDisplayControlUpdated(bool status) {
     display_control_result_ = (status ? CALLBACK_SUCCESS : CALLBACK_FAILURE);
@@ skipping 17 matching lines @@
  protected:
   // Configures |native_display_delegate_| to return the first |num_outputs|
   // entries from
   // |outputs_|. If |send_events| is true, also sends screen-change and
   // output-change events to |configurator_| and triggers the configure
   // timeout if one was scheduled.
   void UpdateOutputs(size_t num_outputs, bool send_events) {
     ASSERT_LE(num_outputs, arraysize(outputs_));
     std::vector<DisplaySnapshot*> outputs;
     for (size_t i = 0; i < num_outputs; ++i)
-      outputs.push_back(&outputs_[i]);
+      outputs.push_back(outputs_[i].get());
     native_display_delegate_->set_outputs(outputs);
 
     if (send_events) {
       configurator_.OnConfigurationChanged();
       EXPECT_TRUE(test_api_.TriggerConfigureTimeout());
     }
   }
 
   void Init(bool panel_fitting_enabled) {
     configurator_.Init(nullptr, panel_fitting_enabled);
   }
 
   // Initializes |configurator_| with a single internal display.
   void InitWithSingleOutput() {
     UpdateOutputs(1, false);
     EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
     configurator_.Init(nullptr, false);
 
     EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
     configurator_.ForceInitialConfigure(0);
-    EXPECT_EQ(JoinActions(kInitXRandR, kGrab,
-                          GetFramebufferAction(small_mode_.size(), &outputs_[0],
-                                               NULL).c_str(),
-                          GetCrtcAction(outputs_[0], &small_mode_,
-                                        gfx::Point(0, 0)).c_str(),
-                          kForceDPMS, kUngrab, NULL),
-              log_->GetActionsAndClear());
+    EXPECT_EQ(
+        JoinActions(
+            kInitXRandR, kGrab,
+            GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+                .c_str(),
+            GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+            kForceDPMS, kUngrab, nullptr),
+        log_->GetActionsAndClear());
   }
 
   CallbackResult PopCallbackResult() {
     CallbackResult result = callback_result_;
     callback_result_ = CALLBACK_NOT_CALLED;
     return result;
   }
 
   CallbackResult PopDisplayControlResult() {
     CallbackResult result = display_control_result_;
     display_control_result_ = CALLBACK_NOT_CALLED;
     return result;
   }
 
   base::MessageLoop message_loop_;
   TestStateController state_controller_;
   TestMirroringController mirroring_controller_;
   DisplayConfigurator configurator_;
   TestObserver observer_;
   std::unique_ptr<ActionLogger> log_;
   TestNativeDisplayDelegate* native_display_delegate_;  // not owned
   DisplayConfigurator::TestApi test_api_;
 
   bool enable_content_protection_status_;
   int enable_content_protection_call_count_;
   DisplayConfigurator::QueryProtectionResponse
       query_content_protection_response_;
   int query_content_protection_call_count_;
 
-  TestDisplaySnapshot outputs_[3];
+  std::unique_ptr<DisplaySnapshot> outputs_[3];
 
   CallbackResult callback_result_;
   CallbackResult display_control_result_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorTest);
 };
 
 }  // namespace
 
 TEST_F(DisplayConfiguratorTest, FindDisplayModeMatchingSize) {
-  std::vector<const DisplayMode*> modes;
+  std::unique_ptr<ui::DisplaySnapshot> output =
+      display::FakeDisplaySnapshot::Builder()
+          .SetId(kDisplayIds[0])
+          .AddMode(MakeDisplayMode(1920, 1200, false, 60.0))
+          .SetNativeMode(MakeDisplayMode(1920, 1200, false, 50.0))
+          // Different rates.
+          .AddMode(MakeDisplayMode(1920, 1080, false, 30.0))
+          .AddMode(MakeDisplayMode(1920, 1080, false, 50.0))
+          .AddMode(MakeDisplayMode(1920, 1080, false, 40.0))
+          .AddMode(MakeDisplayMode(1920, 1080, false, 0.0))
+          // Interlaced vs non-interlaced.
+          .AddMode(MakeDisplayMode(1280, 720, true, 60.0))
+          .AddMode(MakeDisplayMode(1280, 720, false, 40.0))
+          // Interlaced only.
+          .AddMode(MakeDisplayMode(1024, 768, true, 0.0))
+          .AddMode(MakeDisplayMode(1024, 768, true, 40.0))
+          .AddMode(MakeDisplayMode(1024, 768, true, 60.0))
+          // Mixed.
+          .AddMode(MakeDisplayMode(1024, 600, true, 60.0))
+          .AddMode(MakeDisplayMode(1024, 600, false, 40.0))
+          .AddMode(MakeDisplayMode(1024, 600, false, 50.0))
+          // Just one interlaced mode.
+          .AddMode(MakeDisplayMode(640, 480, true, 60.0))
+          // Refresh rate not available.
+          .AddMode(MakeDisplayMode(320, 200, false, 0.0))
+          .Build();
 
-  // Fields are width, height, interlaced, refresh rate.
-  modes.push_back(new DisplayMode(gfx::Size(1920, 1200), false, 60.0));
-  DisplayMode* native_mode =
-      new DisplayMode(gfx::Size(1920, 1200), false, 50.0);
-  modes.push_back(native_mode);
-  // Different rates.
-  modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 30.0));
-  modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 50.0));
-  modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 40.0));
-  modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 0.0));
-  // Interlaced vs non-interlaced.
-  modes.push_back(new DisplayMode(gfx::Size(1280, 720), true, 60.0));
-  modes.push_back(new DisplayMode(gfx::Size(1280, 720), false, 40.0));
-  // Interlaced only.
-  modes.push_back(new DisplayMode(gfx::Size(1024, 768), true, 0.0));
-  modes.push_back(new DisplayMode(gfx::Size(1024, 768), true, 40.0));
-  modes.push_back(new DisplayMode(gfx::Size(1024, 768), true, 60.0));
-  // Mixed.
-  modes.push_back(new DisplayMode(gfx::Size(1024, 600), true, 60.0));
-  modes.push_back(new DisplayMode(gfx::Size(1024, 600), false, 40.0));
-  modes.push_back(new DisplayMode(gfx::Size(1024, 600), false, 50.0));
-  // Just one interlaced mode.
-  modes.push_back(new DisplayMode(gfx::Size(640, 480), true, 60.0));
-  // Refresh rate not available.
-  modes.push_back(new DisplayMode(gfx::Size(320, 200), false, 0.0));
-
-  TestDisplaySnapshot output;
-  std::vector<std::unique_ptr<const DisplayMode>> tmp_modes;
-  for (const DisplayMode* mode : modes)
-    tmp_modes.push_back(base::WrapUnique(mode));
-  output.set_modes(std::move(tmp_modes));
-  output.set_native_mode(native_mode);
+  const std::vector<std::unique_ptr<const DisplayMode>>& modes =
+      output->modes();
 
   // Should pick native over highest refresh rate.
-  EXPECT_EQ(modes[1],
-            DisplayConfigurator::FindDisplayModeMatchingSize(
-                output, gfx::Size(1920, 1200)));
+  EXPECT_EQ(modes[1].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
+                                *output, gfx::Size(1920, 1200)));
 
   // Should pick highest refresh rate.
-  EXPECT_EQ(modes[3],
-            DisplayConfigurator::FindDisplayModeMatchingSize(
-                output, gfx::Size(1920, 1080)));
+  EXPECT_EQ(modes[3].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
+                                *output, gfx::Size(1920, 1080)));
 
   // Should pick non-interlaced mode.
-  EXPECT_EQ(modes[7],
-            DisplayConfigurator::FindDisplayModeMatchingSize(
-                output, gfx::Size(1280, 720)));
+  EXPECT_EQ(modes[7].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
+                                *output, gfx::Size(1280, 720)));
 
   // Interlaced only. Should pick one with the highest refresh rate in
   // interlaced mode.
-  EXPECT_EQ(modes[10],
-            DisplayConfigurator::FindDisplayModeMatchingSize(
-                output, gfx::Size(1024, 768)));
+  EXPECT_EQ(modes[10].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
+                                 *output, gfx::Size(1024, 768)));
 
   // Mixed: Should pick one with the highest refresh rate in
   // interlaced mode.
-  EXPECT_EQ(modes[13],
-            DisplayConfigurator::FindDisplayModeMatchingSize(
-                output, gfx::Size(1024, 600)));
+  EXPECT_EQ(modes[13].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
+                                 *output, gfx::Size(1024, 600)));
 
   // Just one interlaced mode.
-  EXPECT_EQ(modes[14],
-            DisplayConfigurator::FindDisplayModeMatchingSize(
-                output, gfx::Size(640, 480)));
+  EXPECT_EQ(modes[14].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
+                                 *output, gfx::Size(640, 480)));
 
   // Refresh rate not available.
-  EXPECT_EQ(modes[15],
-            DisplayConfigurator::FindDisplayModeMatchingSize(
-                output, gfx::Size(320, 200)));
+  EXPECT_EQ(modes[15].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
+                                 *output, gfx::Size(320, 200)));
 
   // No mode found.
-  EXPECT_EQ(NULL,
-            DisplayConfigurator::FindDisplayModeMatchingSize(
-                output, gfx::Size(1440, 900)));
+  EXPECT_EQ(nullptr, DisplayConfigurator::FindDisplayModeMatchingSize(
+                         *output, gfx::Size(1440, 900)));
 }
 
 TEST_F(DisplayConfiguratorTest, EnableVirtualDisplay) {
   InitWithSingleOutput();
 
   observer_.Reset();
   const DisplayConfigurator::DisplayStateList& cached =
       configurator_.cached_displays();
   ASSERT_EQ(static_cast<size_t>(1u), cached.size());
   EXPECT_EQ(small_mode_.size(), cached[0]->current_mode()->size());
 
   // Add virtual display.
   int64_t virtual_display_id =
       configurator_.AddVirtualDisplay(big_mode_.size());
   EXPECT_EQ(display::GenerateDisplayID(0x8000, 0x0, 1), virtual_display_id);
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
 
   // Virtual should not trigger addition of added crtc but does change FB
   // height.
   const int kVirtualHeight = small_mode_.size().height() +
                              DisplayConfigurator::kVerticalGap +
                              big_mode_.size().height();
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kVirtualHeight),
-                     &outputs_[0], nullptr)
+                     outputs_[0].get(), nullptr)
                      .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(1, observer_.num_changes());
   ASSERT_EQ(static_cast<size_t>(2u), cached.size());
   EXPECT_EQ(small_mode_.size(), cached[0]->current_mode()->size());
   EXPECT_EQ(big_mode_.size(), cached[1]->current_mode()->size());
   EXPECT_EQ(virtual_display_id, cached[1]->display_id());
 
   // Remove virtual display.
   observer_.Reset();
   EXPECT_TRUE(configurator_.RemoveVirtualDisplay(virtual_display_id));
   EXPECT_EQ(
       JoinActions(
-          kGrab, GetFramebufferAction(small_mode_.size(), &outputs_[0], nullptr)
-                     .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kGrab,
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(1, observer_.num_changes());
   ASSERT_EQ(static_cast<size_t>(1u), cached.size());
   EXPECT_EQ(small_mode_.size(), cached[0]->current_mode()->size());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
 }
 
 TEST_F(DisplayConfiguratorTest, EnableTwoVirtualDisplays) {
   InitWithSingleOutput();
@@ skipping 14 matching lines @@
 
   // Virtual should not trigger addition of added crtc but does change FB
   // height.
   const int kSingleVirtualHeight = small_mode_.size().height() +
                                    DisplayConfigurator::kVerticalGap +
                                    big_mode_.size().height();
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kSingleVirtualHeight),
-                     &outputs_[0], nullptr)
+                     outputs_[0].get(), nullptr)
                      .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(1, observer_.num_changes());
   ASSERT_EQ(static_cast<size_t>(2), cached.size());
   EXPECT_EQ(small_mode_.size(), cached[0]->current_mode()->size());
   EXPECT_EQ(big_mode_.size(), cached[1]->current_mode()->size());
   EXPECT_EQ(virtual_display_id_1, cached[1]->display_id());
 
   // Add 2nd virtual display
   int64_t virtual_display_id_2 =
       configurator_.AddVirtualDisplay(big_mode_.size());
   EXPECT_EQ(display::GenerateDisplayID(0x8000, 0x0, 2), virtual_display_id_2);
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
             configurator_.display_state());
 
   const int kDualVirtualHeight =
       small_mode_.size().height() +
       (DisplayConfigurator::kVerticalGap + big_mode_.size().height()) * 2;
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kDualVirtualHeight),
-                     &outputs_[0], nullptr)
+                     outputs_[0].get(), nullptr)
                      .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(2, observer_.num_changes());
   ASSERT_EQ(static_cast<size_t>(3u), cached.size());
   EXPECT_EQ(small_mode_.size(), cached[0]->current_mode()->size());
   EXPECT_EQ(big_mode_.size(), cached[1]->current_mode()->size());
   EXPECT_EQ(big_mode_.size(), cached[2]->current_mode()->size());
   EXPECT_EQ(virtual_display_id_1, cached[1]->display_id());
   EXPECT_EQ(virtual_display_id_2, cached[2]->display_id());
 
   // Remove 1st virtual display.
   observer_.Reset();
   EXPECT_TRUE(configurator_.RemoveVirtualDisplay(virtual_display_id_1));
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kSingleVirtualHeight),
-                     &outputs_[0], nullptr)
+                     outputs_[0].get(), nullptr)
                      .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(1, observer_.num_changes());
   ASSERT_EQ(static_cast<size_t>(2u), cached.size());
   EXPECT_EQ(small_mode_.size(), cached[0]->current_mode()->size());
   EXPECT_EQ(big_mode_.size(), cached[1]->current_mode()->size());
   EXPECT_EQ(virtual_display_id_2, cached[1]->display_id());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
 
   // Remove 2nd virtual display.
   observer_.Reset();
   EXPECT_TRUE(configurator_.RemoveVirtualDisplay(virtual_display_id_2));
   EXPECT_EQ(
       JoinActions(
-          kGrab, GetFramebufferAction(small_mode_.size(), &outputs_[0], nullptr)
-                     .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kGrab,
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(1, observer_.num_changes());
   ASSERT_EQ(static_cast<size_t>(1), cached.size());
   EXPECT_EQ(small_mode_.size(), cached[0]->current_mode()->size());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
 }
 
 TEST_F(DisplayConfiguratorTest, ConnectSecondOutput) {
   InitWithSingleOutput();
 
   // Connect a second output and check that the configurator enters
   // extended mode.
   observer_.Reset();
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   const int kDualHeight = small_mode_.size().height() +
                           DisplayConfigurator::kVerticalGap +
                           big_mode_.size().height();
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0],
-                               &outputs_[1]).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1],
-                        &big_mode_,
-                        gfx::Point(0,
-                                   small_mode_.size().height() +
-                                       DisplayConfigurator::kVerticalGap))
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          kUngrab,
-          NULL),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   observer_.Reset();
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Disconnect the second output.
   observer_.Reset();
   UpdateOutputs(1, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Get rid of shared modes to force software mirroring.
-  std::vector<std::unique_ptr<const DisplayMode>> modes;
-  modes.push_back(big_mode_.Clone());
-  outputs_[1].set_current_mode(modes.front().get());
-  outputs_[1].set_native_mode(modes.front().get());
-  outputs_[1].set_modes(std::move(modes));
+  outputs_[1] = display::FakeDisplaySnapshot::Builder()
+                    .SetId(kDisplayIds[1])
+                    .SetNativeMode(big_mode_.Clone())
+                    .SetCurrentMode(big_mode_.Clone())
+                    .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
+                    .SetIsAspectPerservingScaling(true)
+                    .Build();
+
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0],
-                               &outputs_[1]).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1],
-                        &big_mode_,
-                        gfx::Point(0,
-                                   small_mode_.size().height() +
-                                       DisplayConfigurator::kVerticalGap))
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          kUngrab,
-          NULL),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   const gfx::Size framebuffer_size = configurator_.framebuffer_size();
   DCHECK(!framebuffer_size.IsEmpty());
 
   observer_.Reset();
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
-  EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(kGrab, kUngrab, nullptr), log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(framebuffer_size.ToString(),
             configurator_.framebuffer_size().ToString());
 
   EXPECT_EQ(1, observer_.num_changes());
 
   // Setting MULTIPLE_DISPLAY_STATE_DUAL_MIRROR should try to reconfigure.
   observer_.Reset();
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
-  EXPECT_EQ(JoinActions(NULL), log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(nullptr), log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Set back to software mirror mode.
   observer_.Reset();
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
-  EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(kGrab, kUngrab, nullptr), log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Disconnect the second output.
   observer_.Reset();
   UpdateOutputs(1, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 }
 
 TEST_F(DisplayConfiguratorTest, SetDisplayPower) {
   InitWithSingleOutput();
 
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   observer_.Reset();
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turning off the internal display should switch the external display to
   // its native mode.
   observer_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(big_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(big_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
   EXPECT_EQ(1, observer_.num_changes());
 
   // When all displays are turned off, the framebuffer should switch back
   // to the mirrored size.
   observer_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_OFF,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
-      JoinActions(kGrab,
-                  GetFramebufferAction(
-                      small_mode_.size(), &outputs_[0], &outputs_[1]).c_str(),
-                  GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-                  GetCrtcAction(outputs_[1], NULL, gfx::Point(0, 0)).c_str(),
-                  kUngrab,
-                  NULL),
+      JoinActions(
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turn all displays on and check that mirroring is still used.
   observer_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Get rid of shared modes to force software mirroring.
-  std::vector<std::unique_ptr<const DisplayMode>> modes;
-  modes.push_back(big_mode_.Clone());
-  outputs_[1].set_current_mode(modes.front().get());
-  outputs_[1].set_native_mode(modes.front().get());
-  outputs_[1].set_modes(std::move(modes));
+  outputs_[1] = display::FakeDisplaySnapshot::Builder()
+                    .SetId(kDisplayIds[1])
+                    .SetNativeMode(big_mode_.Clone())
+                    .SetCurrentMode(big_mode_.Clone())
+                    .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
+                    .SetIsAspectPerservingScaling(true)
+                    .Build();
+
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   observer_.Reset();
   UpdateOutputs(2, true);
   const int kDualHeight = small_mode_.size().height() +
                           DisplayConfigurator::kVerticalGap +
                           big_mode_.size().height();
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0],
-                               &outputs_[1]).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1],
-                        &big_mode_,
-                        gfx::Point(0,
-                                   small_mode_.size().height() +
-                                       DisplayConfigurator::kVerticalGap))
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          kUngrab,
-          NULL),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turning off the internal display should switch the external display to
   // its native mode.
   observer_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(big_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(big_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // When all displays are turned off, the framebuffer should switch back
   // to the extended + software mirroring.
   observer_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_OFF,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0],
-                               &outputs_[1]).c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1],
-                        NULL,
-                        gfx::Point(0,
-                                   small_mode_.size().height() +
-                                       DisplayConfigurator::kVerticalGap))
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          kUngrab,
-          NULL),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turn all displays on and check that mirroring is still used.
   observer_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0],
-                               &outputs_[1]).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1],
-                        &big_mode_,
-                        gfx::Point(0,
-                                   small_mode_.size().height() +
-                                       DisplayConfigurator::kVerticalGap))
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 }
 
 TEST_F(DisplayConfiguratorTest, SuspendAndResume) {
   InitWithSingleOutput();
 
   // No preparation is needed before suspending when the display is already
   // on.  The configurator should still reprobe on resume in case a display
   // was connected while suspended.
   const gfx::Size framebuffer_size = configurator_.framebuffer_size();
   DCHECK(!framebuffer_size.IsEmpty());
   configurator_.SuspendDisplays(base::Bind(
       &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(framebuffer_size.ToString(),
             configurator_.framebuffer_size().ToString());
-  EXPECT_EQ(
-      JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          kSync,
-          NULL),
-      log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(
+                kGrab, GetFramebufferAction(small_mode_.size(),
+                                            outputs_[0].get(), nullptr)
+                           .c_str(),
+                GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+                kUngrab, kSync, nullptr),
+            log_->GetActionsAndClear());
   configurator_.ResumeDisplays();
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Now turn the display off before suspending and check that the
   // configurator turns it back on and syncs with the server.
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_OFF,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
-  EXPECT_EQ(
-      JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
-      log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(
+                kGrab, GetFramebufferAction(small_mode_.size(),
+                                            outputs_[0].get(), nullptr)
+                           .c_str(),
+                GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+                kUngrab, nullptr),
+            log_->GetActionsAndClear());
 
   configurator_.SuspendDisplays(base::Bind(
       &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(kSync, log_->GetActionsAndClear());
 
   configurator_.ResumeDisplays();
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_OFF,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], NULL, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   configurator_.SuspendDisplays(base::Bind(
       &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(kSync, log_->GetActionsAndClear());
 
   // If a display is disconnected while suspended, the configurator should
   // pick up the change and only turn on the internal display.
   UpdateOutputs(1, false);
   configurator_.ResumeDisplays();
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, Headless) {
   UpdateOutputs(0, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   Init(false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.ForceInitialConfigure(0);
-  EXPECT_EQ(JoinActions(kInitXRandR, kGrab, kForceDPMS, kUngrab, NULL),
+  EXPECT_EQ(JoinActions(kInitXRandR, kGrab, kForceDPMS, kUngrab, nullptr),
             log_->GetActionsAndClear());
 
   // Not much should happen when the display power state is changed while
   // no displays are connected.
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_OFF,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
-  EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(kGrab, kUngrab, nullptr), log_->GetActionsAndClear());
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
-  EXPECT_EQ(JoinActions(kGrab, kForceDPMS, kUngrab, NULL),
+  EXPECT_EQ(JoinActions(kGrab, kForceDPMS, kUngrab, nullptr),
             log_->GetActionsAndClear());
 
   // Connect an external display and check that it's configured correctly.
-  std::vector<std::unique_ptr<const DisplayMode>> modes;
-  for (const std::unique_ptr<const DisplayMode>& mode : outputs_[1].modes()) {
-    modes.push_back(mode->Clone());
-    if (mode.get() == outputs_[1].current_mode())
-      outputs_[0].set_current_mode(modes.back().get());
-    if (mode.get() == outputs_[1].native_mode())
-      outputs_[0].set_native_mode(modes.back().get());
-  }
-  outputs_[0].set_modes(std::move(modes));
-  outputs_[0].set_type(outputs_[1].type());
+  outputs_[0] = display::FakeDisplaySnapshot::Builder()
+                    .SetId(kDisplayIds[0])
+                    .SetNativeMode(big_mode_.Clone())
+                    .SetCurrentMode(big_mode_.Clone())
+                    .AddMode(small_mode_.Clone())
+                    .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
+                    .SetIsAspectPerservingScaling(true)
+                    .Build();
 
   UpdateOutputs(1, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(big_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], &big_mode_, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          GetFramebufferAction(big_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &big_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
   const gfx::Size framebuffer_size = configurator_.framebuffer_size();
   DCHECK(!framebuffer_size.IsEmpty());
 
   UpdateOutputs(0, true);
-  EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(kGrab, kUngrab, nullptr), log_->GetActionsAndClear());
   EXPECT_EQ(framebuffer_size.ToString(),
             configurator_.framebuffer_size().ToString());
 }
 
 TEST_F(DisplayConfiguratorTest, StartWithTwoOutputs) {
   UpdateOutputs(2, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   Init(false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   configurator_.ForceInitialConfigure(0);
   EXPECT_EQ(
       JoinActions(
           kInitXRandR, kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                               outputs_[1].get())
               .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS, kUngrab, NULL),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, InvalidMultipleDisplayStates) {
   UpdateOutputs(0, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   Init(false);
   configurator_.ForceInitialConfigure(0);
   observer_.Reset();
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_HEADLESS);
@@ skipping 37 matching lines @@
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   configurator_.ForceInitialConfigure(0);
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
 }
 
 TEST_F(DisplayConfiguratorTest, UpdateCachedOutputsEvenAfterFailure) {
   InitWithSingleOutput();
   const DisplayConfigurator::DisplayStateList& cached =
       configurator_.cached_displays();
   ASSERT_EQ(static_cast<size_t>(1), cached.size());
-  EXPECT_EQ(outputs_[0].current_mode(), cached[0]->current_mode());
+  EXPECT_EQ(outputs_[0]->current_mode(), cached[0]->current_mode());
 
   // After connecting a second output, check that it shows up in
   // |cached_displays_| even if an invalid state is requested.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
   UpdateOutputs(2, true);
   ASSERT_EQ(static_cast<size_t>(2), cached.size());
-  EXPECT_EQ(outputs_[0].current_mode(), cached[0]->current_mode());
-  EXPECT_EQ(outputs_[1].current_mode(), cached[1]->current_mode());
+  EXPECT_EQ(outputs_[0]->current_mode(), cached[0]->current_mode());
+  EXPECT_EQ(outputs_[1]->current_mode(), cached[1]->current_mode());
 }
 
 TEST_F(DisplayConfiguratorTest, PanelFitting) {
   // Configure the internal display to support only the big mode and the
   // external display to support only the small mode.
-  std::unique_ptr<const DisplayMode> tmp_mode = big_mode_.Clone();
-  const DisplayMode* mode = tmp_mode.get();
-  std::vector<std::unique_ptr<const DisplayMode>> modes;
-  modes.push_back(std::move(tmp_mode));
-  outputs_[0].set_modes(std::move(modes));
-  outputs_[0].set_current_mode(mode);
-  outputs_[0].set_native_mode(mode);
+  outputs_[0] = display::FakeDisplaySnapshot::Builder()
+                    .SetId(kDisplayIds[0])
+                    .SetNativeMode(big_mode_.Clone())
+                    .SetCurrentMode(big_mode_.Clone())
+                    .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
+                    .SetIsAspectPerservingScaling(true)
+                    .Build();
 
-  modes.clear();
-  tmp_mode = small_mode_.Clone();
-  mode = tmp_mode.get();
-  modes.push_back(std::move(tmp_mode));
-  outputs_[1].set_modes(std::move(modes));
-  outputs_[1].set_current_mode(mode);
-  outputs_[1].set_native_mode(mode);
+  outputs_[1] = display::FakeDisplaySnapshot::Builder()
+                    .SetId(kDisplayIds[1])
+                    .SetNativeMode(small_mode_.Clone())
+                    .SetCurrentMode(small_mode_.Clone())
+                    .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
+                    .SetIsAspectPerservingScaling(true)
+                    .Build();
 
   // The small mode should be added to the internal output when requesting
   // mirrored mode.
   UpdateOutputs(2, false);
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   Init(true /* is_panel_fitting_enabled */);
   configurator_.ForceInitialConfigure(0);
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
   EXPECT_EQ(
       JoinActions(
           kInitXRandR, kGrab,
-          GetAddOutputModeAction(outputs_[0], &small_mode_).c_str(),
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
+          GetAddOutputModeAction(*outputs_[0], &small_mode_).c_str(),
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                               outputs_[1].get())
               .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS, kUngrab, NULL),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Both outputs should be using the small mode.
   ASSERT_EQ(1, observer_.num_changes());
   ASSERT_EQ(static_cast<size_t>(2), observer_.latest_outputs().size());
   EXPECT_EQ(small_mode_.size(),
             observer_.latest_outputs()[0]->current_mode()->size());
   EXPECT_EQ(small_mode_.size(),
             observer_.latest_outputs()[1]->current_mode()->size());
 
   // Also test that there are 2 modes (instead of the initial one) in the
   // snapshot that was passed to the observer (http://crbug.com/289159).
   DisplaySnapshot* state = observer_.latest_outputs()[0];
   ASSERT_EQ(2UL, state->modes().size());
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtection) {
   Init(false);
   configurator_.ForceInitialConfigure(0);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
 
   DisplayConfigurator::ContentProtectionClientId id =
       configurator_.RegisterContentProtectionClient();
   EXPECT_NE(0u, id);
 
   // One output.
   UpdateOutputs(1, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
   configurator_.QueryContentProtectionStatus(
-      id, outputs_[0].display_id(),
+      id, outputs_[0]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, query_content_protection_call_count_);
   EXPECT_TRUE(query_content_protection_response_.success);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_INTERNAL),
             query_content_protection_response_.link_mask);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
             query_content_protection_response_.protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Two outputs.
   UpdateOutputs(2, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
   configurator_.QueryContentProtectionStatus(
-      id, outputs_[1].display_id(),
+      id, outputs_[1]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, query_content_protection_call_count_);
   EXPECT_TRUE(query_content_protection_response_.success);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
             query_content_protection_response_.link_mask);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
             query_content_protection_response_.protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   configurator_.EnableContentProtection(
-      id, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      id, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, enable_content_protection_call_count_);
   EXPECT_TRUE(enable_content_protection_status_);
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_DESIRED),
+  EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED),
             log_->GetActionsAndClear());
 
   // Enable protection.
   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
   configurator_.QueryContentProtectionStatus(
-      id, outputs_[1].display_id(),
+      id, outputs_[1]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(3, query_content_protection_call_count_);
   EXPECT_TRUE(query_content_protection_response_.success);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
             query_content_protection_response_.link_mask);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_HDCP),
             query_content_protection_response_.protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Protections should be disabled after unregister.
   configurator_.UnregisterContentProtectionClient(id);
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_UNDESIRED),
+  EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_UNDESIRED),
             log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, DoNotConfigureWithSuspendedDisplays) {
   InitWithSingleOutput();
 
   // The DisplayConfigurator may occasionally receive OnConfigurationChanged()
   // after the displays have been suspended.  This event should be ignored since
   // the DisplayConfigurator will force a probe and reconfiguration of displays
   // at resume time.
   configurator_.SuspendDisplays(base::Bind(
       &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
-  EXPECT_EQ(
-      JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          kSync,
-          NULL),
-      log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(
+                kGrab, GetFramebufferAction(small_mode_.size(),
+                                            outputs_[0].get(), nullptr)
+                           .c_str(),
+                GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+                kUngrab, kSync, nullptr),
+            log_->GetActionsAndClear());
 
   // The configuration timer should not be started when the displays
   // are suspended.
   configurator_.OnConfigurationChanged();
   EXPECT_FALSE(test_api_.TriggerConfigureTimeout());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Calls to SetDisplayPower should do nothing if the power state doesn't
   // change.
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_OFF,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   UpdateOutputs(2, false);
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // The DisplayConfigurator should do nothing at resume time if there is no
   // state change.
   UpdateOutputs(1, false);
   configurator_.ResumeDisplays();
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // If a configuration task is pending when the displays are suspended, that
   // task should not run either and the timer should be stopped. The displays
   // should be turned off by suspend.
   configurator_.OnConfigurationChanged();
   configurator_.SuspendDisplays(base::Bind(
       &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
-  EXPECT_EQ(
-      JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          kSync,
-          NULL),
-      log_->GetActionsAndClear());
+  EXPECT_EQ(JoinActions(
+                kGrab, GetFramebufferAction(small_mode_.size(),
+                                            outputs_[0].get(), nullptr)
+                           .c_str(),
+                GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+                kUngrab, kSync, nullptr),
+            log_->GetActionsAndClear());
 
   EXPECT_FALSE(test_api_.TriggerConfigureTimeout());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   configurator_.ResumeDisplays();
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClients) {
   DisplayConfigurator::ContentProtectionClientId client1 =
       configurator_.RegisterContentProtectionClient();
   DisplayConfigurator::ContentProtectionClientId client2 =
       configurator_.RegisterContentProtectionClient();
   EXPECT_NE(client1, client2);
 
   Init(false);
   configurator_.ForceInitialConfigure(0);
   UpdateOutputs(2, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
 
   // Clients never know state enableness for methods that they didn't request.
   configurator_.EnableContentProtection(
-      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, enable_content_protection_call_count_);
   EXPECT_TRUE(enable_content_protection_status_);
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_DESIRED).c_str(),
+  EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED).c_str(),
             log_->GetActionsAndClear());
   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
 
   configurator_.QueryContentProtectionStatus(
-      client1, outputs_[1].display_id(),
+      client1, outputs_[1]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, query_content_protection_call_count_);
   EXPECT_TRUE(query_content_protection_response_.success);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
             query_content_protection_response_.link_mask);
   EXPECT_EQ(CONTENT_PROTECTION_METHOD_HDCP,
             query_content_protection_response_.protection_mask);
 
   configurator_.QueryContentProtectionStatus(
-      client2, outputs_[1].display_id(),
+      client2, outputs_[1]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, query_content_protection_call_count_);
   EXPECT_TRUE(query_content_protection_response_.success);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
             query_content_protection_response_.link_mask);
   EXPECT_EQ(CONTENT_PROTECTION_METHOD_NONE,
             query_content_protection_response_.protection_mask);
 
   // Protections will be disabled only if no more clients request them.
   configurator_.EnableContentProtection(
-      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_NONE,
+      client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_NONE,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, enable_content_protection_call_count_);
   EXPECT_TRUE(enable_content_protection_status_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   configurator_.EnableContentProtection(
-      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_NONE,
+      client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_NONE,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(3, enable_content_protection_call_count_);
   EXPECT_TRUE(enable_content_protection_status_);
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_UNDESIRED).c_str(),
+  EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_UNDESIRED).c_str(),
             log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClientsEnable) {
   DisplayConfigurator::ContentProtectionClientId client1 =
       configurator_.RegisterContentProtectionClient();
   DisplayConfigurator::ContentProtectionClientId client2 =
       configurator_.RegisterContentProtectionClient();
   EXPECT_NE(client1, client2);
 
   Init(false);
   configurator_.ForceInitialConfigure(0);
   UpdateOutputs(2, true);
   log_->GetActionsAndClear();
 
   // Only enable once if HDCP is enabling.
   configurator_.EnableContentProtection(
-      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, enable_content_protection_call_count_);
   EXPECT_TRUE(enable_content_protection_status_);
   native_display_delegate_->set_hdcp_state(HDCP_STATE_DESIRED);
   configurator_.EnableContentProtection(
-      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, enable_content_protection_call_count_);
   EXPECT_TRUE(enable_content_protection_status_);
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_DESIRED).c_str(),
+  EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED).c_str(),
             log_->GetActionsAndClear());
   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
 
   // Don't enable again if HDCP is already active.
   configurator_.EnableContentProtection(
-      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(3, enable_content_protection_call_count_);
   EXPECT_TRUE(enable_content_protection_status_);
   configurator_.EnableContentProtection(
-      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(4, enable_content_protection_call_count_);
   EXPECT_TRUE(enable_content_protection_status_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, HandleConfigureCrtcFailure) {
   InitWithSingleOutput();
 
-  ScopedVector<const DisplayMode> modes;
+  std::vector<std::unique_ptr<const DisplayMode>> modes;
   // The first mode is the mode we are requesting DisplayConfigurator to choose.
   // The test will be setup so that this mode will fail and it will have to
   // choose the next best option.
-  modes.push_back(new DisplayMode(gfx::Size(2560, 1600), false, 60.0));
-  modes.push_back(new DisplayMode(gfx::Size(1024, 768), false, 60.0));
-  modes.push_back(new DisplayMode(gfx::Size(1280, 720), false, 60.0));
-  modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 60.0));
-  modes.push_back(new DisplayMode(gfx::Size(1920, 1080), false, 40.0));
+  modes.push_back(MakeDisplayMode(2560, 1600, false, 60.0));
+  modes.push_back(MakeDisplayMode(1024, 768, false, 60.0));
+  modes.push_back(MakeDisplayMode(1280, 720, false, 60.0));
+  modes.push_back(MakeDisplayMode(1920, 1080, false, 60.0));
+  modes.push_back(MakeDisplayMode(1920, 1080, false, 40.0));
 
-  for (unsigned int i = 0; i < arraysize(outputs_); i++) {
-    std::vector<std::unique_ptr<const DisplayMode>> tmp_modes;
-    for (const DisplayMode* mode : modes)
-      tmp_modes.push_back(mode->Clone());
-    outputs_[i].set_current_mode(tmp_modes[0].get());
-    outputs_[i].set_native_mode(tmp_modes[0].get());
-    outputs_[i].set_modes(std::move(tmp_modes));
-  }
+  outputs_[0] = display::FakeDisplaySnapshot::Builder()
+                    .SetId(kDisplayIds[0])
+                    .SetNativeMode(modes[0]->Clone())
+                    .SetCurrentMode(modes[0]->Clone())
+                    .AddMode(modes[1]->Clone())
+                    .AddMode(modes[2]->Clone())
+                    .AddMode(modes[3]->Clone())
+                    .AddMode(modes[4]->Clone())
+                    .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
+                    .SetIsAspectPerservingScaling(true)
+                    .Build();
 
   // First test simply fails in MULTIPLE_DISPLAY_STATE_SINGLE mode. This is
   // probably unrealistic but we want to make sure any assumptions don't creep
   // in.
   native_display_delegate_->set_max_configurable_pixels(
       modes[2]->size().GetArea());
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
   UpdateOutputs(1, true);
 
   EXPECT_EQ(
       JoinActions(
           kGrab,
-          GetFramebufferAction(big_mode_.size(), &outputs_[0], NULL).c_str(),
-          GetCrtcAction(outputs_[0], modes[0], gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[0], modes[3], gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[0], modes[2], gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          NULL),
+          GetFramebufferAction(big_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], modes[0].get(), gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[0], modes[3].get(), gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[0], modes[2].get(), gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
+  outputs_[1] = display::FakeDisplaySnapshot::Builder()
+                    .SetId(kDisplayIds[1])
+                    .SetNativeMode(modes[0]->Clone())
+                    .SetCurrentMode(modes[0]->Clone())
+                    .AddMode(modes[1]->Clone())
+                    .AddMode(modes[2]->Clone())
+                    .AddMode(modes[3]->Clone())
+                    .AddMode(modes[4]->Clone())
+                    .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
+                    .SetIsAspectPerservingScaling(true)
+                    .Build();
+
   // This test should attempt to configure a mirror mode that will not succeed
   // and should end up in extended mode.
   native_display_delegate_->set_max_configurable_pixels(
       modes[3]->size().GetArea());
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   UpdateOutputs(2, true);
 
   EXPECT_EQ(
       JoinActions(
-          kGrab, GetFramebufferAction(modes[0]->size(), &outputs_[0],
-                                      &outputs_[1]).c_str(),
-          GetCrtcAction(outputs_[0], modes[0], gfx::Point(0, 0)).c_str(),
+          kGrab, GetFramebufferAction(modes[0]->size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], modes[0].get(), gfx::Point(0, 0)).c_str(),
           // Then attempt to configure crtc1 with the first mode.
-          GetCrtcAction(outputs_[1], modes[0], gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], modes[0].get(), gfx::Point(0, 0)).c_str(),
           // First mode tried is expected to fail and it will
           // retry wil the 4th mode in the list.
-          GetCrtcAction(outputs_[0], modes[3], gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], modes[3], gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[0], modes[3].get(), gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], modes[3].get(), gfx::Point(0, 0)).c_str(),
           // Since it was requested to go into mirror mode
           // and the configured modes were different, it
           // should now try and setup a valid configurable
           // extended mode.
           GetFramebufferAction(
               gfx::Size(modes[0]->size().width(),
                         modes[0]->size().height() + modes[0]->size().height() +
                             DisplayConfigurator::kVerticalGap),
-              &outputs_[0], &outputs_[1]).c_str(),
-          GetCrtcAction(outputs_[0], modes[0], gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], modes[0],
+              outputs_[0].get(), outputs_[1].get())
+              .c_str(),
+          GetCrtcAction(*outputs_[0], modes[0].get(), gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], modes[0].get(),
                         gfx::Point(0, modes[0]->size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          GetCrtcAction(outputs_[0], modes[3], gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], modes[3],
+          GetCrtcAction(*outputs_[0], modes[3].get(), gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], modes[3].get(),
                         gfx::Point(0, modes[0]->size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kUngrab, NULL),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 // Tests that power state requests are saved after failed configuration attempts
 // so they can be reused later: http://crosbug.com/p/31571
 TEST_F(DisplayConfiguratorTest, SaveDisplayPowerStateOnConfigFailure) {
   // Start out with two displays in extended mode.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   Init(false);
   configurator_.ForceInitialConfigure(0);
@@ skipping 22 matching lines @@
   EXPECT_EQ(CALLBACK_FAILURE, PopCallbackResult());
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(1, observer_.num_failures());
   log_->GetActionsAndClear();
 
   // Simulate the external display getting disconnected and check that the
   // internal display is turned on (i.e. DISPLAY_POWER_ALL_ON is used) rather
   // than the earlier DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON state.
   native_display_delegate_->set_max_configurable_pixels(0);
   UpdateOutputs(1, true);
-  EXPECT_EQ(JoinActions(kGrab, GetFramebufferAction(small_mode_.size(),
-                                                    &outputs_[0], NULL).c_str(),
-                        GetCrtcAction(outputs_[0], &small_mode_,
-                                      gfx::Point(0, 0)).c_str(),
-                        kForceDPMS, kUngrab, NULL),
-            log_->GetActionsAndClear());
+  EXPECT_EQ(
+      JoinActions(
+          kGrab,
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
+      log_->GetActionsAndClear());
 }
 
 // Tests that the SetDisplayPowerState() task posted by HandleResume() doesn't
 // use a stale state if a new state is requested before it runs:
 // http://crosbug.com/p/32393
 TEST_F(DisplayConfiguratorTest, DontRestoreStalePowerStateAfterResume) {
   // Start out with two displays in mirrored mode.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   Init(false);
   configurator_.ForceInitialConfigure(0);
   log_->GetActionsAndClear();
   observer_.Reset();
 
   // Turn off the internal display, simulating docked mode.
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(big_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(big_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Suspend and resume the system. Resuming should restore the previous power
   // state and force a probe. Suspend should turn off the displays since an
   // external monitor is connected.
   configurator_.SuspendDisplays(base::Bind(
       &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(2, observer_.num_changes());
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0],
-              &outputs_[1]).c_str(),
-          GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], NULL, gfx::Point(0, 0)).c_str(),
-          kUngrab,
-          kSync,
-          NULL),
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
+          kUngrab, kSync, nullptr),
       log_->GetActionsAndClear());
 
   // Before the task runs, exit docked mode.
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(3, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
   EXPECT_EQ(
       JoinActions(
-          kGrab,
-          GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
-              .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
-          kForceDPMS,
-          kUngrab,
-          NULL),
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Check that the display states are not changed after resuming.
   configurator_.ResumeDisplays();
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, ExternalControl) {
   InitWithSingleOutput();
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
   configurator_.RelinquishControl(
       base::Bind(&DisplayConfiguratorTest::OnDisplayControlUpdated,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopDisplayControlResult());
+  EXPECT_EQ(JoinActions(kRelinquishDisplayControl, nullptr),
+            log_->GetActionsAndClear());
+  configurator_.TakeControl(
+      base::Bind(&DisplayConfiguratorTest::OnDisplayControlUpdated,
+                 base::Unretained(this)));
+  EXPECT_EQ(CALLBACK_SUCCESS, PopDisplayControlResult());
   EXPECT_EQ(
       JoinActions(
-          kRelinquishDisplayControl,
-          NULL),
+          kTakeDisplayControl, kGrab,
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
-  configurator_.TakeControl(
-      base::Bind(&DisplayConfiguratorTest::OnDisplayControlUpdated,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopDisplayControlResult());
-  EXPECT_EQ(JoinActions(kTakeDisplayControl, kGrab,
-                        GetFramebufferAction(small_mode_.size(), &outputs_[0],
-                                             nullptr).c_str(),
-                        GetCrtcAction(outputs_[0], &small_mode_,
-                                      gfx::Point(0, 0)).c_str(),
-                        kUngrab, NULL),
-            log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest,
        SetDisplayPowerWhilePendingConfigurationTaskRunning) {
   // Start out with two displays in extended mode.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   Init(false);
   configurator_.ForceInitialConfigure(0);
   log_->GetActionsAndClear();
   observer_.Reset();
@@ skipping 18 matching lines @@
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
 
   const int kDualHeight = small_mode_.size().height() +
                           DisplayConfigurator::kVerticalGap +
                           big_mode_.size().height();
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0], &outputs_[1])
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          GetCrtcAction(outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], nullptr,
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kUngrab, NULL),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   EXPECT_TRUE(test_api_.TriggerConfigureTimeout());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(2, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
 
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0], &outputs_[1])
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_,
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kForceDPMS, kUngrab, NULL),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest,
        SetDisplayPowerAfterFailedDisplayConfiguration) {
   // Start out with two displays in extended mode.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   Init(false);
   configurator_.ForceInitialConfigure(0);
   log_->GetActionsAndClear();
@@ skipping 13 matching lines @@
   EXPECT_EQ(1, observer_.num_failures());
 
   const int kDualHeight = small_mode_.size().height() +
                           DisplayConfigurator::kVerticalGap +
                           big_mode_.size().height();
 
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0], &outputs_[1])
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          GetCrtcAction(outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], nullptr,
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kUngrab, NULL),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // This configuration should trigger a display configuration since the
   // previous configuration failed.
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(0, observer_.num_changes());
   EXPECT_EQ(2, observer_.num_failures());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0], &outputs_[1])
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_,
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          GetCrtcAction(outputs_[1], &small_mode_,
+          GetCrtcAction(*outputs_[1], &small_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kUngrab, NULL),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Allow configuration to succeed.
   native_display_delegate_->set_max_configurable_pixels(0);
 
   // Validate that a configuration event has the proper power state (displays
   // should be on).
   configurator_.OnConfigurationChanged();
   EXPECT_TRUE(test_api_.TriggerConfigureTimeout());
 
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(2, observer_.num_failures());
 
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0], &outputs_[1])
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_,
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kUngrab, NULL),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, TestWithThreeDisplays) {
   // Start out with two displays in extended mode.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   Init(false);
   configurator_.ForceInitialConfigure(0);
   log_->GetActionsAndClear();
   observer_.Reset();
 
   UpdateOutputs(3, true);
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
 
   const int kDualHeight = small_mode_.size().height() +
                           DisplayConfigurator::kVerticalGap +
                           big_mode_.size().height();
   const int kTripleHeight = 2 * small_mode_.size().height() +
                             2 * DisplayConfigurator::kVerticalGap +
                             big_mode_.size().height();
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kTripleHeight),
-                     &outputs_[0], &outputs_[1])
+                     outputs_[0].get(), outputs_[1].get())
                      .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_,
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           GetCrtcAction(
-              outputs_[2], &small_mode_,
+              *outputs_[2], &small_mode_,
               gfx::Point(0, small_mode_.size().height() +
                                 big_mode_.size().height() +
                                 2 * DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kUngrab, NULL),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Verify that turning the power off works.
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_OFF,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kTripleHeight),
-                     &outputs_[0], &outputs_[1])
+                     outputs_[0].get(), outputs_[1].get())
                      .c_str(),
-          GetCrtcAction(outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], nullptr,
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           GetCrtcAction(
-              outputs_[2], nullptr,
+              *outputs_[2], nullptr,
               gfx::Point(0, small_mode_.size().height() +
                                 big_mode_.size().height() +
                                 2 * DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kUngrab, NULL),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_ALL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kTripleHeight),
-                     &outputs_[0], &outputs_[1])
+                     outputs_[0].get(), outputs_[1].get())
                      .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_,
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           GetCrtcAction(
-              outputs_[2], &small_mode_,
+              *outputs_[2], &small_mode_,
               gfx::Point(0, small_mode_.size().height() +
                                 big_mode_.size().height() +
                                 2 * DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kForceDPMS, kUngrab, NULL),
+          kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Disconnect the third output.
   observer_.Reset();
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
-                               &outputs_[0], &outputs_[1])
+                               outputs_[0].get(), outputs_[1].get())
               .c_str(),
-          GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
-          GetCrtcAction(outputs_[1], &big_mode_,
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
-          kUngrab, NULL),
+          kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 }  // namespace test
 }  // namespace ui