Resolve current orientation after applying the previous orientation request.

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 "ui/display/manager/display_manager.h"
 
 #include "ash/accelerators/accelerator_commands_aura.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_window.h"
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_util.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shared/app_types.h"
 #include "ash/shell.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/mirror_window_test_api.h"
+#include "ash/test/screen_orientation_controller_test_api.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "chromeos/accelerometer/accelerometer_reader.h"
 #include "chromeos/accelerometer/accelerometer_types.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 2896 matching lines @@
   layout_store->RegisterLayoutForDisplayIdList(list, std::move(old_layout));
   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);
 }
 
 namespace {
 
+class DisplayManagerOrientationTest : public DisplayManagerTest {
+ public:
+  DisplayManagerOrientationTest() {}
+  ~DisplayManagerOrientationTest() override {}
+
+  void SetUp() override {
+    DisplayManagerTest::SetUp();
+    const float kMeanGravity = 9.8066f;
+    portrait_primary->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, kMeanGravity,
+                          0.f, 0.f);
+    portrait_secondary->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN,
+                            -kMeanGravity, 0.f, 0.f);
+  }
+
+ protected:
+  scoped_refptr<chromeos::AccelerometerUpdate> portrait_primary =
+      new chromeos::AccelerometerUpdate();
+  scoped_refptr<chromeos::AccelerometerUpdate> portrait_secondary =
+      new chromeos::AccelerometerUpdate();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DisplayManagerOrientationTest);
+};
+
 class TestObserver : public ScreenOrientationController::Observer {
  public:
   TestObserver() {}
   ~TestObserver() override{};
 
   void OnUserRotationLockChanged() override { count_++; }
 
   int countAndReset() {
     int tmp = count_;
     count_ = 0;
     return tmp;
   }
 
  private:
   int count_ = 0;
 };
 
 }  // namespace
 
-TEST_F(DisplayManagerTest, SaveRestoreUserRotationLock) {
+TEST_F(DisplayManagerOrientationTest, SaveRestoreUserRotationLock) {
   Shell* shell = Shell::Get();
   display::DisplayManager* display_manager = shell->display_manager();
-  display::test::DisplayManagerTestApi test_api(display_manager);
-  test_api.SetFirstDisplayAsInternalDisplay();
+  display::test::DisplayManagerTestApi(display_manager)
+      .SetFirstDisplayAsInternalDisplay();
   ScreenOrientationController* orientation_controller =
       shell->screen_orientation_controller();
+  test::ScreenOrientationControllerTestApi test_api(orientation_controller);
   TestObserver test_observer;
   orientation_controller->AddObserver(&test_observer);
 
   // Set up windows with portrait,lanscape and any.
   aura::Window* window_a = CreateTestWindowInShellWithId(0);
   {
     WmWindow* wm_window_a = WmWindow::Get(window_a);
     wm_window_a->SetAppType(static_cast<int>(AppType::CHROME_APP));
     orientation_controller->LockOrientationForWindow(
-        wm_window_a, blink::WebScreenOrientationLockAny);
+        wm_window_a, blink::WebScreenOrientationLockAny,
+        ScreenOrientationController::LockCompletionBehavior::None);
   }
   aura::Window* window_p = CreateTestWindowInShellWithId(0);
   {
     WmWindow* wm_window_p = WmWindow::Get(window_p);
     wm_window_p->SetAppType(static_cast<int>(AppType::CHROME_APP));
     orientation_controller->LockOrientationForWindow(
-        wm_window_p, blink::WebScreenOrientationLockPortrait);
+        wm_window_p, blink::WebScreenOrientationLockPortrait,
+        ScreenOrientationController::LockCompletionBehavior::None);
   }
   aura::Window* window_l = CreateTestWindowInShellWithId(0);
   {
     WmWindow* wm_window_l = WmWindow::Get(window_l);
     wm_window_l->SetAppType(static_cast<int>(AppType::CHROME_APP));
     orientation_controller->LockOrientationForWindow(
-        wm_window_l, blink::WebScreenOrientationLockLandscape);
+        wm_window_l, blink::WebScreenOrientationLockLandscape,
+        ScreenOrientationController::LockCompletionBehavior::None);
   }
 
   DisplayConfigurationController* configuration_controller =
       shell->display_configuration_controller();
   display::Screen* screen = display::Screen::GetScreen();
 
   // Rotate to portrait in clamshell.
   configuration_controller->SetDisplayRotation(
       screen->GetPrimaryDisplay().id(), display::Display::ROTATE_90,
       display::Display::ROTATION_SOURCE_USER);
   EXPECT_EQ(display::Display::ROTATE_90,
             screen->GetPrimaryDisplay().rotation());
   EXPECT_FALSE(display_manager->registered_internal_display_rotation_lock());
 
   EXPECT_EQ(0, test_observer.countAndReset());
   // Just enabling will not save the lock.
   Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
       true);
   EXPECT_EQ(1, test_observer.countAndReset());
 
   EXPECT_EQ(display::Display::ROTATE_0, screen->GetPrimaryDisplay().rotation());
   EXPECT_FALSE(display_manager->registered_internal_display_rotation_lock());
