Use injection and remove ozone dependency from ui/display

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"
@@ skipping 194 matching lines @@
     for (size_t i = 0; i < num_outputs; ++i)
       outputs.push_back(&outputs_[i]);
     native_display_delegate_->set_outputs(outputs);
 
     if (send_events) {
       configurator_.OnConfigurationChanged();
       EXPECT_TRUE(test_api_.TriggerConfigureTimeout());
     }
   }
 
+  void Init(bool panel_fitting_enabled) {
+    configurator_.Init(std::unique_ptr<NativeDisplayDelegate>(),
+                       panel_fitting_enabled);
+  }
+
   // Initializes |configurator_| with a single internal display.
   void InitWithSingleOutput() {
     UpdateOutputs(1, false);
     EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
-    configurator_.Init(false);
+    configurator_.Init(std::unique_ptr<NativeDisplayDelegate>(), 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());
   }
@@ skipping 709 matching lines @@
           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
           GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, Headless) {
   UpdateOutputs(0, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
-  configurator_.Init(false);
+  Init(false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.ForceInitialConfigure(0);
   EXPECT_EQ(JoinActions(kInitXRandR, kGrab, kForceDPMS, kUngrab, NULL),
             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,
@@ skipping 30 matching lines @@
 
   UpdateOutputs(0, true);
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
   EXPECT_EQ(framebuffer_size.ToString(),
             configurator_.framebuffer_size().ToString());
 }
 
 TEST_F(DisplayConfiguratorTest, StartWithTwoOutputs) {
   UpdateOutputs(2, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
-  configurator_.Init(false);
+  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])
               .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),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, InvalidMultipleDisplayStates) {
   UpdateOutputs(0, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
-  configurator_.Init(false);
+  Init(false);
   configurator_.ForceInitialConfigure(0);
   observer_.Reset();
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_HEADLESS);
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_SINGLE);
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(3, observer_.num_failures());
@@ skipping 19 matching lines @@
   EXPECT_EQ(0, observer_.num_changes());
   EXPECT_EQ(2, observer_.num_failures());
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   EXPECT_EQ(2, observer_.num_changes());
   EXPECT_EQ(2, observer_.num_failures());
 }
 
 TEST_F(DisplayConfiguratorTest, GetMultipleDisplayStateForMirroredDisplays) {
   UpdateOutputs(2, false);
-  configurator_.Init(false);
+  Init(false);
   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());
@@ skipping 16 matching lines @@
   outputs_[0].set_modes(std::vector<const DisplayMode*>(1, &big_mode_));
 
   outputs_[1].set_current_mode(&small_mode_);
   outputs_[1].set_native_mode(&small_mode_);
   outputs_[1].set_modes(std::vector<const DisplayMode*>(1, &small_mode_));
 
   // 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);
-  configurator_.Init(true /* is_panel_fitting_enabled */);
+  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])
               .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),
       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_, observer_.latest_outputs()[0]->current_mode());
   EXPECT_EQ(&small_mode_, observer_.latest_outputs()[1]->current_mode());
 
   // Also check that the newly-added small mode is present in the internal
   // snapshot that was passed to the observer (http://crbug.com/289159).
   DisplaySnapshot* state = observer_.latest_outputs()[0];
   ASSERT_NE(
       state->modes().end(),
       std::find(state->modes().begin(), state->modes().end(), &small_mode_));
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtection) {
-  configurator_.Init(false);
+  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());
@@ skipping 154 matching lines @@
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClients) {
   DisplayConfigurator::ContentProtectionClientId client1 =
       configurator_.RegisterContentProtectionClient();
   DisplayConfigurator::ContentProtectionClientId client2 =
       configurator_.RegisterContentProtectionClient();
   EXPECT_NE(client1, client2);
 
-  configurator_.Init(false);
+  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,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, enable_content_protection_call_count_);
@@ skipping 43 matching lines @@
             log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClientsEnable) {
   DisplayConfigurator::ContentProtectionClientId client1 =
       configurator_.RegisterContentProtectionClient();
   DisplayConfigurator::ContentProtectionClientId client2 =
       configurator_.RegisterContentProtectionClient();
   EXPECT_NE(client1, client2);
 
-  configurator_.Init(false);
+  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,
       base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, enable_content_protection_call_count_);
@@ skipping 102 matching lines @@
               .c_str(),
           kUngrab, NULL),
       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);
-  configurator_.Init(false);
+  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)));
@@ skipping 27 matching lines @@
                         kForceDPMS, kUngrab, NULL),
             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);
-  configurator_.Init(false);
+  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)));
@@ skipping 76 matching lines @@
                         GetFramebufferAction(small_mode_.size(), &outputs_[0],
                                              nullptr).c_str(),
                         GetCrtcAction(outputs_[0], &small_mode_,
                                       gfx::Point(0, 0)).c_str(),
                         kUngrab, NULL),
             log_->GetActionsAndClear());
 }
 
 }  // namespace test
 }  // namespace ui