[Media controls] Integrate rotate-to-fullscreen with orientation lock

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

 // 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 "modules/media_controls/MediaControlsRotateToFullscreenDelegate.h"
 
 #include "core/HTMLNames.h"
 #include "core/css/CSSStyleDeclaration.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/Fullscreen.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLAudioElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/loader/EmptyClients.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/media_controls/MediaControlsImpl.h"
+#include "modules/screen_orientation/ScreenOrientationControllerImpl.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/testing/EmptyWebMediaPlayer.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/wtf/text/AtomicString.h"
 #include "public/platform/WebSize.h"
+#include "public/platform/modules/screen_orientation/WebScreenOrientationClient.h"
 #include "public/platform/modules/screen_orientation/WebScreenOrientationType.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::AtLeast;
 using ::testing::Return;
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
+class FakeWebScreenOrientationClient : public WebScreenOrientationClient {
+ public:
+  // WebScreenOrientationClient overrides:
+  void LockOrientation(WebScreenOrientationLockType,
+                       std::unique_ptr<WebLockOrientationCallback>) override {}
+  void UnlockOrientation() override {}
+};
+
 class MockVideoWebMediaPlayer : public EmptyWebMediaPlayer {
  public:
   // ChromeClient overrides:
   bool HasVideo() const override { return true; }
 
   MOCK_CONST_METHOD0(NaturalSize, WebSize());
 };
 
 class MockChromeClient : public EmptyChromeClient {
  public:
   // ChromeClient overrides:
+  void InstallSupplements(LocalFrame& frame) override {
+    EmptyChromeClient::InstallSupplements(frame);
+    ScreenOrientationControllerImpl::ProvideTo(frame,
+                                               &web_screen_orientation_client);
+  }
   void EnterFullscreen(LocalFrame& frame) override {
     Fullscreen::From(*frame.GetDocument()).DidEnterFullscreen();
   }
   void ExitFullscreen(LocalFrame& frame) override {
     Fullscreen::From(*frame.GetDocument()).DidExitFullscreen();
   }
 
   MOCK_CONST_METHOD0(GetScreenInfo, WebScreenInfo());
+
+ private:
+  FakeWebScreenOrientationClient web_screen_orientation_client;

[mlamouri (slow - plz ping), 2017/05/24 17:03:41]

style: you are missing a _

[johnme, 2017/05/24 17:17:42]

Done.

 };
 
 class StubLocalFrameClient : public EmptyLocalFrameClient {
  public:
   static StubLocalFrameClient* Create() { return new StubLocalFrameClient; }
 
   std::unique_ptr<WebMediaPlayer> CreateWebMediaPlayer(
       HTMLMediaElement&,
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) override {
     return WTF::MakeUnique<MockVideoWebMediaPlayer>();
   }
 };
 
 }  // anonymous namespace
 
 class MediaControlsRotateToFullscreenDelegateTest : public ::testing::Test {
  protected:
   using SimpleOrientation =
       MediaControlsRotateToFullscreenDelegate::SimpleOrientation;
 
   void SetUp() override {
     previous_video_rotate_to_fullscreen_value_ =
         RuntimeEnabledFeatures::videoRotateToFullscreenEnabled();
+    previous_video_fullscreen_orientation_lock_value_ =
+        RuntimeEnabledFeatures::videoFullscreenOrientationLockEnabled();
     RuntimeEnabledFeatures::setVideoRotateToFullscreenEnabled(true);
+    RuntimeEnabledFeatures::setVideoFullscreenOrientationLockEnabled(true);
 
     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());
 
     video_ = HTMLVideoElement::Create(GetDocument());
     GetVideo().setAttribute(controlsAttr, g_empty_atom);
     // Most tests should call GetDocument().body()->AppendChild(&GetVideo());
     // This is not done automatically, so that tests control timing of `Attach`.
   }
 
   void TearDown() override {
     RuntimeEnabledFeatures::setVideoRotateToFullscreenEnabled(
         previous_video_rotate_to_fullscreen_value_);
+    RuntimeEnabledFeatures::setVideoFullscreenOrientationLockEnabled(
+        previous_video_fullscreen_orientation_lock_value_);
   }
 
   static bool HasDelegate(const MediaControls& media_controls) {
     return !!static_cast<const MediaControlsImpl*>(&media_controls)
                  ->rotate_to_fullscreen_delegate_;
   }
 
