Remove ui/gfx/screen_type_delegate.h

chrome/browser/chromeos/display/display_preferences_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 "chrome/browser/chromeos/display/display_preferences.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 229 matching lines @@
   EXPECT_EQ("left, 30", GetRegisteredDisplayLayoutStr(dummy_pair));
 }
 
 TEST_F(DisplayPreferencesTest, BasicStores) {
   ash::WindowTreeHostManager* window_tree_host_manager =
       ash::Shell::GetInstance()->window_tree_host_manager();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
   UpdateDisplay("200x200*2, 400x300#400x400|300x200*1.25");
-  int64_t id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
+  int64_t id1 = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
   ash::test::ScopedSetInternalDisplayId set_internal(id1);
   int64_t id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   int64_t dummy_id = id2 + 1;
   ASSERT_NE(id1, dummy_id);
   std::vector<ui::ColorCalibrationProfile> profiles;
   profiles.push_back(ui::COLOR_PROFILE_STANDARD);
   profiles.push_back(ui::COLOR_PROFILE_DYNAMIC);
   profiles.push_back(ui::COLOR_PROFILE_MOVIE);
   profiles.push_back(ui::COLOR_PROFILE_READING);
   // Allows only |id1|.
@@ skipping 252 matching lines @@
   property = NULL;
   EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id), &property));
   EXPECT_TRUE(property->GetInteger("width", &width));
   EXPECT_TRUE(property->GetInteger("height", &height));
   EXPECT_EQ(300, width);
   EXPECT_EQ(200, height);
 }
 
 TEST_F(DisplayPreferencesTest, StoreForSwappedDisplay) {
   UpdateDisplay("100x100,200x200");
-  int64_t id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
+  int64_t id1 = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
   int64_t id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
 
   ash::WindowTreeHostManager* window_tree_host_manager =
       ash::Shell::GetInstance()->window_tree_host_manager();
   window_tree_host_manager->SwapPrimaryDisplayForTest();
   ASSERT_EQ(id1, ash::ScreenUtil::GetSecondaryDisplay().id());
 
   LoggedInAsUser();
   ash::DisplayLayout layout(ash::DisplayLayout::TOP, 10);
   ash::Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
@@ skipping 17 matching lines @@
   EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
   EXPECT_EQ(layout.position, stored_layout.position);
   EXPECT_EQ(layout.offset, stored_layout.offset);
   EXPECT_EQ(id1, stored_layout.primary_id);
 }
 
 TEST_F(DisplayPreferencesTest, RestoreColorProfiles) {
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
-  int64_t id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
+  int64_t id1 = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   StoreColorProfile(id1, "dynamic");
 
   LoggedInAsUser();
   LoadDisplayPreferences(false);
 
   // id1's available color profiles list is empty, means somehow the color
   // profile suport is temporary in trouble.
   EXPECT_NE(ui::COLOR_PROFILE_DYNAMIC,
             display_manager->GetDisplayInfo(id1).color_profile());
@@ skipping 33 matching lines @@
   display_manager->SetDisplayRotation(new_primary, gfx::Display::ROTATE_90,
                                       gfx::Display::ROTATION_SOURCE_USER);
 
   // Does not store the preferences locally.
   EXPECT_FALSE(local_state()->FindPreference(
       prefs::kSecondaryDisplays)->HasUserSetting());
   EXPECT_FALSE(local_state()->FindPreference(
       prefs::kDisplayProperties)->HasUserSetting());
 
   // Settings are still notified to the system.
-  gfx::Screen* screen = gfx::Screen::GetNativeScreen();
+  gfx::Screen* screen = gfx::Screen::GetScreen();
   EXPECT_EQ(id2, screen->GetPrimaryDisplay().id());
   EXPECT_EQ(ash::DisplayLayout::BOTTOM,
             display_manager->GetCurrentDisplayLayout().position);
   EXPECT_EQ(-10, display_manager->GetCurrentDisplayLayout().offset);
   const gfx::Display& primary_display = screen->GetPrimaryDisplay();
   EXPECT_EQ("178x176", primary_display.bounds().size().ToString());
   EXPECT_EQ(gfx::Display::ROTATE_90, primary_display.rotation());
 
   const ash::DisplayInfo& info1 = display_manager->GetDisplayInfo(id1);
   EXPECT_EQ(1.25f, info1.configured_ui_scale());
@@ skipping 58 matching lines @@
   LoadDisplayPreferences(false);
   EXPECT_EQ(chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
             shell->display_configurator()->requested_power_state());
 }
 
 // Tests that display configuration changes caused by MaximizeModeController
 // are not saved.
 TEST_F(DisplayPreferencesTest, DontSaveMaximizeModeControllerRotations) {
   ash::Shell* shell = ash::Shell::GetInstance();
   gfx::Display::SetInternalDisplayId(
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
   ash::DisplayManager* display_manager = shell->display_manager();
   LoggedInAsUser();
   // Populate the properties.
   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                       gfx::Display::ROTATE_180,
                                       gfx::Display::ROTATION_SOURCE_USER);
   // Reset property to avoid rotation lock
   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                       gfx::Display::ROTATE_0,
                                       gfx::Display::ROTATION_SOURCE_USER);
