Rename gfx::Display/Screen to display::Display/Screen in ash

ash/display/display_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/display/display_manager.h"
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_util.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/mirror_window_test_api.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
+#include "ui/display/display.h"
+#include "ui/display/display_observer.h"
 #include "ui/display/manager/display_layout_builder.h"
+#include "ui/display/screen.h"
 #include "ui/events/test/event_generator.h"
-#include "ui/gfx/display.h"
-#include "ui/gfx/display_observer.h"
 #include "ui/gfx/font_render_params.h"
-#include "ui/gfx/screen.h"
 
 namespace ash {
 
 using std::vector;
 using std::string;
 
 using base::StringPrintf;
 
 namespace {
 
 std::string ToDisplayName(int64_t id) {
   return "x-" + base::Int64ToString(id);
 }
 
 }  // namespace
 
 class DisplayManagerTest : public test::AshTestBase,
-                           public gfx::DisplayObserver,
+                           public display::DisplayObserver,
                            public aura::WindowObserver {
  public:
   DisplayManagerTest()
       : removed_count_(0U),
         root_window_destroyed_(false),
         changed_metrics_(0U) {
   }
   ~DisplayManagerTest() override {}
 
   void SetUp() override {
     AshTestBase::SetUp();
-    gfx::Screen::GetScreen()->AddObserver(this);
+    display::Screen::GetScreen()->AddObserver(this);
     Shell::GetPrimaryRootWindow()->AddObserver(this);
   }
   void TearDown() override {
     Shell::GetPrimaryRootWindow()->RemoveObserver(this);
-    gfx::Screen::GetScreen()->RemoveObserver(this);
+    display::Screen::GetScreen()->RemoveObserver(this);
     AshTestBase::TearDown();
   }
 
   DisplayManager* display_manager() {
     return Shell::GetInstance()->display_manager();
   }
-  const vector<gfx::Display>& changed() const { return changed_; }
-  const vector<gfx::Display>& added() const { return added_; }
+  const vector<display::Display>& changed() const { return changed_; }
+  const vector<display::Display>& added() const { return added_; }
   uint32_t changed_metrics() const { return changed_metrics_; }
 
   string GetCountSummary() const {
     return StringPrintf("%" PRIuS " %" PRIuS " %" PRIuS,
                         changed_.size(), added_.size(), removed_count_);
   }
 
   void reset() {
     changed_.clear();
     added_.clear();
     removed_count_ = 0U;
     changed_metrics_ = 0U;
     root_window_destroyed_ = false;
   }
 
   bool root_window_destroyed() const {
     return root_window_destroyed_;
   }
 
-  const DisplayInfo& GetDisplayInfo(const gfx::Display& display) {
+  const DisplayInfo& GetDisplayInfo(const display::Display& display) {
     return display_manager()->GetDisplayInfo(display.id());
   }
 
   const DisplayInfo& GetDisplayInfoAt(int index) {
     return GetDisplayInfo(display_manager()->GetDisplayAt(index));
   }
 
-  const gfx::Display& GetDisplayForId(int64_t id) {
+  const display::Display& GetDisplayForId(int64_t id) {
     return display_manager()->GetDisplayForId(id);
   }
 
   const DisplayInfo& GetDisplayInfoForId(int64_t id) {
     return GetDisplayInfo(display_manager()->GetDisplayForId(id));
   }
 
   // aura::DisplayObserver overrides:
-  void OnDisplayMetricsChanged(const gfx::Display& display,
+  void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t changed_metrics) override {
     changed_.push_back(display);
     changed_metrics_ |= changed_metrics;
   }
-  void OnDisplayAdded(const gfx::Display& new_display) override {
+  void OnDisplayAdded(const display::Display& new_display) override {
     added_.push_back(new_display);
   }
-  void OnDisplayRemoved(const gfx::Display& old_display) override {
+  void OnDisplayRemoved(const display::Display& old_display) override {
     ++removed_count_;
   }
 
   // aura::WindowObserver overrides:
   void OnWindowDestroying(aura::Window* window) override {
     ASSERT_EQ(Shell::GetPrimaryRootWindow(), window);
     root_window_destroyed_ = true;
   }
 
  private:
-  vector<gfx::Display> changed_;
-  vector<gfx::Display> added_;
+  vector<display::Display> changed_;
+  vector<display::Display> added_;
   size_t removed_count_;
   bool root_window_destroyed_;
   uint32_t changed_metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayManagerTest);
 };
 
 TEST_F(DisplayManagerTest, UpdateDisplayTest) {
   if (!SupportsMultipleDisplays())
     return;
@@ skipping 93 matching lines @@
   EXPECT_EQ("0,0 800x600",
             display_manager()->GetDisplayAt(0).bounds().ToString());
   EXPECT_EQ("800,0 600x400",
             display_manager()->GetDisplayAt(1).bounds().ToString());
 }
 
 TEST_F(DisplayManagerTest, ScaleOnlyChange) {
   if (!SupportsMultipleDisplays())
     return;
   display_manager()->ToggleDisplayScaleFactor();
-  EXPECT_TRUE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
-              gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+              display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
+  EXPECT_TRUE(changed_metrics() &
+              display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
 }
 
 // Test in emulation mode (use_fullscreen_host_window=false)
 TEST_F(DisplayManagerTest, EmulatorTest) {
   if (!SupportsMultipleDisplays())
     return;
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   display_manager()->AddRemoveDisplay();
@@ skipping 68 matching lines @@
   EXPECT_EQ("10,480 320x200",
             display_manager()->GetDisplayAt(1).bounds().ToString());
   EXPECT_EQ("20,680 400x300",
             display_manager()->GetDisplayAt(2).bounds().ToString());
 }
 
 TEST_F(DisplayManagerTest, LayoutMorethanThreeDisplaysTest) {
   if (!SupportsMultipleDisplays())
     return;
 
-  int64_t primary_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
+  int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display::DisplayIdList list = ash::test::CreateDisplayIdListN(
       3, primary_id, primary_id + 1, primary_id + 2);
   {
     // Layout: [2]
     //         [1][P]
     display::DisplayLayoutBuilder builder(primary_id);
     builder.AddDisplayPlacement(list[1], primary_id,
                                 display::DisplayPlacement::LEFT, 10);
     builder.AddDisplayPlacement(list[2], list[1],
                                 display::DisplayPlacement::TOP, 10);
@@ skipping 112 matching lines @@
     return;
 
   UpdateDisplay("0+0-500x500,0+501-400x400");
   reset();
   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
   const DisplayInfo& display_info1 = GetDisplayInfoAt(0);
   const DisplayInfo& display_info2 = GetDisplayInfoAt(1);
   display_manager()->SetOverscanInsets(
       display_info2.id(), gfx::Insets(13, 12, 11, 10));
 
-  std::vector<gfx::Display> changed_displays = changed();
+  std::vector<display::Display> changed_displays = changed();
   EXPECT_EQ(1u, changed_displays.size());
   EXPECT_EQ(display_info2.id(), changed_displays[0].id());
   EXPECT_EQ("0,0 500x500",
             GetDisplayInfoAt(0).bounds_in_native().ToString());
   DisplayInfo updated_display_info2 = GetDisplayInfoAt(1);
   EXPECT_EQ("0,501 400x400",
             updated_display_info2.bounds_in_native().ToString());
   EXPECT_EQ("378x376",
             updated_display_info2.size_in_pixel().ToString());
   EXPECT_EQ("13,12,11,10",
@@ skipping 66 matching lines @@
 
   // Make sure switching primary display applies the overscan offset only once.
   ash::Shell::GetInstance()->window_tree_host_manager()->SetPrimaryDisplayId(
       ScreenUtil::GetSecondaryDisplay().id());
   EXPECT_EQ("-500,0 500x500",
             ScreenUtil::GetSecondaryDisplay().bounds().ToString());
   EXPECT_EQ("0,0 500x500",
             GetDisplayInfo(ScreenUtil::GetSecondaryDisplay()).
             bounds_in_native().ToString());
   EXPECT_EQ("0,501 400x400",
-            GetDisplayInfo(gfx::Screen::GetScreen()->GetPrimaryDisplay())
+            GetDisplayInfo(display::Screen::GetScreen()->GetPrimaryDisplay())
                 .bounds_in_native()
                 .ToString());
-  EXPECT_EQ("0,0 188x190",
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
+  EXPECT_EQ(
+      "0,0 188x190",
+      display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 
   // Make sure just moving the overscan area should property notify observers.
   UpdateDisplay("0+0-500x500");
-  int64_t primary_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
+  int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display_manager()->SetOverscanInsets(primary_id, gfx::Insets(0, 0, 20, 20));
-  EXPECT_EQ("0,0 480x480",
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
+  EXPECT_EQ(
+      "0,0 480x480",
+      display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
   reset();
   display_manager()->SetOverscanInsets(primary_id, gfx::Insets(10, 10, 10, 10));
-  EXPECT_TRUE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
-  EXPECT_TRUE(
-      changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
-  EXPECT_EQ("0,0 480x480",
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
+  EXPECT_TRUE(changed_metrics() &
+              display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
+  EXPECT_TRUE(changed_metrics() &
+              display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+  EXPECT_EQ(
+      "0,0 480x480",
+      display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
   reset();
   display_manager()->SetOverscanInsets(primary_id, gfx::Insets(0, 0, 0, 0));
-  EXPECT_TRUE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
-  EXPECT_TRUE(
-      changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
-  EXPECT_EQ("0,0 500x500",
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
+  EXPECT_TRUE(changed_metrics() &
+              display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
+  EXPECT_TRUE(changed_metrics() &
+              display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+  EXPECT_EQ(
+      "0,0 500x500",
+      display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 }
 
 TEST_F(DisplayManagerTest, ZeroOverscanInsets) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Make sure the display change events is emitted for overscan inset changes.
   UpdateDisplay("0+0-500x500,0+501-400x400");
   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
   int64_t display2_id = display_manager()->GetDisplayAt(1).id();
@@ skipping 35 matching lines @@
   DisplayInfo info(id, ToDisplayName(id), false);
   info.SetBounds(bounds);
   return info;
 }
 
 TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   const int external_id = 10;
   const int mirror_id = 11;
-  const int64_t invalid_id = gfx::Display::kInvalidDisplayID;
+  const int64_t invalid_id = display::Display::kInvalidDisplayID;
   const DisplayInfo internal_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
   const DisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
   const DisplayInfo mirroring_display_info =
       CreateDisplayInfo(mirror_id, gfx::Rect(0, 0, 500, 500));
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   std::string default_bounds =
@@ skipping 14 matching lines @@
   // External connected while primary was disconnected.
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   EXPECT_EQ(invalid_id, GetDisplayForId(internal_display_id).id());
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(external_id).bounds_in_native().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
-  EXPECT_EQ(external_id, gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
+  EXPECT_EQ(external_id,
+            display::Screen::GetScreen()->GetPrimaryDisplay().id());
 
-  EXPECT_EQ(internal_display_id, gfx::Display::InternalDisplayId());
+  EXPECT_EQ(internal_display_id, display::Display::InternalDisplayId());
 
   // Primary connected, with different bounds.
   display_info_list.clear();
   display_info_list.push_back(internal_display_info);
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ(internal_display_id,
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
+            display::Screen::GetScreen()->GetPrimaryDisplay().id());
 
   // This combinatino is new, so internal display becomes primary.
   EXPECT_EQ("0,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(10).bounds_in_native().ToString());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_EQ(ToDisplayName(internal_display_id),
             display_manager()->GetDisplayNameForId(internal_display_id));
@@ skipping 373 matching lines @@
   UpdateDisplay("200x200/l");
   EXPECT_EQ("1 0 0", GetCountSummary());
 
   // Having the internal display deactivated should restore user rotation. Newly
   // set rotations should be applied.
   UpdateDisplay("200x200, 200x200");
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
 
   display_manager()->SetDisplayRotation(internal_display_id,
-                                        gfx::Display::ROTATE_90,
-                                        gfx::Display::ROTATION_SOURCE_USER);
-  display_manager()->SetDisplayRotation(internal_display_id,
-                                        gfx::Display::ROTATE_0,
-                                        gfx::Display::ROTATION_SOURCE_ACTIVE);
+                                        display::Display::ROTATE_90,
+                                        display::Display::ROTATION_SOURCE_USER);
+  display_manager()->SetDisplayRotation(
+      internal_display_id, display::Display::ROTATE_0,
+      display::Display::ROTATION_SOURCE_ACTIVE);
 
   const DisplayInfo info = GetDisplayInfoForId(internal_display_id);
-  EXPECT_EQ(gfx::Display::ROTATE_0, info.GetActiveRotation());
+  EXPECT_EQ(display::Display::ROTATE_0, info.GetActiveRotation());
 
   // Deactivate internal display to simulate Docked Mode.
   vector<DisplayInfo> secondary_only;
   secondary_only.push_back(GetDisplayInfoAt(1));
   display_manager()->OnNativeDisplaysChanged(secondary_only);
 
   const DisplayInfo post_removal_info =
       display_manager()->display_info_[internal_display_id];
   EXPECT_NE(info.GetActiveRotation(), post_removal_info.GetActiveRotation());
-  EXPECT_EQ(gfx::Display::ROTATE_90, post_removal_info.GetActiveRotation());
+  EXPECT_EQ(display::Display::ROTATE_90, post_removal_info.GetActiveRotation());
 
-  display_manager()->SetDisplayRotation(internal_display_id,
-                                        gfx::Display::ROTATE_180,
-                                        gfx::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetDisplayRotation(
+      internal_display_id, display::Display::ROTATE_180,
+      display::Display::ROTATION_SOURCE_ACTIVE);
   const DisplayInfo post_rotation_info =
       display_manager()->display_info_[internal_display_id];
   EXPECT_NE(info.GetActiveRotation(), post_rotation_info.GetActiveRotation());
-  EXPECT_EQ(gfx::Display::ROTATE_180, post_rotation_info.GetActiveRotation());
+  EXPECT_EQ(display::Display::ROTATE_180,
+            post_rotation_info.GetActiveRotation());
 }
 
 #if defined(OS_WIN)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #define MAYBE_UIScale DISABLED_UIScale
 #else
 #define MAYBE_UIScale UIScale
 #endif
 TEST_F(DisplayManagerTest, MAYBE_UIScale) {
   test::ScopedDisable125DSFForUIScaling disable;
 
   UpdateDisplay("1280x800");
-  int64_t display_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
+  int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   SetDisplayUIScale(display_id, 1.125f);
   EXPECT_EQ(1.0, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.75f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.625f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 
   test::ScopedSetInternalDisplayId set_internal(display_id);
@@ skipping 36 matching lines @@
   UpdateDisplay("1280x850*2");
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 1.5f);
   EXPECT_EQ(1.5f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 1.125f);
   EXPECT_EQ(1.125f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 1.0f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
-  gfx::Display display = gfx::Screen::GetScreen()->GetPrimaryDisplay();
+  display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
   EXPECT_EQ(2.0f, display.device_scale_factor());
   EXPECT_EQ("640x425", display.bounds().size().ToString());
 
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.75f);
   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.625f);
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.6f);
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.5f);
   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).configured_ui_scale());
 
   SetDisplayUIScale(display_id, 2.0f);
   EXPECT_EQ(2.0f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
-  display = gfx::Screen::GetScreen()->GetPrimaryDisplay();
+  display = display::Screen::GetScreen()->GetPrimaryDisplay();
   EXPECT_EQ(1.0f, display.device_scale_factor());
   EXPECT_EQ("1280x850", display.bounds().size().ToString());
 
   // 1.25 ui scaling on 1.25 DSF device should use 1.0 DSF
   // on screen.
   UpdateDisplay("1280x850*1.25");
   SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
-  display = gfx::Screen::GetScreen()->GetPrimaryDisplay();
+  display = display::Screen::GetScreen()->GetPrimaryDisplay();
   EXPECT_EQ(1.0f, display.device_scale_factor());
   EXPECT_EQ("1280x850", display.bounds().size().ToString());
 }
 
 TEST_F(DisplayManagerTest, UIScaleWithDisplayMode) {
   int display_id = 1000;
 
   // Setup the display modes with UI-scale.
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1280, 800));
@@ skipping 50 matching lines @@
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
 
 #if defined(OS_WIN) && !defined(USE_ASH)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 #define MAYBE_Use125DSFForUIScaling DISABLED_Use125DSFForUIScaling
 #else
 #define MAYBE_Use125DSFForUIScaling Use125DSFForUIScaling
 #endif
 TEST_F(DisplayManagerTest, MAYBE_Use125DSFForUIScaling) {
-  int64_t display_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
+  int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   test::ScopedSetInternalDisplayId set_internal(display_id);
 
   UpdateDisplay("1920x1080*1.25");
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   EXPECT_EQ("1536x864", GetDisplayForId(display_id).size().ToString());
@@ skipping 13 matching lines @@
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display_manager->SetUnifiedDesktopEnabled(true);
 
   UpdateDisplay("200x200, 400x400");
 
-  int64_t unified_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
+  int64_t unified_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   DisplayInfo info = display_manager->GetDisplayInfo(unified_id);
   ASSERT_EQ(2u, info.display_modes().size());
   EXPECT_EQ("400x200", info.display_modes()[0].size.ToString());
   EXPECT_TRUE(info.display_modes()[0].native);
   EXPECT_EQ("800x400", info.display_modes()[1].size.ToString());
   EXPECT_FALSE(info.display_modes()[1].native);
-  EXPECT_EQ("400x200",
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
+  EXPECT_EQ(
+      "400x200",
+      display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
   DisplayMode active_mode =
       display_manager->GetActiveModeForDisplayId(unified_id);
   EXPECT_EQ(1.0f, active_mode.ui_scale);
   EXPECT_EQ("400x200", active_mode.size.ToString());
 
   EXPECT_TRUE(test::SetDisplayResolution(unified_id, gfx::Size(800, 400)));
-  EXPECT_EQ("800x400",
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
+  EXPECT_EQ(
+      "800x400",
+      display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
 
   active_mode = display_manager->GetActiveModeForDisplayId(unified_id);
   EXPECT_EQ(1.0f, active_mode.ui_scale);
   EXPECT_EQ("800x400", active_mode.size.ToString());
 
   // resolution change will not persist in unified desktop mode.
   UpdateDisplay("600x600, 200x200");
-  EXPECT_EQ("1200x600",
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
+  EXPECT_EQ(
+      "1200x600",
+      display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
   active_mode = display_manager->GetActiveModeForDisplayId(unified_id);
   EXPECT_EQ(1.0f, active_mode.ui_scale);
   EXPECT_TRUE(active_mode.native);
   EXPECT_EQ("1200x600", active_mode.size.ToString());
 }
 
 #if defined(OS_WIN)
 // TODO(scottmg): RootWindow doesn't get resized on Windows
 // Ash. http://crbug.com/247916.
 #define MAYBE_UpdateMouseCursorAfterRotateZoom \
@@ skipping 42 matching lines @@
   EXPECT_EQ("700,125", env->last_mouse_location().ToString());
   UpdateDisplay("600x400,400x300*2@1.5");
   EXPECT_EQ("750,187", env->last_mouse_location().ToString());
 
   // The native location is now outside, so move to the
   // center of closest display.
   UpdateDisplay("600x400,400x200*2@1.5");
   EXPECT_EQ("750,75", env->last_mouse_location().ToString());
 }
 
-class TestDisplayObserver : public gfx::DisplayObserver {
+class TestDisplayObserver : public display::DisplayObserver {
  public:
   TestDisplayObserver() : changed_(false) {}
   ~TestDisplayObserver() override {}
 
-  // gfx::DisplayObserver overrides:
-  void OnDisplayMetricsChanged(const gfx::Display&, uint32_t) override {}
-  void OnDisplayAdded(const gfx::Display& new_display) override {
+  // display::DisplayObserver overrides:
+  void OnDisplayMetricsChanged(const display::Display&, uint32_t) override {}
+  void OnDisplayAdded(const display::Display& new_display) override {
     // Mirror window should already be delete before restoring
     // the external display.
     EXPECT_FALSE(test_api.GetHost());
     changed_ = true;
   }
-  void OnDisplayRemoved(const gfx::Display& old_display) override {
+  void OnDisplayRemoved(const display::Display& old_display) override {
     // Mirror window should not be created until the external display
     // is removed.
     EXPECT_FALSE(test_api.GetHost());
     changed_ = true;
   }
 
   bool changed_and_reset() {
     bool changed = changed_;
     changed_ = false;
     return changed;
   }
 
  private:
   test::MirrorWindowTestApi test_api;
   bool changed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDisplayObserver);
 };
 
 TEST_F(DisplayManagerTest, SoftwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("300x400,400x500");
 
   test::MirrorWindowTestApi test_api;
   EXPECT_EQ(nullptr, test_api.GetHost());
 
   TestDisplayObserver display_observer;
-  gfx::Screen::GetScreen()->AddObserver(&display_observer);
+  display::Screen::GetScreen()->AddObserver(&display_observer);
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display_manager->SetMultiDisplayMode(DisplayManager::MIRRORING);
   display_manager->UpdateDisplays();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(display_observer.changed_and_reset());
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
-  EXPECT_EQ("0,0 300x400",
-            gfx::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
+  EXPECT_EQ(
+      "0,0 300x400",
+      display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
   EXPECT_EQ("400x500", test_api.GetHost()->GetBounds().size().ToString());
   EXPECT_EQ("300x400",
             test_api.GetHost()->window()->bounds().size().ToString());
   EXPECT_TRUE(display_manager->IsInMirrorMode());
 
   display_manager->SetMirrorMode(false);
   EXPECT_TRUE(display_observer.changed_and_reset());
   EXPECT_EQ(nullptr, test_api.GetHost());
   EXPECT_EQ(2U, display_manager->GetNumDisplays());
   EXPECT_FALSE(display_manager->IsInMirrorMode());
@@ skipping 22 matching lines @@
   EXPECT_FALSE(display_observer.changed_and_reset());
   EXPECT_EQ("330x440",
             test_api.GetHost()->window()->bounds().size().ToString());
 
   // Overscan insets are ignored.
   UpdateDisplay("400x600/o,600x800/o");
   EXPECT_FALSE(display_observer.changed_and_reset());
   EXPECT_EQ("400x600",
             test_api.GetHost()->window()->bounds().size().ToString());
 
-  gfx::Screen::GetScreen()->RemoveObserver(&display_observer);
+  display::Screen::GetScreen()->RemoveObserver(&display_observer);
 }
 
 TEST_F(DisplayManagerTest, RotateInSoftwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   UpdateDisplay("600x400,500x300");
   display_manager->SetMirrorMode(true);
 
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
-  int64_t primary_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
-  display_manager->SetDisplayRotation(primary_id, gfx::Display::ROTATE_180,
-                                      gfx::Display::ROTATION_SOURCE_ACTIVE);
+  int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
+  display_manager->SetDisplayRotation(primary_id, display::Display::ROTATE_180,
+                                      display::Display::ROTATION_SOURCE_ACTIVE);
   display_manager->SetMirrorMode(false);
 }
 
 TEST_F(DisplayManagerTest, SingleDisplayToSoftwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("600x400");
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display_manager->SetMultiDisplayMode(DisplayManager::MIRRORING);
@@ skipping 53 matching lines @@
 }
 #endif  // OS_CHROMEOS
 
 TEST_F(DisplayManagerTest, MirroredLayout) {
   if (!SupportsMultipleDisplays())
     return;
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   UpdateDisplay("500x500,400x400");
   EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
-  EXPECT_EQ(2, gfx::Screen::GetScreen()->GetNumDisplays());
+  EXPECT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager->num_connected_displays());
 
   UpdateDisplay("1+0-500x500,1+0-500x500");
   EXPECT_TRUE(display_manager->GetCurrentDisplayLayout().mirrored);
-  EXPECT_EQ(1, gfx::Screen::GetScreen()->GetNumDisplays());
+  EXPECT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager->num_connected_displays());
 
   UpdateDisplay("500x500,500x500");
   EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
-  EXPECT_EQ(2, gfx::Screen::GetScreen()->GetNumDisplays());
+  EXPECT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager->num_connected_displays());
 }
 
 TEST_F(DisplayManagerTest, InvertLayout) {
   EXPECT_EQ("left, 0",
             display::DisplayPlacement(display::DisplayPlacement::RIGHT, 0)
                 .Swap()
                 .ToString());
   EXPECT_EQ("left, -100",
             display::DisplayPlacement(display::DisplayPlacement::RIGHT, 100)
@@ skipping 44 matching lines @@
                 .ToString());
 }
 
 TEST_F(DisplayManagerTest, NotifyPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("500x500,500x500");
   test::SwapPrimaryDisplay();
   reset();
   UpdateDisplay("500x500");
-  EXPECT_FALSE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_FALSE(changed_metrics() &
-               gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+               display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
+  EXPECT_FALSE(changed_metrics() &
+               display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_TRUE(changed_metrics() &
-              gfx::DisplayObserver::DISPLAY_METRIC_PRIMARY);
+              display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 
   UpdateDisplay("500x500,500x500");
   test::SwapPrimaryDisplay();
   UpdateDisplay("500x400");
-  EXPECT_TRUE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
-              gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+              display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
-              gfx::DisplayObserver::DISPLAY_METRIC_PRIMARY);
+              display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+  EXPECT_TRUE(changed_metrics() &
+              display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 }
 
 TEST_F(DisplayManagerTest, NotifyPrimaryChangeUndock) {
   if (!SupportsMultipleDisplays())
     return;
   // Assume the default display is an external display, and
   // emulates undocking by switching to another display.
   DisplayInfo another_display_info =
       CreateDisplayInfo(1, gfx::Rect(0, 0, 1280, 800));
   std::vector<DisplayInfo> info_list;
   info_list.push_back(another_display_info);
   reset();
   display_manager()->OnNativeDisplaysChanged(info_list);
-  EXPECT_TRUE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
-              gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+              display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
-              gfx::DisplayObserver::DISPLAY_METRIC_PRIMARY);
+              display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+  EXPECT_TRUE(changed_metrics() &
+              display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 }
 
 #if defined(OS_WIN)
 // TODO(scottmg): RootWindow doesn't get resized on Windows
 // Ash. http://crbug.com/247916.
 #define MAYBE_UpdateDisplayWithHostOrigin DISABLED_UpdateDisplayWithHostOrigin
 #else
 #define MAYBE_UpdateDisplayWithHostOrigin UpdateDisplayWithHostOrigin
 #endif
 
 TEST_F(DisplayManagerTest, MAYBE_UpdateDisplayWithHostOrigin) {
   UpdateDisplay("100x200,300x400");
-  ASSERT_EQ(2, gfx::Screen::GetScreen()->GetNumDisplays());
+  ASSERT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   aura::Window::Windows root_windows =
       Shell::GetInstance()->GetAllRootWindows();
   ASSERT_EQ(2U, root_windows.size());
   aura::WindowTreeHost* host0 = root_windows[0]->GetHost();
   aura::WindowTreeHost* host1 = root_windows[1]->GetHost();
 
   EXPECT_EQ("1,1", host0->GetBounds().origin().ToString());
   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
   // UpdateDisplay set the origin if it's not set.
   EXPECT_NE("1,1", host1->GetBounds().origin().ToString());
   EXPECT_EQ("300x400", host1->GetBounds().size().ToString());
 
   UpdateDisplay("100x200,200+300-300x400");
-  ASSERT_EQ(2, gfx::Screen::GetScreen()->GetNumDisplays());
+  ASSERT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ("0,0", host0->GetBounds().origin().ToString());
   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
   EXPECT_EQ("200,300", host1->GetBounds().origin().ToString());
   EXPECT_EQ("300x400", host1->GetBounds().size().ToString());
 
   UpdateDisplay("400+500-200x300,300x400");
-  ASSERT_EQ(2, gfx::Screen::GetScreen()->GetNumDisplays());
+  ASSERT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ("400,500", host0->GetBounds().origin().ToString());
   EXPECT_EQ("200x300", host0->GetBounds().size().ToString());
   EXPECT_EQ("0,0", host1->GetBounds().origin().ToString());
   EXPECT_EQ("300x400", host1->GetBounds().size().ToString());
 
   UpdateDisplay("100+200-100x200,300+500-200x300");
-  ASSERT_EQ(2, gfx::Screen::GetScreen()->GetNumDisplays());
+  ASSERT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ("100,200", host0->GetBounds().origin().ToString());
   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
   EXPECT_EQ("300,500", host1->GetBounds().origin().ToString());
   EXPECT_EQ("200x300", host1->GetBounds().size().ToString());
 }
 
 TEST_F(DisplayManagerTest, UnifiedDesktopBasic) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   UpdateDisplay("400x500,300x200");
 
   // Enable after extended mode.
   display_manager()->SetUnifiedDesktopEnabled(true);
 
   // Defaults to the unified desktop.
-  gfx::Screen* screen = gfx::Screen::GetScreen();
+  display::Screen* screen = display::Screen::GetScreen();
   // The 2nd display is scaled so that it has the same height as 1st display.
   // 300 * 500 / 200  + 400 = 1150.
   EXPECT_EQ(gfx::Size(1150, 500), screen->GetPrimaryDisplay().size());
 
   display_manager()->SetMirrorMode(true);
   EXPECT_EQ(gfx::Size(400, 500), screen->GetPrimaryDisplay().size());
 
   display_manager()->SetMirrorMode(false);
   EXPECT_EQ(gfx::Size(1150, 500), screen->GetPrimaryDisplay().size());
 
@@ skipping 89 matching lines @@
   EXPECT_FALSE(display_manager()->IsInUnifiedMode());
 }
 
 TEST_F(DisplayManagerTest, UnifiedDesktopWith2xDSF) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   display_manager()->SetUnifiedDesktopEnabled(true);
-  gfx::Screen* screen = gfx::Screen::GetScreen();
+  display::Screen* screen = display::Screen::GetScreen();
 
   // 2nd display is 2x.
   UpdateDisplay("400x500,1000x800*2");
   DisplayInfo info =
       display_manager()->GetDisplayInfo(screen->GetPrimaryDisplay().id());
   EXPECT_EQ(2u, info.display_modes().size());
   EXPECT_EQ("1640x800", info.display_modes()[0].size.ToString());
   EXPECT_EQ(2.0f, info.display_modes()[0].device_scale_factor);
   EXPECT_EQ("1025x500", info.display_modes()[1].size.ToString());
   EXPECT_EQ(1.0f, info.display_modes()[1].device_scale_factor);
@@ skipping 100 matching lines @@
 TEST_F(DisplayManagerTest, NoRotateUnifiedDesktop) {
   if (!SupportsMultipleDisplays())
     return;
   display_manager()->SetUnifiedDesktopEnabled(true);
 
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   UpdateDisplay("400x500,300x200");
 
-  gfx::Screen* screen = gfx::Screen::GetScreen();
-  const gfx::Display& display = screen->GetPrimaryDisplay();
+  display::Screen* screen = display::Screen::GetScreen();
+  const display::Display& display = screen->GetPrimaryDisplay();
   EXPECT_EQ("1150x500", display.size().ToString());
-  display_manager()->SetDisplayRotation(display.id(), gfx::Display::ROTATE_90,
-                                        gfx::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetDisplayRotation(
+      display.id(), display::Display::ROTATE_90,
+      display::Display::ROTATION_SOURCE_ACTIVE);
   EXPECT_EQ("1150x500", screen->GetPrimaryDisplay().size().ToString());
-  display_manager()->SetDisplayRotation(display.id(), gfx::Display::ROTATE_0,
-                                        gfx::Display::ROTATION_SOURCE_ACTIVE);
+  display_manager()->SetDisplayRotation(
+      display.id(), display::Display::ROTATE_0,
+      display::Display::ROTATION_SOURCE_ACTIVE);
   EXPECT_EQ("1150x500", screen->GetPrimaryDisplay().size().ToString());
 
   UpdateDisplay("400x500");
   EXPECT_EQ("400x500", screen->GetPrimaryDisplay().size().ToString());
 }
 
 // Makes sure the transition from unified to single won't crash
 // with docked windows.
 TEST_F(DisplayManagerTest, UnifiedWithDockWindows) {
   if (!SupportsMultipleDisplays())
@@ skipping 48 matching lines @@
   const DisplayInfo& info = display_manager()->GetDisplayInfo(internal_id);
   DisplayMode mode;
 
   EXPECT_FALSE(GetDisplayModeForNextUIScale(info, true, &mode));
   EXPECT_FALSE(GetDisplayModeForNextUIScale(info, false, &mode));
   EXPECT_FALSE(SetDisplayUIScale(internal_id, 1.0f));
 
   DisplayInfo invalid_info;
   EXPECT_FALSE(GetDisplayModeForNextUIScale(invalid_info, true, &mode));
   EXPECT_FALSE(GetDisplayModeForNextUIScale(invalid_info, false, &mode));
-  EXPECT_FALSE(SetDisplayUIScale(gfx::Display::kInvalidDisplayID, 1.0f));
+  EXPECT_FALSE(SetDisplayUIScale(display::Display::kInvalidDisplayID, 1.0f));
 }
 
 // Make sure that bad layout information is ignored and does not crash.
 TEST_F(DisplayManagerTest, DontRegisterBadConfig) {
   if (!SupportsMultipleDisplays())
     return;
   display::DisplayIdList list = ash::test::CreateDisplayIdList2(1, 2);
   display::DisplayLayoutBuilder builder(1);
   builder.AddDisplayPlacement(2, 1, display::DisplayPlacement::LEFT, 0);
   builder.AddDisplayPlacement(3, 1, display::DisplayPlacement::BOTTOM, 0);
 
   display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
       list, builder.Build());
 }
 
 class ScreenShutdownTest : public test::AshTestBase {
  public:
   ScreenShutdownTest() {
   }
   ~ScreenShutdownTest() override {}
 
   void TearDown() override {
-    gfx::Screen* orig_screen = gfx::Screen::GetScreen();
+    display::Screen* orig_screen = display::Screen::GetScreen();
     AshTestBase::TearDown();
     if (!SupportsMultipleDisplays())
       return;
-    gfx::Screen* screen = gfx::Screen::GetScreen();
+    display::Screen* screen = display::Screen::GetScreen();
     EXPECT_NE(orig_screen, screen);
     EXPECT_EQ(2, screen->GetNumDisplays());
     EXPECT_EQ("500x300", screen->GetPrimaryDisplay().size().ToString());
-    std::vector<gfx::Display> all = screen->GetAllDisplays();
+    std::vector<display::Display> all = screen->GetAllDisplays();
     EXPECT_EQ("500x300", all[0].size().ToString());
     EXPECT_EQ("800x400", all[1].size().ToString());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScreenShutdownTest);
 };
 
 TEST_F(ScreenShutdownTest, ScreenAfterShutdown) {
   if (!SupportsMultipleDisplays())
@@ skipping 47 matching lines @@
 }
 
 }  // namespace
 
 typedef testing::Test DisplayManagerFontTest;
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf100Internal) {
   FontTestHelper helper(1.0f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       1.0f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_FALSE(IsTextSubpixelPositioningEnabled());
   EXPECT_NE(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf125Internal) {
   test::ScopedDisable125DSFForUIScaling disable;
   FontTestHelper helper(1.25f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       1.25f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf200Internal) {
   FontTestHelper helper(2.0f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       2.0f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 
-  SetDisplayUIScale(gfx::Screen::GetScreen()->GetPrimaryDisplay().id(), 2.0f);
+  SetDisplayUIScale(display::Screen::GetScreen()->GetPrimaryDisplay().id(),
+                    2.0f);
 
   ASSERT_DOUBLE_EQ(
       1.0f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_FALSE(IsTextSubpixelPositioningEnabled());
   EXPECT_NE(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf100External) {
   FontTestHelper helper(1.0f, FontTestHelper::EXTERNAL);
   ASSERT_DOUBLE_EQ(
       1.0f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_FALSE(IsTextSubpixelPositioningEnabled());
   EXPECT_NE(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf125External) {
   FontTestHelper helper(1.25f, FontTestHelper::EXTERNAL);
   ASSERT_DOUBLE_EQ(
       1.25f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest, TextSubpixelPositioningWithDsf200External) {
   FontTestHelper helper(2.0f, FontTestHelper::EXTERNAL);
   ASSERT_DOUBLE_EQ(
       2.0f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerFontTest,
        TextSubpixelPositioningWithDsf125InternalWithScaling) {
   FontTestHelper helper(1.25f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       1.0f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_FALSE(IsTextSubpixelPositioningEnabled());
   EXPECT_NE(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 
-  SetDisplayUIScale(gfx::Screen::GetScreen()->GetPrimaryDisplay().id(), 0.8f);
+  SetDisplayUIScale(display::Screen::GetScreen()->GetPrimaryDisplay().id(),
+                    0.8f);
 
   ASSERT_DOUBLE_EQ(
       1.25f,
-      gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
 TEST_F(DisplayManagerTest, CheckInitializationOfRotationProperty) {
   int64_t id = display_manager()->GetDisplayAt(0).id();
-  display_manager()->RegisterDisplayProperty(id, gfx::Display::ROTATE_90, 1.0f,
-                                             nullptr, gfx::Size(), 1.0f,
+  display_manager()->RegisterDisplayProperty(id, display::Display::ROTATE_90,
+                                             1.0f, nullptr, gfx::Size(), 1.0f,
                                              ui::COLOR_PROFILE_STANDARD);
 
   const DisplayInfo& info = display_manager()->GetDisplayInfo(id);
 
-  EXPECT_EQ(gfx::Display::ROTATE_90,
-            info.GetRotation(gfx::Display::ROTATION_SOURCE_USER));
-  EXPECT_EQ(gfx::Display::ROTATE_90,
-            info.GetRotation(gfx::Display::ROTATION_SOURCE_ACTIVE));
+  EXPECT_EQ(display::Display::ROTATE_90,
+            info.GetRotation(display::Display::ROTATION_SOURCE_USER));
+  EXPECT_EQ(display::Display::ROTATE_90,
+            info.GetRotation(display::Display::ROTATION_SOURCE_ACTIVE));
 }
 
 TEST_F(DisplayManagerTest, RejectInvalidLayoutData) {
   DisplayLayoutStore* layout_store = display_manager()->layout_store();
   int64_t id1 = 10001;
   int64_t id2 = 10002;
   ASSERT_TRUE(CompareDisplayIds(id1, id2));
   display::DisplayLayoutBuilder good_builder(id1);
   good_builder.SetSecondaryPlacement(id2, display::DisplayPlacement::LEFT, 0);
   std::unique_ptr<display::DisplayLayout> good(good_builder.Build());
@@ skipping 28 matching lines @@
   const display::DisplayLayout& stored =
       layout_store->GetRegisteredDisplayLayout(list);
 
   EXPECT_EQ(id1, stored.placement_list[0].parent_display_id);
   EXPECT_EQ(id2, stored.placement_list[0].display_id);
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash