Snapshot of all changes to get jumbo in blink and content.

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/UserGestureIndicator.h"
 #include "core/frame/FrameView.h"
@@ skipping 26 matching lines @@
 namespace {
 
 // WebLockOrientationCallback implementation that will not react to a success
 // nor a failure.
 class DummyScreenOrientationCallback final : public WebLockOrientationCallback {
  public:
   void OnSuccess() override {}
   void OnError(WebLockOrientationError) override {}
 };
 
-class MockVideoWebMediaPlayer final : public EmptyWebMediaPlayer {
+class MockWebMediaPlayerForOrientationLockDelegate final
+    : public EmptyWebMediaPlayer {
  public:
   bool HasVideo() const override { return true; }
 
   MOCK_CONST_METHOD0(NaturalSize, WebSize());
 };
 
 class MockWebScreenOrientationClient final : public WebScreenOrientationClient {
  public:
   // WebScreenOrientationClient overrides:
   void LockOrientation(WebScreenOrientationLockType type,
@@ skipping 10 matching lines @@
   Fullscreen::From(*document).DidEnterFullscreen();
   document->ServiceScriptedAnimations(WTF::MonotonicallyIncreasingTime());
 }
 
 void DidExitFullscreen(Document* document) {
   DCHECK(document);
   Fullscreen::From(*document).DidExitFullscreen();
   document->ServiceScriptedAnimations(WTF::MonotonicallyIncreasingTime());
 }
 
-class MockChromeClient final : public EmptyChromeClient {
+class MockChromeClientForOrientationLockDelegate final
+    : public EmptyChromeClient {
  public:
   // ChromeClient overrides:
   void InstallSupplements(LocalFrame& frame) override {
     EmptyChromeClient::InstallSupplements(frame);
     ScreenOrientationControllerImpl::ProvideTo(frame,
                                                &web_screen_orientation_client_);
   }
   // The real ChromeClient::EnterFullscreen/ExitFullscreen implementation is
   // async due to IPC, emulate that by posting tasks:
   void EnterFullscreen(LocalFrame& frame) override {
@@ skipping 10 matching lines @@
   MOCK_CONST_METHOD0(GetScreenInfo, WebScreenInfo());
 
   MockWebScreenOrientationClient& WebScreenOrientationClient() {
     return web_screen_orientation_client_;
   }
 
  private:
   MockWebScreenOrientationClient web_screen_orientation_client_;
 };
 
-class StubLocalFrameClient final : public EmptyLocalFrameClient {
+class StubLocalFrameClientForOrientationLockDelegate final
+    : public EmptyLocalFrameClient {
  public:
-  static StubLocalFrameClient* Create() { return new StubLocalFrameClient; }
+  static StubLocalFrameClientForOrientationLockDelegate* Create() {
+    return new StubLocalFrameClientForOrientationLockDelegate;
+  }
 
   std::unique_ptr<WebMediaPlayer> CreateWebMediaPlayer(
       HTMLMediaElement&,
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) override {
-    return WTF::MakeUnique<MockVideoWebMediaPlayer>();
+    return WTF::MakeUnique<MockWebMediaPlayerForOrientationLockDelegate>();
   }
 };
 
 }  // anonymous namespace
 
 class MediaControlsOrientationLockDelegateTest : public ::testing::Test {
  protected:
   using DeviceOrientationType =
       MediaControlsOrientationLockDelegate::DeviceOrientationType;
 
   static constexpr TimeDelta GetUnlockDelay() {
     return MediaControlsOrientationLockDelegate::kUnlockDelay;
   }
 
   void SetUp() override {
-    chrome_client_ = new MockChromeClient();
+    chrome_client_ = new MockChromeClientForOrientationLockDelegate();
 
     Page::PageClients clients;
     FillWithEmptyClients(clients);
     clients.chrome_client = chrome_client_.Get();
 
-    page_holder_ = DummyPageHolder::Create(IntSize(800, 600), &clients,
-                                           StubLocalFrameClient::Create());
+    page_holder_ = DummyPageHolder::Create(
+        IntSize(800, 600), &clients,
+        StubLocalFrameClientForOrientationLockDelegate::Create());
 
     previous_orientation_event_value_ =
         RuntimeEnabledFeatures::OrientationEventEnabled();
     previous_video_fullscreen_orientation_lock_value_ =
         RuntimeEnabledFeatures::VideoFullscreenOrientationLockEnabled();
     previous_video_rotate_to_fullscreen_value_ =
         RuntimeEnabledFeatures::VideoRotateToFullscreenEnabled();
     RuntimeEnabledFeatures::SetVideoFullscreenOrientationLockEnabled(true);
     // Turn off rotate-to-fullscreen. Tests covering the intersection of the two
     // can use the MediaControlsOrientationLockAndRotateToFullscreenDelegateTest
@@ skipping 74 matching lines @@
 
   WebScreenOrientationLockType DelegateOrientationLock() const {
     return MediaControls()->orientation_lock_delegate_->locked_orientation_;
   }
 
   WebScreenOrientationLockType ComputeOrientationLock() const {
     return MediaControls()
         ->orientation_lock_delegate_->ComputeOrientationLock();
   }
 
-  MockChromeClient& ChromeClient() const { return *chrome_client_; }
+  MockChromeClientForOrientationLockDelegate& ChromeClient() const {
+    return *chrome_client_;
+  }
 
   HTMLVideoElement& Video() const { return *video_; }
   Document& GetDocument() const { return page_holder_->GetDocument(); }
   MockWebScreenOrientationClient& ScreenOrientationClient() const {
     return ChromeClient().WebScreenOrientationClient();
   }
-  MockVideoWebMediaPlayer& MockWebMediaPlayer() const {
-    return *static_cast<MockVideoWebMediaPlayer*>(Video().GetWebMediaPlayer());
+  MockWebMediaPlayerForOrientationLockDelegate& MockWebMediaPlayer() const {
+    return *static_cast<MockWebMediaPlayerForOrientationLockDelegate*>(
+        Video().GetWebMediaPlayer());
   }
 
  private:
   friend class MediaControlsOrientationLockAndRotateToFullscreenDelegateTest;
 
   bool previous_orientation_event_value_;
   bool previous_video_fullscreen_orientation_lock_value_;
   bool previous_video_rotate_to_fullscreen_value_;
   std::unique_ptr<DummyPageHolder> page_holder_;
   Persistent<HTMLVideoElement> video_;
-  Persistent<MockChromeClient> chrome_client_;
+  Persistent<MockChromeClientForOrientationLockDelegate> chrome_client_;
 };
 
 class MediaControlsOrientationLockAndRotateToFullscreenDelegateTest
     : public MediaControlsOrientationLockDelegateTest {
  protected:
   enum DeviceNaturalOrientation { kNaturalIsPortrait, kNaturalIsLandscape };
 
   void SetUp() override {
     // Unset this to fix ScreenOrientationControllerImpl::ComputeOrientation.
     // TODO(mlamouri): Refactor to avoid this (crbug.com/726817).
@@ skipping 1122 matching lines @@
 
   // Wait for the rest of the unlock delay.
   testing::RunDelayedTasks(GetUnlockDelay() - kMinUnlockDelay);
 
   // MediaControlsOrientationLockDelegate should now have unlocked.
   CheckStatePendingFullscreen();
   EXPECT_FALSE(DelegateWillUnlockFullscreen());
 }
 
 }  // namespace blink