+  EXPECT_EQ(blink::WebScreenOrientationLockLandscapePrimary,
+            test_api.GetCurrentOrientation());
 
   // Enable lock at 0.
   orientation_controller->ToggleUserRotationLock();
   EXPECT_EQ(1, test_observer.countAndReset());
 
   EXPECT_TRUE(display_manager->registered_internal_display_rotation_lock());
   EXPECT_EQ(display::Display::ROTATE_0,
             display_manager->registered_internal_display_rotation());
 
   // Application can overwwrite the locked orientation.
   wm::ActivateWindow(window_p);
   EXPECT_EQ(display::Display::ROTATE_90,
             screen->GetPrimaryDisplay().rotation());
   EXPECT_EQ(display::Display::ROTATE_0,
             display_manager->registered_internal_display_rotation());
   EXPECT_EQ(0, test_observer.countAndReset());
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitPrimary,
+            test_api.GetCurrentOrientation());
 
   // Any will rotate to the locked rotation.
   wm::ActivateWindow(window_a);
   EXPECT_EQ(display::Display::ROTATE_0, screen->GetPrimaryDisplay().rotation());
   EXPECT_TRUE(display_manager->registered_internal_display_rotation_lock());
   EXPECT_EQ(display::Display::ROTATE_0,
             display_manager->registered_internal_display_rotation());
   EXPECT_EQ(0, test_observer.countAndReset());
 
   wm::ActivateWindow(window_l);
@@ skipping 35 matching lines @@
             display_manager->registered_internal_display_rotation());
 
   // ANY will rotate to locked ortation.
   wm::ActivateWindow(window_a);
   EXPECT_EQ(display::Display::ROTATE_90,
             screen->GetPrimaryDisplay().rotation());
 
   orientation_controller->RemoveObserver(&test_observer);
 }
 
-TEST_F(DisplayManagerTest, UserRotationLockReverse) {
+TEST_F(DisplayManagerOrientationTest, UserRotationLockReverse) {
   Shell* shell = Shell::Get();
   display::DisplayManager* display_manager = shell->display_manager();
   display::test::DisplayManagerTestApi test_api(display_manager);
   test_api.SetFirstDisplayAsInternalDisplay();
   ScreenOrientationController* orientation_controller =
       shell->screen_orientation_controller();
 
   // Set up windows with portrait,lanscape and any.
   aura::Window* window = CreateTestWindowInShellWithId(0);
   WmWindow* wm_window = WmWindow::Get(window);
   wm_window->SetAppType(static_cast<int>(AppType::CHROME_APP));
   display::Screen* screen = display::Screen::GetScreen();
 
   // Just enabling will not save the lock.
   Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
       true);
 
   orientation_controller->LockOrientationForWindow(
-      wm_window, blink::WebScreenOrientationLockPortrait);
+      wm_window, blink::WebScreenOrientationLockPortrait,
+      ScreenOrientationController::LockCompletionBehavior::None);
   EXPECT_EQ(display::Display::ROTATE_90,
             screen->GetPrimaryDisplay().rotation());
 
