chrome/browser/chromeos/policy/display_rotation_default_handler_browsertest.cc - chromium/src - Git at Google

 // Copyright 2015 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 <stdint.h>

 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/policy/device_policy_builder.h"
 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
 #include "chrome/browser/chromeos/policy/display_rotation_default_handler.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/display.h"

 namespace em = enterprise_management;

 namespace {

 ash::DisplayManager* GetDisplayManager() {
   return ash::Shell::GetInstance()->display_manager();
 }

 gfx::Display::Rotation GetRotationOfFirstDisplay() {
   const ash::DisplayManager* const display_manager = GetDisplayManager();
   const int64_t first_display_id = display_manager->first_display_id();
   const gfx::Display& first_display =
       display_manager->GetDisplayForId(first_display_id);
   return first_display.rotation();
 }

 // Fails the test and returns ROTATE_0 if there is no second display.
 gfx::Display::Rotation GetRotationOfSecondDisplay() {
   const ash::DisplayManager* const display_manager = GetDisplayManager();
   if (display_manager->GetNumDisplays() < 2) {
     ADD_FAILURE()
         << "Requested rotation of second display while there was only one.";
     return gfx::Display::ROTATE_0;
   }
   const ash::DisplayIdPair display_id_pair =
       display_manager->GetCurrentDisplayIdPair();
   const gfx::Display& second_display =
       display_manager->GetDisplayForId(display_id_pair.second);
   return second_display.rotation();
 }

 } // anonymous namespace

 namespace policy {

 class DisplayRotationDefaultTest
     : public policy::DevicePolicyCrosBrowserTest,
       public testing::WithParamInterface<gfx::Display::Rotation> {
  public:
   DisplayRotationDefaultTest() {}

   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(chromeos::switches::kLoginManager);
     command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
   }

   void SetUpInProcessBrowserTestFixture() override {
     InstallOwnerKey();
     MarkAsEnterpriseOwned();
     DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
   }

   void TearDownOnMainThread() override {
     // If the login display is still showing, exit gracefully.
     if (chromeos::LoginDisplayHost::default_host()) {
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::Bind(&chrome::AttemptExit));
       content::RunMessageLoop();
     }
   }

  protected:
   void SetPolicy(int rotation) {
     em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
     proto.mutable_display_rotation_default()->set_display_rotation_default(
         static_cast<em::DisplayRotationDefaultProto::Rotation>(rotation));
     RefreshPolicyAndWaitUntilDeviceSettingsUpdated();
   }

   // This is needed to test that refreshing the settings without change to the
   // DisplayRotationDefault policy will not rotate the display again.
   void SetADifferentPolicy() {
     em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
     const bool clock24 = proto.use_24hour_clock().use_24hour_clock();
     proto.mutable_use_24hour_clock()->set_use_24hour_clock(!clock24);
     RefreshPolicyAndWaitUntilDeviceSettingsUpdated();
   }

   void UnsetPolicy() {
     em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
     proto.clear_display_rotation_default();
     RefreshPolicyAndWaitUntilDeviceSettingsUpdated();
   }

   // Creates second display if there is none yet, or removes it if there is one.
   void ToggleSecondDisplay() {
     GetDisplayManager()->AddRemoveDisplay();
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }

   void RefreshPolicyAndWaitUntilDeviceSettingsUpdated() {
     base::RunLoop run_loop;
     // For calls from SetPolicy().
     scoped_ptr<chromeos::CrosSettings::ObserverSubscription> observer =
         chromeos::CrosSettings::Get()->AddSettingsObserver(
             chromeos::kDisplayRotationDefault, run_loop.QuitClosure());
     // For calls from SetADifferentPolicy().
     scoped_ptr<chromeos::CrosSettings::ObserverSubscription> observer2 =
         chromeos::CrosSettings::Get()->AddSettingsObserver(
             chromeos::kSystemUse24HourClock, run_loop.QuitClosure());
     RefreshDevicePolicy();
     run_loop.Run();
   }

  private:
   DISALLOW_COPY_AND_ASSIGN(DisplayRotationDefaultTest);
 };

 // If gfx::Display::Rotation is ever modified and this test fails, there are
 // hardcoded enum-values in the following files that might need adjustment:
 // * this file: range check in this function, initializations, expected values,
 //              the list of parameters at the bottom of the file
 // * display_rotation_default_handler.cc: Range check in UpdateFromCrosSettings,
 //                                        initialization to ROTATE_0
 // * display_rotation_default_handler.h: initialization to ROTATE_0
 // * chrome/browser/chromeos/policy/proto/chrome_device_policy.proto:
 //       DisplayRotationDefaultProto::Rotation should match one to one
 IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, EnumsInSync) {
   const gfx::Display::Rotation rotation = GetParam();
   EXPECT_EQ(em::DisplayRotationDefaultProto::Rotation_ARRAYSIZE,
             gfx::Display::ROTATE_270 + 1)
       << "Enums gfx::Display::Rotation and "
       << "em::DisplayRotationDefaultProto::Rotation are not in sync.";
   EXPECT_TRUE(em::DisplayRotationDefaultProto::Rotation_IsValid(rotation))
       << rotation << " is invalid as rotation. All valid values lie in "
       << "the range from " << em::DisplayRotationDefaultProto::Rotation_MIN
       << " to " << em::DisplayRotationDefaultProto::Rotation_MAX << ".";
 }

 IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, FirstDisplay) {
   const gfx::Display::Rotation policy_rotation = GetParam();
   EXPECT_EQ(gfx::Display::ROTATE_0, GetRotationOfFirstDisplay())
       << "Initial primary rotation before policy";

   SetPolicy(policy_rotation);
   int settings_rotation;
   EXPECT_TRUE(chromeos::CrosSettings::Get()->GetInteger(
       chromeos::kDisplayRotationDefault, &settings_rotation));
   EXPECT_EQ(policy_rotation, settings_rotation)
       << "Value of CrosSettings after policy value changed";
   EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay())
       << "Rotation of primary display after policy";
 }

 IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, RefreshSecondDisplay) {
   const gfx::Display::Rotation policy_rotation = GetParam();
   ToggleSecondDisplay();
   EXPECT_EQ(gfx::Display::ROTATE_0, GetRotationOfSecondDisplay())
       << "Rotation of secondary display before policy";
   SetPolicy(policy_rotation);
   EXPECT_EQ(policy_rotation, GetRotationOfSecondDisplay())
       << "Rotation of already connected secondary display after policy";
 }

 IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, ConnectSecondDisplay) {
   const gfx::Display::Rotation policy_rotation = GetParam();
   SetPolicy(policy_rotation);
   ToggleSecondDisplay();
   EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay())
       << "Rotation of primary display after policy";
   EXPECT_EQ(policy_rotation, GetRotationOfSecondDisplay())
       << "Rotation of newly connected secondary display after policy";
 }

 IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, UserInteraction) {
   const gfx::Display::Rotation policy_rotation = GetParam();
   const gfx::Display::Rotation user_rotation = gfx::Display::ROTATE_90;
   GetDisplayManager()->SetDisplayRotation(
       GetDisplayManager()->first_display_id(), user_rotation,
       gfx::Display::ROTATION_SOURCE_USER);
   EXPECT_EQ(user_rotation, GetRotationOfFirstDisplay())
       << "Rotation of primary display after user change";
   SetPolicy(policy_rotation);
   EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay())
       << "Rotation of primary display after policy overrode user change";
   GetDisplayManager()->SetDisplayRotation(
       GetDisplayManager()->first_display_id(), user_rotation,
       gfx::Display::ROTATION_SOURCE_USER);
   EXPECT_EQ(user_rotation, GetRotationOfFirstDisplay())
       << "Rotation of primary display after user overrode policy change";
   SetADifferentPolicy();
   EXPECT_EQ(user_rotation, GetRotationOfFirstDisplay())
       << "Rotation of primary display after policy reloaded without change";
 }

 IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, SetAndUnsetPolicy) {
   const gfx::Display::Rotation policy_rotation = GetParam();
   SetPolicy(policy_rotation);
   UnsetPolicy();
   EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay())
       << "Rotation of primary display after policy was set and removed.";
 }

 IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest,
                        SetAndUnsetPolicyWithUserInteraction) {
   const gfx::Display::Rotation policy_rotation = GetParam();
   const gfx::Display::Rotation user_rotation = gfx::Display::ROTATE_90;
   SetPolicy(policy_rotation);
   GetDisplayManager()->SetDisplayRotation(
       GetDisplayManager()->first_display_id(), user_rotation,
       gfx::Display::ROTATION_SOURCE_USER);
   UnsetPolicy();
   EXPECT_EQ(user_rotation, GetRotationOfFirstDisplay())
       << "Rotation of primary display after policy was set to "
       << policy_rotation << ", user changed the rotation to " << user_rotation
       << ", and policy was removed.";
 }

 INSTANTIATE_TEST_CASE_P(PolicyDisplayRotationDefault,
                         DisplayRotationDefaultTest,
                         testing::Values(gfx::Display::ROTATE_0,
                                         gfx::Display::ROTATE_90,
                                         gfx::Display::ROTATE_180,
                                         gfx::Display::ROTATE_270));

 // This class tests that the policy is reapplied after a reboot. To persist from
 // PRE_Reboot to Reboot, the policy is inserted into a FakeSessionManagerClient.
 // From there, it travels to DeviceSettingsProvider, whose UpdateFromService()
 // method caches the policy (using device_settings_cache::Store()).
 // In the main test, the FakeSessionManagerClient is not fully initialized.
 // Thus, DeviceSettingsProvider falls back on the cached values (using
 // device_settings_cache::Retrieve()).
 class DisplayRotationBootTest
     : public InProcessBrowserTest,
       public testing::WithParamInterface<gfx::Display::Rotation> {
  protected:
   DisplayRotationBootTest()
       : fake_session_manager_client_(new chromeos::FakeSessionManagerClient) {}
   ~DisplayRotationBootTest() override {}

   void SetUpInProcessBrowserTestFixture() override {
     chromeos::DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
         scoped_ptr<chromeos::SessionManagerClient>(
             fake_session_manager_client_));
     chromeos::DBusThreadManager::GetSetterForTesting()->SetCryptohomeClient(
         scoped_ptr<chromeos::CryptohomeClient>(
             new chromeos::FakeCryptohomeClient));

     test_helper_.InstallOwnerKey();
     test_helper_.MarkAsEnterpriseOwned();
   }

   chromeos::FakeSessionManagerClient* fake_session_manager_client_;
   policy::DevicePolicyCrosTestHelper test_helper_;
 };

 IN_PROC_BROWSER_TEST_P(DisplayRotationBootTest, PRE_Reboot) {
   const gfx::Display::Rotation policy_rotation = GetParam();
   const gfx::Display::Rotation user_rotation = gfx::Display::ROTATE_180;

   // Set policy.
   policy::DevicePolicyBuilder* const device_policy(
       test_helper_.device_policy());
   em::ChromeDeviceSettingsProto& proto(device_policy->payload());
   proto.mutable_display_rotation_default()->set_display_rotation_default(
       static_cast<em::DisplayRotationDefaultProto::Rotation>(policy_rotation));
   base::RunLoop run_loop;
   scoped_ptr<chromeos::CrosSettings::ObserverSubscription> observer =
       chromeos::CrosSettings::Get()->AddSettingsObserver(
           chromeos::kDisplayRotationDefault, run_loop.QuitClosure());
   device_policy->SetDefaultSigningKey();
   device_policy->Build();
   fake_session_manager_client_->set_device_policy(device_policy->GetBlob());
   fake_session_manager_client_->OnPropertyChangeComplete(true);
   run_loop.Run();

   // Check the display's rotation.
   ash::DisplayManager* const display_manager = GetDisplayManager();
   const int64_t first_display_id = display_manager->first_display_id();
   const gfx::Display& first_display =
       display_manager->GetDisplayForId(first_display_id);
   EXPECT_EQ(policy_rotation, first_display.rotation());

   // Let the user rotate the display to a different orientation, to check that
   // the policy value is restored after reboot.
   display_manager->SetDisplayRotation(first_display_id, user_rotation,
                                       gfx::Display::ROTATION_SOURCE_USER);
   EXPECT_EQ(user_rotation, first_display.rotation());
 }

 IN_PROC_BROWSER_TEST_P(DisplayRotationBootTest, Reboot) {
   const gfx::Display::Rotation policy_rotation = GetParam();

   // Check that the policy rotation is restored.
   EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay());
 }

 INSTANTIATE_TEST_CASE_P(PolicyDisplayRotationDefault,
                         DisplayRotationBootTest,
                         testing::Values(gfx::Display::ROTATE_0,
                                         gfx::Display::ROTATE_90,
                                         gfx::Display::ROTATE_180,
                                         gfx::Display::ROTATE_270));

 }  // namespace policy
	// Copyright 2015 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 <stdint.h>

	#include "ash/display/display_manager.h"
	#include "ash/shell.h"
	#include "base/bind.h"
	#include "base/command_line.h"
	#include "base/location.h"
	#include "base/macros.h"
	#include "base/memory/scoped_ptr.h"
	#include "base/message_loop/message_loop.h"
	#include "base/run_loop.h"
	#include "chrome/browser/chromeos/login/ui/login_display_host.h"
	#include "chrome/browser/chromeos/policy/device_policy_builder.h"
	#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
	#include "chrome/browser/chromeos/policy/display_rotation_default_handler.h"
	#include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
	#include "chrome/browser/chromeos/settings/cros_settings.h"
	#include "chrome/browser/lifetime/application_lifetime.h"
	#include "chrome/test/base/in_process_browser_test.h"
	#include "chromeos/chromeos_switches.h"
	#include "chromeos/dbus/cryptohome_client.h"
	#include "chromeos/dbus/dbus_thread_manager.h"
	#include "chromeos/dbus/fake_cryptohome_client.h"
	#include "chromeos/dbus/fake_session_manager_client.h"
	#include "chromeos/dbus/session_manager_client.h"
	#include "chromeos/settings/cros_settings_names.h"
	#include "content/public/test/test_utils.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "ui/gfx/display.h"

	namespace em = enterprise_management;

	namespace {

	ash::DisplayManager* GetDisplayManager() {
	return ash::Shell::GetInstance()->display_manager();
	}

	gfx::Display::Rotation GetRotationOfFirstDisplay() {
	const ash::DisplayManager* const display_manager = GetDisplayManager();
	const int64_t first_display_id = display_manager->first_display_id();
	const gfx::Display& first_display =
	display_manager->GetDisplayForId(first_display_id);
	return first_display.rotation();
	}

	// Fails the test and returns ROTATE_0 if there is no second display.
	gfx::Display::Rotation GetRotationOfSecondDisplay() {
	const ash::DisplayManager* const display_manager = GetDisplayManager();
	if (display_manager->GetNumDisplays() < 2) {
	ADD_FAILURE()
	<< "Requested rotation of second display while there was only one.";
	return gfx::Display::ROTATE_0;
	}
	const ash::DisplayIdPair display_id_pair =
	display_manager->GetCurrentDisplayIdPair();
	const gfx::Display& second_display =
	display_manager->GetDisplayForId(display_id_pair.second);
	return second_display.rotation();
	}

	} // anonymous namespace

	namespace policy {

	class DisplayRotationDefaultTest
	: public policy::DevicePolicyCrosBrowserTest,
	public testing::WithParamInterface<gfx::Display::Rotation> {
	public:
	DisplayRotationDefaultTest() {}

	void SetUpCommandLine(base::CommandLine* command_line) override {
	command_line->AppendSwitch(chromeos::switches::kLoginManager);
	command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
	}

	void SetUpInProcessBrowserTestFixture() override {
	InstallOwnerKey();
	MarkAsEnterpriseOwned();
	DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
	}

	void TearDownOnMainThread() override {
	// If the login display is still showing, exit gracefully.
	if (chromeos::LoginDisplayHost::default_host()) {
	base::MessageLoop::current()->PostTask(FROM_HERE,
	base::Bind(&chrome::AttemptExit));
	content::RunMessageLoop();
	}
	}

	protected:
	void SetPolicy(int rotation) {
	em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
	proto.mutable_display_rotation_default()->set_display_rotation_default(
	static_cast<em::DisplayRotationDefaultProto::Rotation>(rotation));
	RefreshPolicyAndWaitUntilDeviceSettingsUpdated();
	}

	// This is needed to test that refreshing the settings without change to the
	// DisplayRotationDefault policy will not rotate the display again.
	void SetADifferentPolicy() {
	em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
	const bool clock24 = proto.use_24hour_clock().use_24hour_clock();
	proto.mutable_use_24hour_clock()->set_use_24hour_clock(!clock24);
	RefreshPolicyAndWaitUntilDeviceSettingsUpdated();
	}

	void UnsetPolicy() {
	em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
	proto.clear_display_rotation_default();
	RefreshPolicyAndWaitUntilDeviceSettingsUpdated();
	}

	// Creates second display if there is none yet, or removes it if there is one.
	void ToggleSecondDisplay() {
	GetDisplayManager()->AddRemoveDisplay();
	base::RunLoop run_loop;
	run_loop.RunUntilIdle();
	}

	void RefreshPolicyAndWaitUntilDeviceSettingsUpdated() {
	base::RunLoop run_loop;
	// For calls from SetPolicy().
	scoped_ptr<chromeos::CrosSettings::ObserverSubscription> observer =
	chromeos::CrosSettings::Get()->AddSettingsObserver(
	chromeos::kDisplayRotationDefault, run_loop.QuitClosure());
	// For calls from SetADifferentPolicy().
	scoped_ptr<chromeos::CrosSettings::ObserverSubscription> observer2 =
	chromeos::CrosSettings::Get()->AddSettingsObserver(
	chromeos::kSystemUse24HourClock, run_loop.QuitClosure());
	RefreshDevicePolicy();
	run_loop.Run();
	}

	private:
	DISALLOW_COPY_AND_ASSIGN(DisplayRotationDefaultTest);
	};

	// If gfx::Display::Rotation is ever modified and this test fails, there are
	// hardcoded enum-values in the following files that might need adjustment:
	// * this file: range check in this function, initializations, expected values,
	// the list of parameters at the bottom of the file
	// * display_rotation_default_handler.cc: Range check in UpdateFromCrosSettings,
	// initialization to ROTATE_0
	// * display_rotation_default_handler.h: initialization to ROTATE_0
	// * chrome/browser/chromeos/policy/proto/chrome_device_policy.proto:
	// DisplayRotationDefaultProto::Rotation should match one to one
	IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, EnumsInSync) {
	const gfx::Display::Rotation rotation = GetParam();
	EXPECT_EQ(em::DisplayRotationDefaultProto::Rotation_ARRAYSIZE,
	gfx::Display::ROTATE_270 + 1)
	<< "Enums gfx::Display::Rotation and "
	<< "em::DisplayRotationDefaultProto::Rotation are not in sync.";
	EXPECT_TRUE(em::DisplayRotationDefaultProto::Rotation_IsValid(rotation))
	<< rotation << " is invalid as rotation. All valid values lie in "
	<< "the range from " << em::DisplayRotationDefaultProto::Rotation_MIN
	<< " to " << em::DisplayRotationDefaultProto::Rotation_MAX << ".";
	}

	IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, FirstDisplay) {
	const gfx::Display::Rotation policy_rotation = GetParam();
	EXPECT_EQ(gfx::Display::ROTATE_0, GetRotationOfFirstDisplay())
	<< "Initial primary rotation before policy";

	SetPolicy(policy_rotation);
	int settings_rotation;
	EXPECT_TRUE(chromeos::CrosSettings::Get()->GetInteger(
	chromeos::kDisplayRotationDefault, &settings_rotation));
	EXPECT_EQ(policy_rotation, settings_rotation)
	<< "Value of CrosSettings after policy value changed";
	EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay())
	<< "Rotation of primary display after policy";
	}

	IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, RefreshSecondDisplay) {
	const gfx::Display::Rotation policy_rotation = GetParam();
	ToggleSecondDisplay();
	EXPECT_EQ(gfx::Display::ROTATE_0, GetRotationOfSecondDisplay())
	<< "Rotation of secondary display before policy";
	SetPolicy(policy_rotation);
	EXPECT_EQ(policy_rotation, GetRotationOfSecondDisplay())
	<< "Rotation of already connected secondary display after policy";
	}

	IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, ConnectSecondDisplay) {
	const gfx::Display::Rotation policy_rotation = GetParam();
	SetPolicy(policy_rotation);
	ToggleSecondDisplay();
	EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay())
	<< "Rotation of primary display after policy";
	EXPECT_EQ(policy_rotation, GetRotationOfSecondDisplay())
	<< "Rotation of newly connected secondary display after policy";
	}

	IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, UserInteraction) {
	const gfx::Display::Rotation policy_rotation = GetParam();
	const gfx::Display::Rotation user_rotation = gfx::Display::ROTATE_90;
	GetDisplayManager()->SetDisplayRotation(
	GetDisplayManager()->first_display_id(), user_rotation,
	gfx::Display::ROTATION_SOURCE_USER);
	EXPECT_EQ(user_rotation, GetRotationOfFirstDisplay())
	<< "Rotation of primary display after user change";
	SetPolicy(policy_rotation);
	EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay())
	<< "Rotation of primary display after policy overrode user change";
	GetDisplayManager()->SetDisplayRotation(
	GetDisplayManager()->first_display_id(), user_rotation,
	gfx::Display::ROTATION_SOURCE_USER);
	EXPECT_EQ(user_rotation, GetRotationOfFirstDisplay())
	<< "Rotation of primary display after user overrode policy change";
	SetADifferentPolicy();
	EXPECT_EQ(user_rotation, GetRotationOfFirstDisplay())
	<< "Rotation of primary display after policy reloaded without change";
	}

	IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest, SetAndUnsetPolicy) {
	const gfx::Display::Rotation policy_rotation = GetParam();
	SetPolicy(policy_rotation);
	UnsetPolicy();
	EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay())
	<< "Rotation of primary display after policy was set and removed.";
	}

	IN_PROC_BROWSER_TEST_P(DisplayRotationDefaultTest,
	SetAndUnsetPolicyWithUserInteraction) {
	const gfx::Display::Rotation policy_rotation = GetParam();
	const gfx::Display::Rotation user_rotation = gfx::Display::ROTATE_90;
	SetPolicy(policy_rotation);
	GetDisplayManager()->SetDisplayRotation(
	GetDisplayManager()->first_display_id(), user_rotation,
	gfx::Display::ROTATION_SOURCE_USER);
	UnsetPolicy();
	EXPECT_EQ(user_rotation, GetRotationOfFirstDisplay())
	<< "Rotation of primary display after policy was set to "
	<< policy_rotation << ", user changed the rotation to " << user_rotation
	<< ", and policy was removed.";
	}

	INSTANTIATE_TEST_CASE_P(PolicyDisplayRotationDefault,
	DisplayRotationDefaultTest,
	testing::Values(gfx::Display::ROTATE_0,
	gfx::Display::ROTATE_90,
	gfx::Display::ROTATE_180,
	gfx::Display::ROTATE_270));

	// This class tests that the policy is reapplied after a reboot. To persist from
	// PRE_Reboot to Reboot, the policy is inserted into a FakeSessionManagerClient.
	// From there, it travels to DeviceSettingsProvider, whose UpdateFromService()
	// method caches the policy (using device_settings_cache::Store()).
	// In the main test, the FakeSessionManagerClient is not fully initialized.
	// Thus, DeviceSettingsProvider falls back on the cached values (using
	// device_settings_cache::Retrieve()).
	class DisplayRotationBootTest
	: public InProcessBrowserTest,
	public testing::WithParamInterface<gfx::Display::Rotation> {
	protected:
	DisplayRotationBootTest()
	: fake_session_manager_client_(new chromeos::FakeSessionManagerClient) {}
	~DisplayRotationBootTest() override {}

	void SetUpInProcessBrowserTestFixture() override {
	chromeos::DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
	scoped_ptr<chromeos::SessionManagerClient>(
	fake_session_manager_client_));
	chromeos::DBusThreadManager::GetSetterForTesting()->SetCryptohomeClient(
	scoped_ptr<chromeos::CryptohomeClient>(
	new chromeos::FakeCryptohomeClient));

	test_helper_.InstallOwnerKey();
	test_helper_.MarkAsEnterpriseOwned();
	}

	chromeos::FakeSessionManagerClient* fake_session_manager_client_;
	policy::DevicePolicyCrosTestHelper test_helper_;
	};

	IN_PROC_BROWSER_TEST_P(DisplayRotationBootTest, PRE_Reboot) {
	const gfx::Display::Rotation policy_rotation = GetParam();
	const gfx::Display::Rotation user_rotation = gfx::Display::ROTATE_180;

	// Set policy.
	policy::DevicePolicyBuilder* const device_policy(
	test_helper_.device_policy());
	em::ChromeDeviceSettingsProto& proto(device_policy->payload());
	proto.mutable_display_rotation_default()->set_display_rotation_default(
	static_cast<em::DisplayRotationDefaultProto::Rotation>(policy_rotation));
	base::RunLoop run_loop;
	scoped_ptr<chromeos::CrosSettings::ObserverSubscription> observer =
	chromeos::CrosSettings::Get()->AddSettingsObserver(
	chromeos::kDisplayRotationDefault, run_loop.QuitClosure());
	device_policy->SetDefaultSigningKey();
	device_policy->Build();
	fake_session_manager_client_->set_device_policy(device_policy->GetBlob());
	fake_session_manager_client_->OnPropertyChangeComplete(true);
	run_loop.Run();

	// Check the display's rotation.
	ash::DisplayManager* const display_manager = GetDisplayManager();
	const int64_t first_display_id = display_manager->first_display_id();
	const gfx::Display& first_display =
	display_manager->GetDisplayForId(first_display_id);
	EXPECT_EQ(policy_rotation, first_display.rotation());

	// Let the user rotate the display to a different orientation, to check that
	// the policy value is restored after reboot.
	display_manager->SetDisplayRotation(first_display_id, user_rotation,
	gfx::Display::ROTATION_SOURCE_USER);
	EXPECT_EQ(user_rotation, first_display.rotation());
	}

	IN_PROC_BROWSER_TEST_P(DisplayRotationBootTest, Reboot) {
	const gfx::Display::Rotation policy_rotation = GetParam();

	// Check that the policy rotation is restored.
	EXPECT_EQ(policy_rotation, GetRotationOfFirstDisplay());
	}

	INSTANTIATE_TEST_CASE_P(PolicyDisplayRotationDefault,
	DisplayRotationBootTest,
	testing::Values(gfx::Display::ROTATE_0,
	gfx::Display::ROTATE_90,
	gfx::Display::ROTATE_180,
	gfx::Display::ROTATE_270));

	} // namespace policy