@@ skipping 33 matching lines @@
   EXPECT_TRUE(properties->GetDictionary(
       base::Int64ToString(gfx::Display::InternalDisplayId()), &property));
   rotation = -1;
   EXPECT_TRUE(property->GetInteger("rotation", &rotation));
   EXPECT_EQ(gfx::Display::ROTATE_0, rotation);
 }
 
 // Tests that the rotation state is saved without a user being logged in.
 TEST_F(DisplayPreferencesTest, StoreRotationStateNoLogin) {
   gfx::Display::SetInternalDisplayId(
-            gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
   EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   bool current_rotation_lock = IsRotationLocked();
   StoreDisplayRotationPrefs(current_rotation_lock);
   EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayRotationLock);
   bool rotation_lock;
   EXPECT_TRUE(properties->GetBoolean("lock", &rotation_lock));
   EXPECT_EQ(current_rotation_lock, rotation_lock);
 
   int orientation;
   gfx::Display::Rotation current_rotation = GetCurrentInternalDisplayRotation();
   EXPECT_TRUE(properties->GetInteger("orientation", &orientation));
   EXPECT_EQ(current_rotation, orientation);
 }
 
 // Tests that the rotation state is saved when a guest is logged in.
 TEST_F(DisplayPreferencesTest, StoreRotationStateGuest) {
   gfx::Display::SetInternalDisplayId(
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
   EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
   LoggedInAsGuest();
 
   bool current_rotation_lock = IsRotationLocked();
   StoreDisplayRotationPrefs(current_rotation_lock);
   EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayRotationLock);
   bool rotation_lock;
   EXPECT_TRUE(properties->GetBoolean("lock", &rotation_lock));
   EXPECT_EQ(current_rotation_lock, rotation_lock);
 
   int orientation;
   gfx::Display::Rotation current_rotation = GetCurrentInternalDisplayRotation();
   EXPECT_TRUE(properties->GetInteger("orientation", &orientation));
   EXPECT_EQ(current_rotation, orientation);
 }
 
 // Tests that the rotation state is saved when a normal user is logged in.
 TEST_F(DisplayPreferencesTest, StoreRotationStateNormalUser) {
   gfx::Display::SetInternalDisplayId(
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
   EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
   LoggedInAsGuest();
 
   bool current_rotation_lock = IsRotationLocked();
   StoreDisplayRotationPrefs(current_rotation_lock);
   EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayRotationLock);
   bool rotation_lock;
   EXPECT_TRUE(properties->GetBoolean("lock", &rotation_lock));
   EXPECT_EQ(current_rotation_lock, rotation_lock);
 
   int orientation;
   gfx::Display::Rotation current_rotation = GetCurrentInternalDisplayRotation();
   EXPECT_TRUE(properties->GetInteger("orientation", &orientation));
   EXPECT_EQ(current_rotation, orientation);
 }
 
 // Tests that rotation state is loaded without a user being logged in, and that
 // entering maximize mode applies the state.
 TEST_F(DisplayPreferencesTest, LoadRotationNoLogin) {
   gfx::Display::SetInternalDisplayId(
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   ash::Shell* shell = ash::Shell::GetInstance();
   bool initial_rotation_lock = IsRotationLocked();
   ASSERT_FALSE(initial_rotation_lock);
   ash::DisplayManager* display_manager = shell->display_manager();
   gfx::Display::Rotation initial_rotation = GetCurrentInternalDisplayRotation();
   ASSERT_EQ(gfx::Display::ROTATE_0, initial_rotation);
 
   StoreDisplayRotationPrefs(initial_rotation_lock);
@@ skipping 30 matching lines @@
   bool screen_orientation_rotation_lock = IsRotationLocked();
   gfx::Display::Rotation maximize_mode_rotation =
       GetCurrentInternalDisplayRotation();
   EXPECT_TRUE(screen_orientation_rotation_lock);
   EXPECT_EQ(gfx::Display::ROTATE_90, maximize_mode_rotation);
 }
 
 // Tests that rotation lock being set causes the rotation state to be saved.
 TEST_F(DisplayPreferencesTest, RotationLockTriggersStore) {
   gfx::Display::SetInternalDisplayId(
-    gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
+      gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   ash::Shell::GetInstance()->screen_orientation_controller()->SetRotationLocked(
       true);
 
   EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayRotationLock);
   bool rotation_lock;
   EXPECT_TRUE(properties->GetBoolean("lock", &rotation_lock));
 }
 
 TEST_F(DisplayPreferencesTest, SaveUnifiedMode) {
 
   LoggedInAsUser();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   display_manager->SetUnifiedDesktopEnabled(true);
 
   UpdateDisplay("200x200,100x100");
   ash::DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
-  EXPECT_EQ(
-      "400x200",
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().size().ToString());
+  EXPECT_EQ("400x200",
+            gfx::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
 
   const base::DictionaryValue* secondary_displays =
       local_state()->GetDictionary(prefs::kSecondaryDisplays);
   const base::DictionaryValue* new_value = NULL;
   EXPECT_TRUE(
       secondary_displays->GetDictionary(ToPairString(pair), &new_value));
 
   ash::DisplayLayout stored_layout;
   EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
   EXPECT_TRUE(stored_layout.default_unified);
   EXPECT_FALSE(stored_layout.mirrored);
 
   const base::DictionaryValue* displays =
       local_state()->GetDictionary(prefs::kDisplayProperties);
-  int64_t unified_id = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
+  int64_t unified_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
   EXPECT_FALSE(
       displays->GetDictionary(base::Int64ToString(unified_id), &new_value));
 
   ash::test::SetDisplayResolution(unified_id, gfx::Size(200, 100));
-  EXPECT_EQ(
-      "200x100",
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().size().ToString());
+  EXPECT_EQ("200x100",
+            gfx::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
   EXPECT_FALSE(
       displays->GetDictionary(base::Int64ToString(unified_id), &new_value));
 
   // Mirror mode should remember if the default mode was unified.
   display_manager->SetMirrorMode(true);
   ASSERT_TRUE(
       secondary_displays->GetDictionary(ToPairString(pair), &new_value));
   EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
   EXPECT_TRUE(stored_layout.default_unified);
   EXPECT_TRUE(stored_layout.mirrored);
 
   display_manager->SetMirrorMode(false);
   ASSERT_TRUE(
       secondary_displays->GetDictionary(ToPairString(pair), &new_value));
   EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
   EXPECT_TRUE(stored_layout.default_unified);
   EXPECT_FALSE(stored_layout.mirrored);
 
   // Exit unified mode.
   display_manager->SetDefaultMultiDisplayModeForCurrentDisplays(
       ash::DisplayManager::EXTENDED);
   ASSERT_TRUE(
       secondary_displays->GetDictionary(ToPairString(pair), &new_value));
   EXPECT_TRUE(ash::DisplayLayout::ConvertFromValue(*new_value, &stored_layout));
   EXPECT_FALSE(stored_layout.default_unified);
   EXPECT_FALSE(stored_layout.mirrored);
 }
 
 TEST_F(DisplayPreferencesTest, RestoreUnifiedMode) {
-  int64_t id1 = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id();
+  int64_t id1 = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
   ash::DisplayIdPair pair = std::make_pair(id1, id1 + 1);
   StoreDisplayBoolPropertyForPair(pair, "default_unified", true);
   StoreDisplayPropertyForPair(
       pair, "primary-id",
       make_scoped_ptr(new base::StringValue(base::Int64ToString(id1))));
   LoadDisplayPreferences(false);
 
   // Should not restore to unified unless unified desktop is enabled.
   UpdateDisplay("100x100,200x200");
   ash::DisplayManager* display_manager =
@@ skipping 20 matching lines @@
   // Sanity check. Restore to extended.
   StoreDisplayBoolPropertyForPair(pair, "default_unified", false);
   StoreDisplayBoolPropertyForPair(pair, "mirrored", false);
   LoadDisplayPreferences(false);
   UpdateDisplay("100x100,200x200");
   EXPECT_FALSE(display_manager->IsInMirrorMode());
   EXPECT_FALSE(display_manager->IsInUnifiedMode());
 }
 
 }  // namespace chromeos