[ScreenOrientation] Fire pending lock request when we found it has failed.

content/browser/screen_orientation/screen_orientation_provider_unittest.cc

 // Copyright 2017 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 "content/browser/screen_orientation/screen_orientation_provider.h"
 
 #include "base/optional.h"
 #include "base/run_loop.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/screen_orientation_delegate.h"
@@ skipping 132 matching lines @@
 
   // Navigate to a site.
   const GURL url("http://www.google.com");
   controller().LoadURL(url, Referrer(), ui::PAGE_TRANSITION_TYPED,
                        std::string());
 
   base::Optional<ScreenOrientationLockResult> result_1;
   CallLockAndGetResult(blink::WebScreenOrientationLockType::
                            WebScreenOrientationLockLandscapeSecondary,
                        &result_1);
-  // Lock request is pending.
+#if defined(OS_ANDROID)
+  // On Android the screen orientation is expected to be changed asynchronously,
+  // the lock request is pending.
   EXPECT_FALSE(result_1.has_value());
+#else
+  // On other platforms the screen orientation is expected to be changed
+  // synchronously, but FakeScreenOrientationDelegate did not change screen
+  // orientation actually, so the lock request will be fired immediately.
+  EXPECT_EQ(ScreenOrientationLockResult::
+                SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
+            result_1);
+#endif
   // Delegate did apply lock once.
   EXPECT_EQ(1, delegate.lock_count());
 }
 
 // Full screen is required by delegate.
 TEST_F(ScreenOrientationProviderTest, DelegateRequireFullScreenLockOnce) {
   // ScreenOrientationDelegate requires full screen.
   FakeScreenOrientationDelegate delegate(true, true);
 
   // Navigate to a site.
@@ skipping 15 matching lines @@
 
   // Simulates entering full screen.
   main_test_rfh()->OnMessageReceived(
       FrameHostMsg_ToggleFullscreen(main_test_rfh()->GetRoutingID(), true));
   ASSERT_TRUE(contents()->IsFullscreenForCurrentTab());
 
   base::Optional<ScreenOrientationLockResult> result_2;
   CallLockAndGetResult(blink::WebScreenOrientationLockType::
                            WebScreenOrientationLockLandscapeSecondary,
                        &result_2);
+#if defined(OS_ANDROID)
   // Lock request is pending.
   EXPECT_FALSE(result_2.has_value());
+#else
+  EXPECT_EQ(ScreenOrientationLockResult::
+                SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
+            result_2);
+#endif
   // Delegate did apply lock once.
   EXPECT_EQ(1, delegate.lock_count());
 }
 
 // Lock once, then unlock once, the pending lock request will be cancelled.
 TEST_F(ScreenOrientationProviderTest, DelegateLockThenUnlock) {
   FakeScreenOrientationDelegate delegate(true, false);
 
   // Navigate to a site.
   const GURL url("http://www.google.com");
   controller().LoadURL(url, Referrer(), ui::PAGE_TRANSITION_TYPED,
                        std::string());
 
   base::Optional<ScreenOrientationLockResult> result_1;
   CallLockAndGetResult(blink::WebScreenOrientationLockType::
                            WebScreenOrientationLockLandscapeSecondary,
                        &result_1);
+#if defined(OS_ANDROID)
   // The lock request will be pending.
   EXPECT_FALSE(result_1.has_value());
+#else
+  EXPECT_EQ(ScreenOrientationLockResult::
+                SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
+            result_1);
+#endif
   // Delegate did apply lock once.
   EXPECT_EQ(1, delegate.lock_count());
   EXPECT_EQ(0, delegate.unlock_count());
 
   CallUnlock();
   // The pending lock request is cancelled.
   EXPECT_EQ(ScreenOrientationLockResult::
                 SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
             result_1);
   // Delegate did apply unlock once.
   EXPECT_EQ(1, delegate.unlock_count());
 }
 
 // Lock twice, the first lock request will be cancelled by the second one.
 TEST_F(ScreenOrientationProviderTest, DelegateLockThenLock) {
   FakeScreenOrientationDelegate delegate(true, false);
 
   // Navigate to a site.
   const GURL url("http://www.google.com");
   controller().LoadURL(url, Referrer(), ui::PAGE_TRANSITION_TYPED,
                        std::string());
 
   base::Optional<ScreenOrientationLockResult> result_1;
   CallLockAndGetResult(blink::WebScreenOrientationLockType::
                            WebScreenOrientationLockLandscapeSecondary,
                        &result_1);
+#if defined(OS_ANDROID)
   // The lock request will be pending.
   EXPECT_FALSE(result_1.has_value());
+#else
+  EXPECT_EQ(ScreenOrientationLockResult::
+                SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
+            result_1);
+#endif
   // Delegate did apply lock once.
   EXPECT_EQ(1, delegate.lock_count());
   EXPECT_EQ(0, delegate.unlock_count());
 
   base::Optional<ScreenOrientationLockResult> result_2;
   CallLockAndGetResult(blink::WebScreenOrientationLockType::
                            WebScreenOrientationLockLandscapeSecondary,
                        &result_2);
   // The pending lock request is cancelled.
   EXPECT_EQ(ScreenOrientationLockResult::
                 SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
             result_1);
+#if defined(OS_ANDROID)
   // The second one became pending.
   EXPECT_FALSE(result_2.has_value());
+#else
+  EXPECT_EQ(ScreenOrientationLockResult::
+                SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
+            result_2);
+#endif
   // Delegate did apply lock once more.
   EXPECT_EQ(2, delegate.lock_count());
   EXPECT_EQ(0, delegate.unlock_count());
 }
 
 // Unlock won't be applied if no lock has been applied previously.
 TEST_F(ScreenOrientationProviderTest, NoUnlockWithoutLock) {
   FakeScreenOrientationDelegate delegate(true, false);
 
   // Navigate to a site.
@@ skipping 20 matching lines @@
 
   // Simulates entering full screen.
   main_test_rfh()->OnMessageReceived(
       FrameHostMsg_ToggleFullscreen(main_test_rfh()->GetRoutingID(), true));
   ASSERT_TRUE(contents()->IsFullscreenForCurrentTab());
 
   base::Optional<ScreenOrientationLockResult> result;
   CallLockAndGetResult(blink::WebScreenOrientationLockType::
                            WebScreenOrientationLockLandscapeSecondary,
                        &result);
+#if defined(OS_ANDROID)
   // The lock request will be pending.
   EXPECT_FALSE(result.has_value());
+#else
+  EXPECT_EQ(ScreenOrientationLockResult::
+                SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
+            result);
+#endif
   // Delegate did apply lock once.
   EXPECT_EQ(1, delegate.lock_count());
   EXPECT_EQ(0, delegate.unlock_count());
 
   // Simulates exiting full screen.
   main_test_rfh()->OnMessageReceived(
       FrameHostMsg_ToggleFullscreen(main_test_rfh()->GetRoutingID(), false));
   ASSERT_FALSE(contents()->IsFullscreenForCurrentTab());
   // The pending lock request is cancelled.
   EXPECT_EQ(ScreenOrientationLockResult::
@@ skipping 11 matching lines @@
 
   // Navigate to a site.
   const GURL url("http://www.google.com");
   controller().LoadURL(url, Referrer(), ui::PAGE_TRANSITION_TYPED,
                        std::string());
 
   base::Optional<ScreenOrientationLockResult> result;
   CallLockAndGetResult(blink::WebScreenOrientationLockType::
                            WebScreenOrientationLockLandscapeSecondary,
                        &result);
+#if defined(OS_ANDROID)
   // The lock request will be pending.
   EXPECT_FALSE(result.has_value());
+#else
+  EXPECT_EQ(ScreenOrientationLockResult::
+                SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
+            result);
+#endif
   // Delegate did apply lock once.
   EXPECT_EQ(1, delegate.lock_count());
   EXPECT_EQ(0, delegate.unlock_count());
 
   // Navigate to another site.
   const GURL another_url("http://www.google.com/abc.html");
   contents()->NavigateAndCommit(another_url);
   // The pending lock request is cancelled.
   EXPECT_EQ(ScreenOrientationLockResult::
                 SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED,
             result);
   // Delegate did apply unlock once.
   EXPECT_EQ(1, delegate.unlock_count());
 }
 
 }  // namespace content