Move Screen Rotation from MaximizeModeController to ScreenOrientationController

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 <string>
 #include <vector>
 
+#include "ash/content/display/screen_orientation_delegate_chromeos.h"
 #include "ash/display/display_controller.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/resolution_notification_controller.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/wm/maximize_mode/maximize_mode_controller.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 14 matching lines @@
 namespace chromeos {
 namespace {
 const char kPrimaryIdKey[] = "primary-id";
 const char kMirroredKey[] = "mirrored";
 const char kPositionKey[] = "position";
 const char kOffsetKey[] = "offset";
 
 // The mean acceleration due to gravity on Earth in m/s^2.
 const float kMeanGravity = 9.80665f;
 
+bool rotation_locked() {
+  return ash::Shell::GetInstance()
+      ->screen_orientation_delegate()
+      ->rotation_locked();
+}
+
 class DisplayPreferencesTest : public ash::test::AshTestBase {
  protected:
   DisplayPreferencesTest()
       : mock_user_manager_(new MockUserManager),
         user_manager_enabler_(mock_user_manager_) {
   }
 
   virtual ~DisplayPreferencesTest() {}
 
   virtual void SetUp() override {
@@ skipping 593 matching lines @@
   local_state()->SetString(prefs::kDisplayPowerState, "all_off");
   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();
-  ash::MaximizeModeController* controller = shell->maximize_mode_controller();
   gfx::Display::SetInternalDisplayId(
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
   ash::DisplayManager* display_manager = shell->display_manager();
   LoggedInAsUser();
   // Populate the properties.
   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                       gfx::Display::ROTATE_180);
   // Reset property to avoid rotation lock
   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                       gfx::Display::ROTATE_0);
 
   // Open up 270 degrees to trigger maximize mode
   ui::AccelerometerUpdate update;
   update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
              0.0f, 0.0f, kMeanGravity);
   update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
              0.0f, -kMeanGravity, 0.0f);
+  ash::MaximizeModeController* controller = shell->maximize_mode_controller();
   controller->OnAccelerometerUpdated(update);
   EXPECT_TRUE(controller->IsMaximizeModeWindowManagerEnabled());
 
   // Trigger 90 degree rotation
   update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
              -kMeanGravity, 0.0f, 0.0f);
   update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
              -kMeanGravity, 0.0f, 0.0f);
   controller->OnAccelerometerUpdated(update);
   EXPECT_EQ(gfx::Display::ROTATE_90, display_manager->
                 GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation());
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayProperties);
   const base::DictionaryValue* property = NULL;
   EXPECT_TRUE(properties->GetDictionary(
       base::Int64ToString(gfx::Display::InternalDisplayId()), &property));
   int 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());
   EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
-  bool current_rotation_lock =
-      ash::Shell::GetInstance()->maximize_mode_controller()->rotation_locked();
+  bool current_rotation_lock = rotation_locked();
   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 = ash::Shell::GetInstance()->
       display_manager()->
           GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
   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());
   EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
   LoggedInAsGuest();
 
-  bool current_rotation_lock =
-      ash::Shell::GetInstance()->maximize_mode_controller()->rotation_locked();
+  bool current_rotation_lock = rotation_locked();
   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 = ash::Shell::GetInstance()->
       display_manager()->
           GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
   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());
   EXPECT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
   LoggedInAsGuest();
 
-  bool current_rotation_lock =
-      ash::Shell::GetInstance()->maximize_mode_controller()->rotation_locked();
+  bool current_rotation_lock = rotation_locked();
   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 = ash::Shell::GetInstance()->
       display_manager()->
           GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
   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());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   ash::Shell* shell = ash::Shell::GetInstance();
