User orientation lock

ash/content/display/screen_orientation_controller_chromeos_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/display/screen_orientation_controller_chromeos.h"
 
 #include <memory>
 #include <vector>
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/test/test_system_tray_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
+#include "ash/common/wm/window_state.h"
 #include "ash/common/wm_shell.h"
+#include "ash/common/wm_window.h"
 #include "ash/content/shell_content_state.h"
+#include "ash/display/screen_orientation_controller_chromeos.h"
+#include "ash/shared/app_types.h"
 #include "ash/shell.h"
 #include "ash/system/chromeos/screen_layout_observer.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/ash_test_environment_content.h"
 #include "ash/test/ash_test_helper.h"
 #include "ash/test/content/test_shell_content_state.h"
+#include "ash/test/screen_orientation_controller_test_api.h"
 #include "ash/test/test_shell_delegate.h"
 #include "base/command_line.h"
 #include "chromeos/accelerometer/accelerometer_reader.h"
 #include "chromeos/accelerometer/accelerometer_types.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_context.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebScreenOrientationLockType.h"
 #include "ui/aura/window.h"
 #include "ui/display/display.h"
@@ skipping 25 matching lines @@
   WmShell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
       enable);
 }
 
 bool RotationLocked() {
   return Shell::GetInstance()
       ->screen_orientation_controller()
       ->rotation_locked();
 }
 
+bool UserRotationLocked() {
+  return Shell::GetInstance()
+      ->screen_orientation_controller()
+      ->user_rotation_locked();
+}
+
 void SetDisplayRotationById(int64_t display_id,
                             display::Display::Rotation rotation) {
   Shell::GetInstance()->display_manager()->SetDisplayRotation(
       display_id, rotation, display::Display::ROTATION_SOURCE_USER);
 }
 
 void SetInternalDisplayRotation(display::Display::Rotation rotation) {
   SetDisplayRotationById(display::Display::InternalDisplayId(), rotation);
 }
 
-void SetRotationLocked(bool rotation_locked) {
-  Shell::GetInstance()->screen_orientation_controller()->SetRotationLocked(
-      rotation_locked);
-}
-
 void TriggerLidUpdate(const gfx::Vector3dF& lid) {
   scoped_refptr<chromeos::AccelerometerUpdate> update(
       new chromeos::AccelerometerUpdate());
   update->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, lid.x(), lid.y(), lid.z());
   Shell::GetInstance()->screen_orientation_controller()->OnAccelerometerUpdated(
       update);
 }
 
 // Attaches the NativeView of |web_contents| to |parent| without changing the
 // currently active window.
@@ skipping 31 matching lines @@
   // content::BrowserContext and that has an aura::Window.
   content::WebContents* CreateWebContents();
 
   // Creates a secondary content::WebContents, with a separate
   // content::BrowserContext.
   content::WebContents* CreateSecondaryWebContents();
 
   // test::AshTestBase:
   void SetUp() override;
 
+ protected:
+  aura::Window* CreateAppWindowInShellWithId(int id) {
+    aura::Window* window = CreateTestWindowInShellWithId(id);
+    WmWindow::Get(window)->SetAppType(static_cast<int>(AppType::CHROME_APP));
+    return window;
+  }
+
+  void SetSystemRotationLocked(bool rotation_locked) {
+    test::ScreenOrientationControllerTestApi(
+        Shell::GetInstance()->screen_orientation_controller())
+        .SetRotationLocked(rotation_locked);
+  }
+
+  void SetUserRotationLocked(bool rotation_locked) {
+    if (Shell::GetInstance()
+            ->screen_orientation_controller()
+            ->user_rotation_locked() != rotation_locked) {
+      Shell::GetInstance()
+          ->screen_orientation_controller()
+          ->ToggleUserRotationLock();
+    }
+  }
+
+  blink::WebScreenOrientationLockType UserLockedOrientation() const {
+    test::ScreenOrientationControllerTestApi test_api(
+        Shell::GetInstance()->screen_orientation_controller());
+    return test_api.UserLockedOrientation();
+  }
+
  private:
   // Optional content::BrowserContext used for two window tests.
   std::unique_ptr<content::BrowserContext> secondary_browser_context_;
 
   // Setups underlying content layer so that content::WebContents can be
   // generated.
   std::unique_ptr<views::WebViewTestHelper> webview_test_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenOrientationControllerTest);
 };