-  static bool HasOrientationLockDelegate(const MediaControls& media_controls) {
-    return !!static_cast<const MediaControlsImpl*>(&media_controls)
-                 ->orientation_lock_delegate_;
-  }
-
   void SimulateVideoReadyState(HTMLMediaElement::ReadyState state) {
     GetVideo().SetReadyState(state);
   }
 
   SimpleOrientation ObservedScreenOrientation() const {
     return GetMediaControls()
         .rotate_to_fullscreen_delegate_->current_screen_orientation_;
   }
 
   SimpleOrientation ComputeVideoOrientation() const {
@@ skipping 41 matching lines @@
   MediaControlsImpl& GetMediaControls() const {
     return *static_cast<MediaControlsImpl*>(GetVideo().GetMediaControls());
   }
   MockVideoWebMediaPlayer& GetWebMediaPlayer() const {
     return *static_cast<MockVideoWebMediaPlayer*>(
         GetVideo().GetWebMediaPlayer());
   }
 
  private:
   bool previous_video_rotate_to_fullscreen_value_;
+  bool previous_video_fullscreen_orientation_lock_value_;
   Persistent<MockChromeClient> chrome_client_;
   std::unique_ptr<DummyPageHolder> page_holder_;
   Persistent<HTMLVideoElement> video_;
 };
 
 void MediaControlsRotateToFullscreenDelegateTest::InitScreenAndVideo(
     WebScreenOrientationType initial_screen_orientation,
     WebSize video_size) {
   // Set initial screen orientation (called by `Attach` during `AppendChild`).
   WebScreenInfo screen_info;
@@ skipping 20 matching lines @@
     GetVideo().Play();
   }
   testing::RunPendingTasks();
 }
 
 void MediaControlsRotateToFullscreenDelegateTest::RotateTo(
     WebScreenOrientationType new_screen_orientation) {
   WebScreenInfo screen_info;
   screen_info.orientation_type = new_screen_orientation;
   EXPECT_CALL(GetChromeClient(), GetScreenInfo())
-      .Times(1)
-      .WillOnce(Return(screen_info));
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(screen_info));
   DispatchEvent(GetWindow(), EventTypeNames::orientationchange);
   testing::RunPendingTasks();
 }
 
 TEST_F(MediaControlsRotateToFullscreenDelegateTest, DelegateRequiresFlag) {
   // SetUp turns the flag on by default.
   GetDocument().body()->AppendChild(&GetVideo());
   EXPECT_TRUE(HasDelegate(GetMediaControls()));
 
   // No delegate when flag is off.
   RuntimeEnabledFeatures::setVideoRotateToFullscreenEnabled(false);
   HTMLVideoElement* video = HTMLVideoElement::Create(GetDocument());
   GetDocument().body()->AppendChild(video);
   EXPECT_FALSE(HasDelegate(*video->GetMediaControls()));
 }
 
 TEST_F(MediaControlsRotateToFullscreenDelegateTest, DelegateRequiresVideo) {
   HTMLAudioElement* audio = HTMLAudioElement::Create(GetDocument());
   GetDocument().body()->AppendChild(audio);
   EXPECT_FALSE(HasDelegate(*audio->GetMediaControls()));
 }
 
-TEST_F(MediaControlsRotateToFullscreenDelegateTest,
-       OrientationLockIsMutuallyExclusive) {
-  // Rotate to fullscreen and fullscreen orientation lock are currently
-  // incompatible, so if both are enabled only one should be active.
-  RuntimeEnabledFeatures::setVideoRotateToFullscreenEnabled(true);
-  RuntimeEnabledFeatures::setVideoFullscreenOrientationLockEnabled(true);
-  HTMLVideoElement* video = HTMLVideoElement::Create(GetDocument());
-  GetDocument().body()->AppendChild(video);
-  EXPECT_TRUE(HasDelegate(*video->GetMediaControls()));
-  EXPECT_FALSE(HasOrientationLockDelegate(*video->GetMediaControls()));
-}
-
 TEST_F(MediaControlsRotateToFullscreenDelegateTest, ComputeVideoOrientation) {
   // Set up the WebMediaPlayer instance.
   GetDocument().body()->AppendChild(&GetVideo());
   GetVideo().SetSrc("https://example.com");
   testing::RunPendingTasks();
 
   // Each `ComputeVideoOrientation` calls `NaturalSize` twice, except the first
   // one where the video is not yet ready.
   EXPECT_CALL(GetWebMediaPlayer(), NaturalSize())
       .Times(12)
@@ skipping 395 matching lines @@
 
   // Rotate screen to portrait.
   RotateTo(kWebScreenOrientationPortraitPrimary);
 
   // Should not exit fullscreen, since video was not the fullscreen element.
   EXPECT_TRUE(Fullscreen::IsCurrentFullScreenElement(*GetDocument().body()));
   EXPECT_FALSE(GetVideo().IsFullscreen());
 }
 
 }  // namespace blink