Fix namespace for src/ui/display/.

ui/display/manager/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/manager/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/fake_display_snapshot.h"
 #include "ui/display/manager/chromeos/test/action_logger_util.h"
 #include "ui/display/manager/chromeos/test/test_native_display_delegate.h"
 #include "ui/display/util/display_util.h"
 
-namespace ui {
+namespace display {
 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);
+std::unique_ptr<DisplayMode> MakeDisplayMode(int width,
+                                             int height,
+                                             bool is_interlaced,
+                                             float refresh_rate) {
+  return base::MakeUnique<DisplayMode>(gfx::Size(width, height), is_interlaced,
+                                       refresh_rate);
 }
 
 enum CallbackResult {
   CALLBACK_FAILURE,
   CALLBACK_SUCCESS,
   CALLBACK_NOT_CALLED,
 };
 
 // Expected immediate configurations should be done without any delays.
 constexpr base::TimeDelta kNoDelay = base::TimeDelta::FromMilliseconds(0);
@@ skipping 170 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_);
 
-    outputs_[0] = display::FakeDisplaySnapshot::Builder()
+    outputs_[0] = FakeDisplaySnapshot::Builder()
                       .SetId(kDisplayIds[0])
                       .SetNativeMode(small_mode_.Clone())
                       .SetCurrentMode(small_mode_.Clone())
                       .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
                       .SetIsAspectPerservingScaling(true)
                       .Build();
 
-    outputs_[1] = display::FakeDisplaySnapshot::Builder()
+    outputs_[1] = 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();
 
-    outputs_[2] = display::FakeDisplaySnapshot::Builder()
+    outputs_[2] = FakeDisplaySnapshot::Builder()
                       .SetId(kDisplayIds[2])
                       .SetNativeMode(small_mode_.Clone())
                       .SetCurrentMode(small_mode_.Clone())
                       .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
                       .SetIsAspectPerservingScaling(true)
                       .Build();
 
     UpdateOutputs(2, false);
   }
 
@@ skipping 82 matching lines @@
 
   CallbackResult display_control_result_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorTest);
 };
 
 }  // namespace
 
 TEST_F(DisplayConfiguratorTest, FindDisplayModeMatchingSize) {
-  std::unique_ptr<ui::DisplaySnapshot> output =
-      display::FakeDisplaySnapshot::Builder()
+  std::unique_ptr<DisplaySnapshot> output =
+      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))
@@ skipping 55 matching lines @@
 
   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_EQ(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(
@@ skipping 33 matching lines @@
 
   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 1st virtual display.
   int64_t virtual_display_id_1 =
       configurator_.AddVirtualDisplay(big_mode_.size());
-  EXPECT_EQ(display::GenerateDisplayID(0x8000, 0x0, 1), virtual_display_id_1);
+  EXPECT_EQ(GenerateDisplayID(0x8000, 0x0, 1), virtual_display_id_1);
   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 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].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>(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_EQ(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(
@@ skipping 97 matching lines @@
           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_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Get rid of shared modes to force software mirroring.
-  outputs_[1] = display::FakeDisplaySnapshot::Builder()
+  outputs_[1] = 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(
@@ skipping 132 matching lines @@
                      .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.
-  outputs_[1] = display::FakeDisplaySnapshot::Builder()
+  outputs_[1] = 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);
@@ skipping 261 matching lines @@
   config_waiter_.Reset();
   configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
                                 DisplayConfigurator::kSetDisplayPowerNoFlags,
                                 config_waiter_.on_configuration_callback());
   EXPECT_EQ(kNoDelay, config_waiter_.Wait());
   EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(JoinActions(kGrab, kForceDPMS, kUngrab, nullptr),
             log_->GetActionsAndClear());
 
   // Connect an external display and check that it's configured correctly.
-  outputs_[0] = display::FakeDisplaySnapshot::Builder()
+  outputs_[0] = 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(
@@ skipping 94 matching lines @@
   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());
 }
 
 TEST_F(DisplayConfiguratorTest, PanelFitting) {
   // Configure the internal display to support only the big mode and the
   // external display to support only the small mode.
-  outputs_[0] = display::FakeDisplaySnapshot::Builder()
+  outputs_[0] = FakeDisplaySnapshot::Builder()
                     .SetId(kDisplayIds[0])
                     .SetNativeMode(big_mode_.Clone())
                     .SetCurrentMode(big_mode_.Clone())
                     .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
                     .SetIsAspectPerservingScaling(true)
                     .Build();
 
-  outputs_[1] = display::FakeDisplaySnapshot::Builder()
+  outputs_[1] = 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);
@@ skipping 311 matching lines @@
   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(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));
 
-  outputs_[0] = display::FakeDisplaySnapshot::Builder()
+  outputs_[0] = 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();
@@ skipping 10 matching lines @@
       JoinActions(
           kGrab,
           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()
+  outputs_[1] = 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();
@@ skipping 618 matching lines @@
   config_waiter_.Reset();
   configurator_.ResumeDisplays();
   EXPECT_EQ(kLongDelay, config_waiter_.Wait());
   EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
             configurator_.current_power_state());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
             configurator_.display_state());
 }
 
 }  // namespace test
-}  // namespace ui
+}  // namespace display