@@ skipping 18 matching lines @@
 
 void ScreenOrientationControllerTest::SetUp() {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       ::switches::kUseFirstDisplayAsInternal);
   test::AshTestBase::SetUp();
 }
 
 // Tests that a content::WebContents can lock rotation.
 TEST_F(ScreenOrientationControllerTest, LockOrientation) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window(CreateAppWindowInShellWithId(0));
   ASSERT_NE(nullptr, content->GetNativeView());
   ASSERT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   ASSERT_FALSE(RotationLocked());
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 }
 
 // Tests that a content::WebContents can unlock rotation.
 TEST_F(ScreenOrientationControllerTest, Unlock) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window(CreateAppWindowInShellWithId(0));
   ASSERT_NE(nullptr, content->GetNativeView());
   ASSERT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   ASSERT_FALSE(RotationLocked());
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   delegate()->Unlock(content.get());
   EXPECT_FALSE(RotationLocked());
 }
 
 // Tests that a content::WebContents is able to change the orientation of the
 // display after having locked rotation.
 TEST_F(ScreenOrientationControllerTest, OrientationChanges) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window(CreateAppWindowInShellWithId(0));
   ASSERT_NE(nullptr, content->GetNativeView());
   ASSERT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   ASSERT_FALSE(RotationLocked());
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockPortrait);
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that orientation can only be set by the first content::WebContents that
 // has set a rotation lock.
 TEST_F(ScreenOrientationControllerTest, SecondContentCannotChangeOrientation) {
   std::unique_ptr<content::WebContents> content1(CreateWebContents());
   std::unique_ptr<content::WebContents> content2(CreateSecondaryWebContents());
-  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<aura::Window> focus_window1(CreateAppWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateAppWindowInShellWithId(1));
   ASSERT_NE(content1->GetNativeView(), content2->GetNativeView());
 
   AttachAndActivateWebContents(content1.get(), focus_window1.get());
   AttachWebContents(content2.get(), focus_window2.get());
   delegate()->Lock(content1.get(), blink::WebScreenOrientationLockLandscape);
   delegate()->Lock(content2.get(), blink::WebScreenOrientationLockPortrait);
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that only the content::WebContents that set a rotation lock can perform
 // an unlock.
 TEST_F(ScreenOrientationControllerTest, SecondContentCannotUnlock) {
   std::unique_ptr<content::WebContents> content1(CreateWebContents());
   std::unique_ptr<content::WebContents> content2(CreateSecondaryWebContents());
-  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<aura::Window> focus_window1(CreateAppWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateAppWindowInShellWithId(1));
   ASSERT_NE(content1->GetNativeView(), content2->GetNativeView());
 
   AttachAndActivateWebContents(content1.get(), focus_window1.get());
   AttachWebContents(content2.get(), focus_window2.get());
   delegate()->Lock(content1.get(), blink::WebScreenOrientationLockLandscape);
   delegate()->Unlock(content2.get());
   EXPECT_TRUE(RotationLocked());
 }
 
 // Tests that a rotation lock is applied only while the content::WebContents are
 // a part of the active window.
 TEST_F(ScreenOrientationControllerTest, ActiveWindowChangesUpdateLock) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<aura::Window> focus_window1(CreateAppWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateAppWindowInShellWithId(1));
 
   AttachAndActivateWebContents(content.get(), focus_window1.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   ASSERT_TRUE(RotationLocked());
 
   aura::client::ActivationClient* activation_client =
       Shell::GetInstance()->activation_client();
   activation_client->ActivateWindow(focus_window2.get());
   EXPECT_FALSE(RotationLocked());
 
   activation_client->ActivateWindow(focus_window1.get());
   EXPECT_TRUE(RotationLocked());
 }
 
 // Tests that switching between windows with different orientation locks change
 // the orientation.
 TEST_F(ScreenOrientationControllerTest, ActiveWindowChangesUpdateOrientation) {
   std::unique_ptr<content::WebContents> content1(CreateWebContents());
   std::unique_ptr<content::WebContents> content2(CreateSecondaryWebContents());
-  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<aura::Window> focus_window1(CreateAppWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateAppWindowInShellWithId(1));
   AttachAndActivateWebContents(content1.get(), focus_window1.get());
   AttachWebContents(content2.get(), focus_window2.get());
 
   delegate()->Lock(content1.get(), blink::WebScreenOrientationLockLandscape);
   delegate()->Lock(content2.get(), blink::WebScreenOrientationLockPortrait);
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 
   aura::client::ActivationClient* activation_client =
       Shell::GetInstance()->activation_client();
   activation_client->ActivateWindow(focus_window2.get());
   EXPECT_TRUE(RotationLocked());
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
 
   activation_client->ActivateWindow(focus_window1.get());
   EXPECT_TRUE(RotationLocked());
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that a rotation lock is removed when the setting window is hidden, and
 // that it is reapplied when the window becomes visible.
 TEST_F(ScreenOrientationControllerTest, VisibilityChangesLock) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window(CreateAppWindowInShellWithId(0));
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_TRUE(RotationLocked());
 
   aura::Window* window = content->GetNativeView();
   window->Hide();
   EXPECT_FALSE(RotationLocked());
 
   window->Show();
   EXPECT_TRUE(RotationLocked());
 }
 
 // Tests that when a window is destroyed that its rotation lock is removed, and
 // window activations no longer change the lock
 TEST_F(ScreenOrientationControllerTest, WindowDestructionRemovesLock) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<aura::Window> focus_window1(CreateAppWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateAppWindowInShellWithId(1));
 
   AttachAndActivateWebContents(content.get(), focus_window1.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   ASSERT_TRUE(RotationLocked());
 
   focus_window1->RemoveChild(content->GetNativeView());
   content.reset();
   EXPECT_FALSE(RotationLocked());
 
   aura::client::ActivationClient* activation_client =
@@ skipping 65 matching lines @@
   gravity.set_x(-sin(degrees * kDegreesToRadians) * kMeanGravity);
   gravity.set_y(-cos(degrees * kDegreesToRadians) * kMeanGravity);
   TriggerLidUpdate(gravity);
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that the display will stick to its current orientation when the
 // rotation lock has been set.
 TEST_F(ScreenOrientationControllerTest, RotationLockPreventsRotation) {
   EnableMaximizeMode(true);
-  SetRotationLocked(true);
+  SetUserRotationLocked(true);
 
   // Turn past the threshold for rotation.
   float degrees = 90.0;
   gfx::Vector3dF gravity(-sin(degrees * kDegreesToRadians) * kMeanGravity,
                          -cos(degrees * kDegreesToRadians) * kMeanGravity,
                          0.0f);
   TriggerLidUpdate(gravity);
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 
-  SetRotationLocked(false);
+  SetUserRotationLocked(false);
   TriggerLidUpdate(gravity);
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
 }
 
 // The ScreenLayoutObserver class that is responsible for adding/updating
 // MessageCenter notifications is only added to the SystemTray on ChromeOS.
 // Tests that the screen rotation notifications are suppressed when
 // triggered by the accelerometer.
 TEST_F(ScreenOrientationControllerTest, BlockRotationNotifications) {
   EnableMaximizeMode(true);
   Shell::GetInstance()
       ->screen_layout_observer()
       ->set_show_notifications_for_testing(true);
   display::test::DisplayManagerTestApi(display_manager())
       .SetFirstDisplayAsInternalDisplay();
 
   message_center::MessageCenter* message_center =
       message_center::MessageCenter::Get();
 
   EXPECT_EQ(0u, message_center->NotificationCount());
   EXPECT_FALSE(message_center->HasPopupNotifications());
 
   // Make sure notifications are still displayed when
   // adjusting the screen rotation directly when in maximize mode
   ASSERT_NE(display::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
   SetInternalDisplayRotation(display::Display::ROTATE_270);
-  SetRotationLocked(false);
+  SetSystemRotationLocked(false);
   EXPECT_EQ(display::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
   EXPECT_EQ(1u, message_center->NotificationCount());
   EXPECT_TRUE(message_center->HasPopupNotifications());
 
   // Clear all notifications
   message_center->RemoveAllNotifications(
       false /* by_user */, message_center::MessageCenter::RemoveType::ALL);
   EXPECT_EQ(0u, message_center->NotificationCount());
   EXPECT_FALSE(message_center->HasPopupNotifications());
 
   // Make sure notifications are blocked when adjusting the screen rotation
   // via the accelerometer while in maximize mode
   // Rotate the screen 90 degrees
-  ASSERT_NE(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
+  ASSERT_EQ(display::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(-kMeanGravity, 0.0f, 0.0f));
   ASSERT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   EXPECT_EQ(0u, message_center->NotificationCount());
   EXPECT_FALSE(message_center->HasPopupNotifications());
 
   // Make sure notifications are still displayed when
   // adjusting the screen rotation directly when not in maximize mode
   EnableMaximizeMode(false);
   // Reset the screen rotation.
   SetInternalDisplayRotation(display::Display::ROTATE_0);
@@ skipping 45 matching lines @@
   // maximize mode was activated.
   SetInternalDisplayRotation(display::Display::ROTATE_0);
   EnableMaximizeMode(false);
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that when the orientation lock is set to Landscape, that rotation can
 // be done between the two angles of the orientation.
 TEST_F(ScreenOrientationControllerTest, LandscapeOrientationAllowsRotation) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window(CreateAppWindowInShellWithId(0));
   EnableMaximizeMode(true);
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   // Inverse of orientation is allowed
   TriggerLidUpdate(gfx::Vector3dF(0.0f, kMeanGravity, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_180, GetCurrentInternalDisplayRotation());
 
   // Display rotations between are not allowed
   TriggerLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_180, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(-kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_180, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that when the orientation lock is set to Portrait, that rotaiton can be
 // done between the two angles of the orientation.
 TEST_F(ScreenOrientationControllerTest, PortraitOrientationAllowsRotation) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window(CreateAppWindowInShellWithId(0));
   EnableMaximizeMode(true);
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockPortrait);
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   // Inverse of orientation is allowed
   TriggerLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
 
   // Display rotations between are not allowed
   TriggerLidUpdate(gfx::Vector3dF(0.0f, kMeanGravity, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(0.0f, -kMeanGravity, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that for an orientation lock which does not allow rotation, that the
 // display rotation remains constant.
 TEST_F(ScreenOrientationControllerTest, OrientationLockDisallowsRotation) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window(CreateAppWindowInShellWithId(0));
   EnableMaximizeMode(true);
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(),
                    blink::WebScreenOrientationLockPortraitPrimary);
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   // Rotation does not change.
   TriggerLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(0.0f, kMeanGravity, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(0.0f, -kMeanGravity, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that after a content::WebContents has applied an orientation lock which
 // supports rotation, that a user rotation lock does not allow rotation.
 TEST_F(ScreenOrientationControllerTest, UserRotationLockDisallowsRotation) {
   std::unique_ptr<content::WebContents> content(CreateWebContents());
-  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window(CreateAppWindowInShellWithId(0));
   EnableMaximizeMode(true);
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   delegate()->Unlock(content.get());
 
-  SetRotationLocked(true);
+  SetUserRotationLocked(true);
   EXPECT_TRUE(RotationLocked());
+  EXPECT_TRUE(UserRotationLocked());
+
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
-
   TriggerLidUpdate(gfx::Vector3dF(0.0f, kMeanGravity, 0.0f));
   EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that when MaximizeMode is triggered before the internal display is
 // ready, that ScreenOrientationController still begins listening to events,
 // which require an internal display to be acted upon.
 TEST_F(ScreenOrientationControllerTest, InternalDisplayNotAvailableAtStartup) {
   display::test::DisplayManagerTestApi(display_manager())
       .SetFirstDisplayAsInternalDisplay();
@@ skipping 41 matching lines @@
   // |internal_display_info| as inactive instead of non-existent.
   display_manager()->UpdateDisplaysWith(display_info_list_two_active);
   display_manager()->UpdateDisplaysWith(display_info_list_one_active);
 
   display::test::ScopedSetInternalDisplayId set_internal(display_manager(),
                                                          kInternalDisplayId);
 
   ASSERT_NE(kNewRotation, display_manager()
                               ->GetDisplayInfo(kInternalDisplayId)
                               .GetActiveRotation());
-
-  Shell::GetInstance()->screen_orientation_controller()->SetDisplayRotation(
-      kNewRotation, display::Display::ROTATION_SOURCE_ACTIVE);
+  test::ScreenOrientationControllerTestApi(
+      Shell::GetInstance()->screen_orientation_controller())
+      .SetDisplayRotation(kNewRotation,
+                          display::Display::ROTATION_SOURCE_ACTIVE);
 
   EXPECT_EQ(kNewRotation, display_manager()
                               ->GetDisplayInfo(kInternalDisplayId)
                               .GetActiveRotation());
 }
 
+TEST_F(ScreenOrientationControllerTest, UserRotationLockedOrientation) {
+  ScreenOrientationController* orientation_controller =
+      Shell::GetInstance()->screen_orientation_controller();
+  orientation_controller->ToggleUserRotationLock();
+  EXPECT_TRUE(orientation_controller->user_rotation_locked());
+  EXPECT_EQ(blink::WebScreenOrientationLockLandscapePrimary,
+            UserLockedOrientation());
+
+  orientation_controller->ToggleUserRotationLock();
+  SetInternalDisplayRotation(display::Display::ROTATE_90);
+  orientation_controller->ToggleUserRotationLock();
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitPrimary,
+            UserLockedOrientation());
+
+  orientation_controller->ToggleUserRotationLock();
+  SetInternalDisplayRotation(display::Display::ROTATE_180);
+  orientation_controller->ToggleUserRotationLock();
+  EXPECT_EQ(blink::WebScreenOrientationLockLandscapeSecondary,
+            UserLockedOrientation());
+
+  orientation_controller->ToggleUserRotationLock();
+  SetInternalDisplayRotation(display::Display::ROTATE_270);
+  orientation_controller->ToggleUserRotationLock();
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitSecondary,
+            UserLockedOrientation());
+  orientation_controller->ToggleUserRotationLock();
+
+  SetInternalDisplayRotation(display::Display::ROTATE_270);
+
+  UpdateDisplay("800x1280");
+  orientation_controller->ToggleUserRotationLock();
+  EXPECT_TRUE(orientation_controller->user_rotation_locked());
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitPrimary,
+            UserLockedOrientation());
+
+  orientation_controller->ToggleUserRotationLock();
+  SetInternalDisplayRotation(display::Display::ROTATE_90);
+  orientation_controller->ToggleUserRotationLock();
+  EXPECT_EQ(blink::WebScreenOrientationLockLandscapePrimary,
+            UserLockedOrientation());
+
+  orientation_controller->ToggleUserRotationLock();
+  SetInternalDisplayRotation(display::Display::ROTATE_180);
+  orientation_controller->ToggleUserRotationLock();
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitSecondary,
+            UserLockedOrientation());
+
+  orientation_controller->ToggleUserRotationLock();
+  SetInternalDisplayRotation(display::Display::ROTATE_270);
+  orientation_controller->ToggleUserRotationLock();
+  EXPECT_EQ(blink::WebScreenOrientationLockLandscapeSecondary,
+            UserLockedOrientation());
+  orientation_controller->ToggleUserRotationLock();
+}
+
+TEST_F(ScreenOrientationControllerTest, UserRotationLock) {
+  std::unique_ptr<content::WebContents> content1(CreateWebContents());
+  std::unique_ptr<content::WebContents> content2(CreateSecondaryWebContents());
+  std::unique_ptr<aura::Window> focus_window1(CreateAppWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateAppWindowInShellWithId(1));
+  ASSERT_NE(content1->GetNativeView(), content2->GetNativeView());
+
+  AttachAndActivateWebContents(content2.get(), focus_window2.get());
+  AttachAndActivateWebContents(content1.get(), focus_window1.get());
+
+  ASSERT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
+  ASSERT_FALSE(RotationLocked());
+  ASSERT_FALSE(UserRotationLocked());
+
+  ScreenOrientationController* orientation_controller =
+      Shell::GetInstance()->screen_orientation_controller();
+  ASSERT_FALSE(orientation_controller->user_rotation_locked());
+  orientation_controller->ToggleUserRotationLock();
+  ASSERT_TRUE(orientation_controller->user_rotation_locked());
+
+  delegate()->Lock(content1.get(), blink::WebScreenOrientationLockPortrait);
+
+  EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
+
+  aura::client::ActivationClient* activation_client =
+      Shell::GetInstance()->activation_client();
+  // Activating any will switch to the natural orientation.
+  activation_client->ActivateWindow(focus_window2.get());
+  EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
+
+  // Activating the portrait window will rotate to the portrait.
+  activation_client->ActivateWindow(focus_window1.get());
+  EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
+
+  // User locked to the 90 dig.
+  orientation_controller->ToggleUserRotationLock();
+  orientation_controller->ToggleUserRotationLock();
+
+  // Switching to Any orientation will stay to the user locked orientation.
+  activation_client->ActivateWindow(focus_window2.get());
+  EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
+
+  // Application forced to be landscape.
+  delegate()->Lock(content2.get(), blink::WebScreenOrientationLockLandscape);
+  EXPECT_EQ(display::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
+
+  delegate()->Lock(content1.get(), blink::WebScreenOrientationLockAny);
+  activation_client->ActivateWindow(focus_window1.get());
+  // Switching back to any will rotate to user rotation.
+  EXPECT_EQ(display::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
+}
+
 }  // namespace ash