-  const float kMeanGravity = -9.8066f;
-
-  scoped_refptr<chromeos::AccelerometerUpdate> reverse_portrait(
-      new chromeos::AccelerometerUpdate());
-  reverse_portrait->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, kMeanGravity,
-                        0.f, 0.f);
-  orientation_controller->OnAccelerometerUpdated(reverse_portrait);
+  orientation_controller->OnAccelerometerUpdated(portrait_secondary);
 
   EXPECT_EQ(display::Display::ROTATE_270,
             screen->GetPrimaryDisplay().rotation());
 
-  scoped_refptr<chromeos::AccelerometerUpdate> portrait(
-      new chromeos::AccelerometerUpdate());
-  portrait->Set(chromeos::ACCELEROMETER_SOURCE_SCREEN, -kMeanGravity, 0.f, 0.f);
-  orientation_controller->OnAccelerometerUpdated(portrait);
+  orientation_controller->OnAccelerometerUpdated(portrait_primary);
   EXPECT_EQ(display::Display::ROTATE_90,
             screen->GetPrimaryDisplay().rotation());
 
   // Enable lock at 90.
   orientation_controller->ToggleUserRotationLock();
   EXPECT_TRUE(display_manager->registered_internal_display_rotation_lock());
   EXPECT_EQ(display::Display::ROTATE_90,
             display_manager->registered_internal_display_rotation());
 
-  orientation_controller->OnAccelerometerUpdated(reverse_portrait);
+  orientation_controller->OnAccelerometerUpdated(portrait_secondary);
 
   EXPECT_EQ(display::Display::ROTATE_90,
             screen->GetPrimaryDisplay().rotation());
 }
 
+TEST_F(DisplayManagerOrientationTest, LockToSpecificOrientation) {
+  Shell* shell = Shell::Get();
+  display::DisplayManager* display_manager = shell->display_manager();
+  display::test::DisplayManagerTestApi(display_manager)
+      .SetFirstDisplayAsInternalDisplay();
+  ScreenOrientationController* orientation_controller =
+      shell->screen_orientation_controller();
+  test::ScreenOrientationControllerTestApi test_api(orientation_controller);
+
+  aura::Window* window_a = CreateTestWindowInShellWithId(0);
+  {
+    WmWindow* wm_window_a = WmWindow::Get(window_a);
+    wm_window_a->SetAppType(static_cast<int>(AppType::CHROME_APP));
+    orientation_controller->LockOrientationForWindow(
+        wm_window_a, blink::WebScreenOrientationLockAny,
+        ScreenOrientationController::LockCompletionBehavior::None);
+  }
+  wm::ActivateWindow(window_a);
+  Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
+      true);
+
+  orientation_controller->OnAccelerometerUpdated(portrait_primary);
+
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitPrimary,
+            test_api.GetCurrentOrientation());
+
+  orientation_controller->OnAccelerometerUpdated(portrait_secondary);
+
+  aura::Window* window_ps = CreateTestWindowInShellWithId(1);
+  {
+    WmWindow* wm_window_ps = WmWindow::Get(window_ps);
+    wm_window_ps->SetAppType(static_cast<int>(AppType::CHROME_APP));
+    orientation_controller->LockOrientationForWindow(
+        wm_window_ps, blink::WebScreenOrientationLockPortrait,
+        ScreenOrientationController::LockCompletionBehavior::DisableSensor);
+    wm::ActivateWindow(window_ps);
+  }
+
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitSecondary,
+            test_api.GetCurrentOrientation());
+
+  // The orientation should stay portrait secondary.
+  orientation_controller->OnAccelerometerUpdated(portrait_primary);
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitSecondary,
+            test_api.GetCurrentOrientation());
+
+  wm::ActivateWindow(window_a);
+  orientation_controller->OnAccelerometerUpdated(portrait_primary);
+
+  // Swtching to |window_a| enables rotation.
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitPrimary,
+            test_api.GetCurrentOrientation());
+
+  // The orientation has alraedy been locked to secondary once, so
+  // it should swtich back to the portrait secondary.
+  wm::ActivateWindow(window_ps);
+  EXPECT_EQ(blink::WebScreenOrientationLockPortraitSecondary,
+            test_api.GetCurrentOrientation());
+}
+
 }  // namespace ash