[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/DocumentUserGestureToken.h"
 #include "core/dom/Fullscreen.h"
@@ skipping 89 matching lines @@
     return WTF::MakeUnique<MockVideoWebMediaPlayer>();
   }
 };
 
 }  // anonymous namespace
 
 class MediaControlsOrientationLockDelegateTest : public ::testing::Test {
  protected:
   using DeviceOrientation =
       MediaControlsOrientationLockDelegate::DeviceOrientation;
+  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 642 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 50 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.
   // orientation lock).
   SimulateExitFullscreen();
   EXPECT_FALSE(Video().IsFullscreen());
 
   // MediaControlsOrientationLockDelegate should remain unlocked.
@@ skipping 25 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 61 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 73 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,
+       ScreenOrientationRace) {
+  // 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 */);
+
+  // MediaControlsOrientationLockDelegate should remain locked to landscape for
+  // a few hundred milliseconds...
+  testing::RunDelayedTasks(249);
+  CheckStateMaybeLockedFullscreen();
+  EXPECT_EQ(kWebScreenOrientationLockLandscape, DelegateOrientationLock());
+
+  // ...because it might take that long for Android to update the screen
+  // orientation due to low pass filtering.
+  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 - 249);

[mlamouri (slow - plz ping), 2017/05/31 20:18:37]

Maybe you could harden this test by using `kUnlockDelayMs/2` above and here. You
can drop a +1 so you don't need to worry about rounding. Here, you take the risk
to fail when `kUnlockDelayMs` becomes lower than 250.

[johnme, 2017/06/01 17:21:56]

If kUnlockDelayMs becomes lower than 250 (or at least 201), then the test should
fail, since empirically the race condition does sometimes occur when
kUnlockDelayMs is 200. I made the comments clearer.

+
+  // MediaControlsOrientationLockDelegate should now have unlocked.
+  CheckStatePendingFullscreen();
+  EXPECT_FALSE(DelegateWillUnlockFullscreen());
+}
+
 }  // namespace blink