[Media Controls] Prevent fullscreen orientation lock rotate glitch

third_party/WebKit/Source/modules/media_controls/MediaControlsOrientationLockDelegateTest.cpp

 // Copyright 2016 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 "modules/media_controls/MediaControlsOrientationLockDelegate.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/UserGestureIndicator.h"
@@ skipping 88 matching lines @@
     return WTF::MakeUnique<MockVideoWebMediaPlayer>();
   }
 };
 
 }  // anonymous namespace
 
 class MediaControlsOrientationLockDelegateTest : public ::testing::Test {
  protected:
   using DeviceOrientationType =
       MediaControlsOrientationLockDelegate::DeviceOrientationType;
+  static constexpr int kUnlockDelayMs =
+      MediaControlsOrientationLockDelegate::kUnlockDelayMs;
 
   void SetUp() override {
     chrome_client_ = new MockChromeClient();
 
     Page::PageClients clients;
     FillWithEmptyClients(clients);
     clients.chrome_client = chrome_client_.Get();
 
     page_holder_ = DummyPageHolder::Create(IntSize(800, 600), &clients,
                                            StubLocalFrameClient::Create());
@@ skipping 639 matching lines @@
   // MediaControlsRotateToFullscreenDelegate should enter fullscreen, so
   // MediaControlsOrientationLockDelegate should lock orientation to landscape
   // (even though the screen is already landscape).
   EXPECT_TRUE(Video().IsFullscreen());
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 
   // Device orientation events received by MediaControlsOrientationLockDelegate
   // will confirm that the device is already landscape.
   RotateDeviceTo(90 /* landscape primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsOrientationLockDelegate should unlock orientation.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
 }
 
 TEST_F(MediaControlsOrientationLockAndRotateToFullscreenDelegateTest,
        PortraitInlineButtonToPortraitLockedLandscapeFullscreen) {
   // Naturally portrait device, initially portrait, with landscape video.
   natural_orientation_is_portrait_ = true;
@@ skipping 14 matching lines @@
   // MediaControlsOrientationLockDelegate should lock to landscape.
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 
   // This will trigger a screen orientation change to landscape.
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationLandscapePrimary, 90));
 
   // Even though the device is still held in portrait.
   RotateDeviceTo(0 /* portrait primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsOrientationLockDelegate should remain locked to landscape.
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 }
 
 TEST_F(MediaControlsOrientationLockAndRotateToFullscreenDelegateTest,
        PortraitLockedLandscapeFullscreenRotateToLandscapeFullscreen) {
   // Naturally portrait device, initially portrait device orientation but locked
   // to landscape screen orientation, with landscape video.
   natural_orientation_is_portrait_ = true;
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationLandscapePrimary, 90));
   InitVideo(640, 480);
   SetIsAutoRotateEnabledByUser(true);
 
   // Initially fullscreen, locked orientation.
   SimulateEnterFullscreen();
   ASSERT_TRUE(Video().IsFullscreen());
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 
   // Simulate user rotating their device to landscape (matching the screen
   // orientation lock).
   RotateDeviceTo(90 /* landscape primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsOrientationLockDelegate should unlock orientation.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
   EXPECT_TRUE(Video().IsFullscreen());
 }
 
 TEST_F(MediaControlsOrientationLockAndRotateToFullscreenDelegateTest,
        PortraitLockedLandscapeFullscreenBackToPortraitInline) {
   // Naturally portrait device, initially portrait device orientation but locked
@@ skipping 49 matching lines @@
 
   // Initially inline, unlocked orientation.
   ASSERT_FALSE(Video().IsFullscreen());
   CheckStatePendingFullscreen();
   ASSERT_FALSE(DelegateWillUnlockFullscreen());
 
   // Simulate user rotating their device to portrait triggering a screen
   // orientation change.
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationPortraitPrimary, 0));
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // Video should remain inline, unlocked.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
   EXPECT_FALSE(Video().IsFullscreen());
 }
 
 TEST_F(MediaControlsOrientationLockAndRotateToFullscreenDelegateTest,
        LandscapeInlineButtonToLandscapeFullscreen) {
   // Naturally portrait device, initially landscape, with landscape video.
@@ skipping 13 matching lines @@
   EXPECT_TRUE(Video().IsFullscreen());
 
   // MediaControlsOrientationLockDelegate should lock to landscape (even though
   // the screen is already landscape).
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 
   // Device orientation events received by MediaControlsOrientationLockDelegate
   // will confirm that the device is already landscape.
   RotateDeviceTo(90 /* landscape primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsOrientationLockDelegate should unlock orientation.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
 }
 
 TEST_F(MediaControlsOrientationLockAndRotateToFullscreenDelegateTest,
        LandscapeFullscreenRotateToPortraitInline) {
   // Naturally portrait device, initially landscape, with landscape video.
   natural_orientation_is_portrait_ = true;
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationLandscapePrimary, 90));
   InitVideo(640, 480);
   SetIsAutoRotateEnabledByUser(true);
 
   // Initially fullscreen, unlocked orientation.
   SimulateEnterFullscreen();
   RotateDeviceTo(90 /* landscape primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
   ASSERT_TRUE(Video().IsFullscreen());
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
 
   // Simulate user rotating their device to portrait triggering a screen
   // orientation change.
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationPortraitPrimary, 0));
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsRotateToFullscreenDelegate should exit fullscreen.
   EXPECT_FALSE(Video().IsFullscreen());
 
   // MediaControlsOrientationLockDelegate should remain unlocked.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
 }
 
 TEST_F(MediaControlsOrientationLockAndRotateToFullscreenDelegateTest,
        LandscapeFullscreenBackToLandscapeInline) {
   // Naturally portrait device, initially landscape, with landscape video.
   natural_orientation_is_portrait_ = true;
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationLandscapePrimary, 90));
   InitVideo(640, 480);
   SetIsAutoRotateEnabledByUser(true);
 
   // Initially fullscreen, unlocked orientation.
   SimulateEnterFullscreen();
   RotateDeviceTo(90 /* landscape primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
   ASSERT_TRUE(Video().IsFullscreen());
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
 
   // Simulate user clicking on media controls exit fullscreen button.
   SimulateExitFullscreen();
   EXPECT_FALSE(Video().IsFullscreen());
 
   // MediaControlsOrientationLockDelegate should remain unlocked.
   CheckStatePendingFullscreen();
@@ skipping 24 matching lines @@
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 
   // This will trigger a screen orientation change to landscape, since the app's
   // lock overrides the user's orientation lock (at least on Android).
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationLandscapePrimary, 90));
 
   // Even though the device is still held in portrait.
   RotateDeviceTo(0 /* portrait primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsOrientationLockDelegate should remain locked to landscape.
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 }
 
 TEST_F(
     MediaControlsOrientationLockAndRotateToFullscreenDelegateTest,
     AutoRotateDisabledPortraitLockedLandscapeFullscreenRotateToLandscapeLockedLandscapeFullscreen) {
   // Naturally portrait device, initially portrait device orientation but locked
   // to landscape screen orientation, with landscape video.
   natural_orientation_is_portrait_ = true;
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationLandscapePrimary, 90));
   InitVideo(640, 480);
   // But this time the user has disabled auto rotate, e.g. locked to portrait
   // (even though the app's landscape screen orientation lock overrides it).
   SetIsAutoRotateEnabledByUser(false);
 
   // Initially fullscreen, locked orientation.
   SimulateEnterFullscreen();
   ASSERT_TRUE(Video().IsFullscreen());
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 
   // Simulate user rotating their device to landscape (matching the screen
   // orientation lock).
   RotateDeviceTo(90 /* landscape primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsOrientationLockDelegate should remain locked to landscape even
   // though the screen orientation is now landscape, since the user has disabled
   // auto rotate, so unlocking now would cause the device to return to the
   // portrait orientation.
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
   EXPECT_TRUE(Video().IsFullscreen());
 }
 
@@ skipping 60 matching lines @@
   // Initially fullscreen, locked orientation.
   SimulateEnterFullscreen();
   ASSERT_TRUE(Video().IsFullscreen());
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 
   // Simulate user rotating their device to portrait (matching the user's
   // rotation lock, but perpendicular to MediaControlsOrientationLockDelegate's
   // screen orientation lock which overrides it).
   RotateDeviceTo(0 /* portrait primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // Video should remain locked and fullscreen. This may disappoint users who
   // expect MediaControlsRotateToFullscreenDelegate to let them always leave
   // fullscreen by rotating perpendicular to the video's orientation (i.e.
   // rotating to portrait for a landscape video), however in this specific case,
   // since the user disabled auto rotate at the OS level, it's likely that they
   // wish to be able to use their phone whilst their head is lying sideways on a
   // pillow (or similar), in which case it's essential to keep the fullscreen
   // orientation lock.
   CheckStateMaybeLockedFullscreen();
@@ skipping 72 matching lines @@
   // MediaControlsRotateToFullscreenDelegate should enter fullscreen, so
   // MediaControlsOrientationLockDelegate should lock orientation to portrait
   // (even though the screen is already portrait).
   EXPECT_TRUE(Video().IsFullscreen());
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockPortrait, DelegateOrientationLock());
 
   // Device orientation events received by MediaControlsOrientationLockDelegate
   // will confirm that the device is already portrait.
   RotateDeviceTo(0 /* portrait primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsOrientationLockDelegate should unlock orientation.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
   EXPECT_TRUE(Video().IsFullscreen());
 
   // Simulate user rotating their device to landscape triggering a screen
   // orientation change.
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationLandscapePrimary, 90));
@@ skipping 30 matching lines @@
   // MediaControlsRotateToFullscreenDelegate should enter fullscreen, so
   // MediaControlsOrientationLockDelegate should lock orientation to landscape
   // (even though the screen is already landscape).
   EXPECT_TRUE(Video().IsFullscreen());
   CheckStateMaybeLockedFullscreen();
   EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
 
   // Device orientation events received by MediaControlsOrientationLockDelegate
   // will confirm that the device is already landscape.
   RotateDeviceTo(0 /* landscape primary */);
+  testing::RunDelayedTasks(kUnlockDelayMs);
 
   // MediaControlsOrientationLockDelegate should unlock orientation.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
   EXPECT_TRUE(Video().IsFullscreen());
 
   // Simulate user rotating their device to portrait triggering a screen
   // orientation change.
   ASSERT_NO_FATAL_FAILURE(
       RotateScreenTo(kWebScreenOrientationPortraitPrimary, 270));
 
   // MediaControlsRotateToFullscreenDelegate should exit fullscreen.
   EXPECT_FALSE(Video().IsFullscreen());
 
   // MediaControlsOrientationLockDelegate should remain unlocked.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
 }
 
+TEST_F(MediaControlsOrientationLockAndRotateToFullscreenDelegateTest,
+       ScreenOrientationRaceCondition) {
+  // Naturally portrait device, initially portrait, with landscape video.
+  natural_orientation_is_portrait_ = true;
+  ASSERT_NO_FATAL_FAILURE(
+      RotateScreenTo(kWebScreenOrientationPortraitPrimary, 0));
+  InitVideo(640, 480);
+  SetIsAutoRotateEnabledByUser(true);
+
+  // Initially inline, unlocked orientation.
+  ASSERT_FALSE(Video().IsFullscreen());
+  CheckStatePendingFullscreen();
+  ASSERT_FALSE(DelegateWillUnlockFullscreen());
+
+  // Simulate user clicking on media controls fullscreen button.
+  SimulateEnterFullscreen();
+  EXPECT_TRUE(Video().IsFullscreen());
+
+  // MediaControlsOrientationLockDelegate should lock to landscape.
+  CheckStateMaybeLockedFullscreen();
+  EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
+
+  // This will trigger a screen orientation change to landscape.
+  ASSERT_NO_FATAL_FAILURE(
+      RotateScreenTo(kWebScreenOrientationLandscapePrimary, 90));
+
+  // Even though the device is still held in portrait.
+  RotateDeviceTo(0 /* portrait primary */);
+
+  // MediaControlsOrientationLockDelegate should remain locked to landscape
+  // indefinitely.
+  testing::RunDelayedTasks(kUnlockDelayMs);
+  CheckStateMaybeLockedFullscreen();
+  EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
+
+  // Now suppose the user actually rotates from portrait-primary to landscape-
+  // secondary, despite the screen currently being landscape-primary.
+  RotateDeviceTo(270 /* landscape secondary */);
+
+  // There can be a significant delay, between the device orientation changing
+  // and the OS updating the screen orientation to match the new device
+  // orientation. Manual testing showed that it could take longer than 200ms,
+  // but less than 250ms, on common Android devices. Partly this is because OSes
+  // often low-pass filter the device orientation to ignore high frequency
+  // noise.
+  //
+  // During this period, MediaControlsOrientationLockDelegate should
+  // remain locked to landscape. This prevents a race condition where the
+  // delegate unlocks the screen orientation, so Android changes the screen
+  // orientation back to portrait because it hasn't yet processed the device
+  // orientation change to landscape.
+  constexpr int kMinUnlockDelayMs = 249;
+  static_assert(kUnlockDelayMs > kMinUnlockDelayMs,
+                "kUnlockDelayMs should significantly exceed kMinUnlockDelayMs");
+  testing::RunDelayedTasks(kMinUnlockDelayMs);
+  CheckStateMaybeLockedFullscreen();
+  EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
+
+  // Simulate the OS processing the device orientation change after a delay of
+  // `kMinUnlockDelayMs` and hence changing the screen orientation.
+  ASSERT_NO_FATAL_FAILURE(
+      RotateScreenTo(kWebScreenOrientationLandscapeSecondary, 270));
+
+  // MediaControlsOrientationLockDelegate should remain locked to landscape.
+  CheckStateMaybeLockedFullscreen();
+  EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
+
+  // Wait for the rest of the unlock delay.
+  testing::RunDelayedTasks(kUnlockDelayMs - kMinUnlockDelayMs);
+
+  // MediaControlsOrientationLockDelegate should now have unlocked.
+  CheckStatePendingFullscreen();
+  EXPECT_FALSE(DelegateWillUnlockFullscreen());
+}
+
 }  // namespace blink