-  ash::MaximizeModeController* maximize_mode_controller =
-      shell->maximize_mode_controller();
-  bool initial_rotation_lock = maximize_mode_controller->rotation_locked();
+  bool initial_rotation_lock = rotation_locked();
   ASSERT_FALSE(initial_rotation_lock);
   ash::DisplayManager* display_manager = shell->display_manager();
   gfx::Display::Rotation initial_rotation = display_manager->
       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
   ASSERT_EQ(gfx::Display::ROTATE_0, initial_rotation);
 
   StoreDisplayRotationPrefs(initial_rotation_lock);
   ASSERT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   StoreDisplayRotationPrefsForTest(true, gfx::Display::ROTATE_90);
   LoadDisplayPreferences(false);
 
   bool display_rotation_lock =
       display_manager->registered_internal_display_rotation_lock();
   bool display_rotation =
       display_manager->registered_internal_display_rotation();
   EXPECT_TRUE(display_rotation_lock);
   EXPECT_EQ(gfx::Display::ROTATE_90, display_rotation);
 
-  bool rotation_lock = maximize_mode_controller->rotation_locked();
+  bool rotation_lock = rotation_locked();
   gfx::Display::Rotation before_maximize_mode_rotation = display_manager->
       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
 
   // Settings should not be applied until maximize mode activates
   EXPECT_FALSE(rotation_lock);
   EXPECT_EQ(gfx::Display::ROTATE_0, before_maximize_mode_rotation);
 
   // Open up 270 degrees to trigger maximize mode
   ui::AccelerometerUpdate update;
   update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
              0.0f, 0.0f, kMeanGravity);
   update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
              0.0f, -kMeanGravity, 0.0f);
+  ash::MaximizeModeController* maximize_mode_controller =
+      shell->maximize_mode_controller();
   maximize_mode_controller->OnAccelerometerUpdated(update);
   EXPECT_TRUE(maximize_mode_controller->IsMaximizeModeWindowManagerEnabled());
-  bool maximize_mode_rotation_lock =
-      maximize_mode_controller->rotation_locked();
+  bool screen_orientation_rotation_lock = rotation_locked();
   gfx::Display::Rotation maximize_mode_rotation = display_manager->
       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
-  EXPECT_TRUE(maximize_mode_rotation_lock);
+  EXPECT_TRUE(screen_orientation_rotation_lock);
   EXPECT_EQ(gfx::Display::ROTATE_90, maximize_mode_rotation);
 }
 
 // Tests that loaded rotation state is ignored if the device starts in normal
 // mode, and that they are not applied upon first entering maximize mode.
 TEST_F(DisplayPreferencesTest, LoadRotationIgnoredInNormalMode) {
   gfx::Display::SetInternalDisplayId(
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
   StoreDisplayRotationPrefs(false /* rotation_lock*/);
   ASSERT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   StoreDisplayRotationPrefsForTest(true, gfx::Display::ROTATE_90);
   LoadDisplayPreferences(false);
 
   ash::MaximizeModeController* maximize_mode_controller =
       ash::Shell::GetInstance()->maximize_mode_controller();
   // Lid open to 90 degrees
   ui::AccelerometerUpdate update;
   update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
              -kMeanGravity, 0.0f, 0.0f);
   update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
              -kMeanGravity, 0.0f, 0.0f);
   maximize_mode_controller->OnAccelerometerUpdated(update);
   EXPECT_FALSE(maximize_mode_controller->IsMaximizeModeWindowManagerEnabled());
-  EXPECT_FALSE(maximize_mode_controller->rotation_locked());
+  EXPECT_FALSE(rotation_locked());
 
   // Open up 270 degrees to trigger maximize mode
   update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
              0.0f, 0.0f, kMeanGravity);
   update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
              0.0f, -kMeanGravity, 0.0f);
   maximize_mode_controller->OnAccelerometerUpdated(update);
   EXPECT_TRUE(maximize_mode_controller->IsMaximizeModeWindowManagerEnabled());
-  EXPECT_FALSE(maximize_mode_controller->rotation_locked());
+  EXPECT_FALSE(rotation_locked());
 }
 
 // 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());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
-  ash::MaximizeModeController* maximize_mode_controller =
-      ash::Shell::GetInstance()->maximize_mode_controller();
-  maximize_mode_controller->SetRotationLocked(true);
+  ash::Shell::GetInstance()->screen_orientation_delegate()->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));
 }
 
 }  // namespace chromeos