Move core MediaControls implementation to modules/media_controls/.

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

 /*
  * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "core/html/shadow/MediaControls.h"
+#include "modules/media_controls/MediaControlsImpl.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/ResizeObserver.h"
 #include "core/dom/ResizeObserverCallback.h"
 #include "core/dom/ResizeObserverEntry.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/MouseEvent.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/media/HTMLMediaElementControlsList.h"
 #include "core/html/shadow/MediaControlsMediaEventListener.h"
-#include "core/html/shadow/MediaControlsOrientationLockDelegate.h"
 #include "core/html/shadow/MediaControlsWindowEventListener.h"
 #include "core/html/track/TextTrackContainer.h"
 #include "core/html/track/TextTrackList.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTheme.h"
+#include "modules/media_controls/MediaControlsOrientationLockDelegate.h"
 #include "platform/EventDispatchForbiddenScope.h"
 
 namespace blink {
 
 namespace {
 
 // TODO(steimel): should have better solution than hard-coding pixel values.
 // Defined in core/css/mediaControls.css, core/css/mediaControlsAndroid.css,
 // and core/paint/MediaControlsPainter.cpp.
 constexpr int kOverlayPlayButtonWidth = 48;
 constexpr int kOverlayPlayButtonHeight = 48;
 constexpr int kOverlayBottomMargin = 10;
 constexpr int kAndroidMediaPanelHeight = 48;
 
 constexpr int kMinWidthForOverlayPlayButton = kOverlayPlayButtonWidth;
 constexpr int kMinHeightForOverlayPlayButton = kOverlayPlayButtonHeight +
                                                kAndroidMediaPanelHeight +
                                                (2 * kOverlayBottomMargin);
 
-}  // anonymous namespace
-
 // If you change this value, then also update the corresponding value in
 // LayoutTests/media/media-controls.js.
-static const double timeWithoutMouseMovementBeforeHidingMediaControls = 3;
+const double timeWithoutMouseMovementBeforeHidingMediaControls = 3;
 
-static bool shouldShowFullscreenButton(const HTMLMediaElement& mediaElement) {
+bool shouldShowFullscreenButton(const HTMLMediaElement& mediaElement) {
   // Unconditionally allow the user to exit fullscreen if we are in it
   // now.  Especially on android, when we might not yet know if
   // fullscreen is supported, we sometimes guess incorrectly and show
   // the button earlier, and we don't want to remove it here if the
   // user chose to enter fullscreen.  crbug.com/500732 .
   if (mediaElement.isFullscreen())
     return true;
 
   if (!mediaElement.isHTMLVideoElement())
     return false;
 
   if (!mediaElement.hasVideo())
     return false;
 
   if (!Fullscreen::fullscreenEnabled(mediaElement.document()))
     return false;
 
   if (mediaElement.controlsListInternal()->shouldHideFullscreen()) {
     UseCounter::count(mediaElement.document(),
                       UseCounter::HTMLMediaElementControlsListNoFullscreen);
     return false;
   }
 
   return true;
 }
 
-static bool shouldShowCastButton(HTMLMediaElement& mediaElement) {
+bool shouldShowCastButton(HTMLMediaElement& mediaElement) {
   if (mediaElement.fastHasAttribute(HTMLNames::disableremoteplaybackAttr))
     return false;
 
   // Explicitly do not show cast button when the mediaControlsEnabled setting is
   // false to make sure the overlay does not appear.
   Document& document = mediaElement.document();
   if (document.settings() && !document.settings()->getMediaControlsEnabled())
     return false;
 
   // The page disabled the button via the attribute.
   if (mediaElement.controlsListInternal()->shouldHideRemotePlayback()) {
     UseCounter::count(mediaElement.document(),
                       UseCounter::HTMLMediaElementControlsListNoRemotePlayback);
     return false;
   }
 
   return mediaElement.hasRemoteRoutes();
 }
 
-static bool preferHiddenVolumeControls(const Document& document) {
+bool preferHiddenVolumeControls(const Document& document) {
   return !document.settings() ||
          document.settings()->getPreferHiddenVolumeControls();
 }
 
-class MediaControls::BatchedControlUpdate {
+}  // anonymous namespace
+
+class MediaControlsImpl::BatchedControlUpdate {
   WTF_MAKE_NONCOPYABLE(BatchedControlUpdate);
   STACK_ALLOCATED();
 
  public:
-  explicit BatchedControlUpdate(MediaControls* controls)
+  explicit BatchedControlUpdate(MediaControlsImpl* controls)
       : m_controls(controls) {
     DCHECK(isMainThread());
     DCHECK_GE(s_batchDepth, 0);
     ++s_batchDepth;
   }
   ~BatchedControlUpdate() {
     DCHECK(isMainThread());
     DCHECK_GT(s_batchDepth, 0);
     if (!(--s_batchDepth))
       m_controls->computeWhichControlsFit();
   }
 
  private:
-  Member<MediaControls> m_controls;
+  Member<MediaControlsImpl> m_controls;
   static int s_batchDepth;
 };
 
 // Count of number open batches for controls visibility.
-int MediaControls::BatchedControlUpdate::s_batchDepth = 0;
+int MediaControlsImpl::BatchedControlUpdate::s_batchDepth = 0;
 
-class MediaControls::MediaControlsResizeObserverCallback final
+class MediaControlsImpl::MediaControlsResizeObserverCallback final
     : public ResizeObserverCallback {
  public:
-  explicit MediaControlsResizeObserverCallback(MediaControls* controls)
+  explicit MediaControlsResizeObserverCallback(MediaControlsImpl* controls)
       : m_controls(controls) {
     DCHECK(controls);
   }
   ~MediaControlsResizeObserverCallback() override = default;
 
   void handleEvent(const HeapVector<Member<ResizeObserverEntry>>& entries,
                    ResizeObserver* observer) override {
     DCHECK_EQ(1u, entries.size());
-    DCHECK_EQ(entries[0]->target(), m_controls->m_mediaElement);
+    DCHECK_EQ(entries[0]->target(), m_controls->mediaElement());
     m_controls->notifyElementSizeChanged(entries[0]->contentRect());
   }
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_controls);
     ResizeObserverCallback::trace(visitor);
   }
 
  private:
-  Member<MediaControls> m_controls;
+  Member<MediaControlsImpl> m_controls;
 };
 
-MediaControls::MediaControls(HTMLMediaElement& mediaElement)
+MediaControls* MediaControlsImpl::Factory::create(
+    HTMLMediaElement& mediaElement,
+    ShadowRoot& shadowRoot) {
+  return MediaControlsImpl::create(mediaElement, shadowRoot);
+}
+
+MediaControlsImpl::MediaControlsImpl(HTMLMediaElement& mediaElement)
     : HTMLDivElement(mediaElement.document()),
-      m_mediaElement(&mediaElement),
+      MediaControls(mediaElement),
       m_overlayEnclosure(nullptr),
       m_overlayPlayButton(nullptr),
       m_overlayCastButton(nullptr),
       m_enclosure(nullptr),
       m_panel(nullptr),
       m_playButton(nullptr),
       m_timeline(nullptr),
       m_currentTimeDisplay(nullptr),
       m_durationDisplay(nullptr),
       m_muteButton(nullptr),
       m_volumeSlider(nullptr),
       m_toggleClosedCaptionsButton(nullptr),
       m_textTrackList(nullptr),
       m_overflowList(nullptr),
       m_castButton(nullptr),
       m_fullscreenButton(nullptr),
       m_downloadButton(nullptr),
       m_mediaEventListener(new MediaControlsMediaEventListener(this)),
       m_windowEventListener(MediaControlsWindowEventListener::create(
           this,
-          WTF::bind(&MediaControls::hideAllMenus, wrapWeakPersistent(this)))),
+          WTF::bind(&MediaControlsImpl::hideAllMenus,
+                    wrapWeakPersistent(this)))),
       m_orientationLockDelegate(nullptr),
       m_hideMediaControlsTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer,
                                                      &mediaElement.document()),
                                this,
-                               &MediaControls::hideMediaControlsTimerFired),
+                               &MediaControlsImpl::hideMediaControlsTimerFired),
       m_hideTimerBehaviorFlags(IgnoreNone),
       m_isMouseOverControls(false),
       m_isPausedForScrubbing(false),
       m_resizeObserver(ResizeObserver::create(
           mediaElement.document(),
           new MediaControlsResizeObserverCallback(this))),
-      m_elementSizeChangedTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer,
-                                                      &mediaElement.document()),
-                                this,
-                                &MediaControls::elementSizeChangedTimerFired),
+      m_elementSizeChangedTimer(
+          TaskRunnerHelper::get(TaskType::UnspecedTimer,
+                                &mediaElement.document()),
+          this,
+          &MediaControlsImpl::elementSizeChangedTimerFired),
       m_keepShowingUntilTimerFires(false) {
-  m_resizeObserver->observe(m_mediaElement);
+  m_resizeObserver->observe(&mediaElement);
 }
 
-MediaControls* MediaControls::create(HTMLMediaElement& mediaElement,
-                                     ShadowRoot& shadowRoot) {
-  MediaControls* controls = new MediaControls(mediaElement);
+MediaControlsImpl* MediaControlsImpl::create(HTMLMediaElement& mediaElement,
+                                             ShadowRoot& shadowRoot) {
+  MediaControlsImpl* controls = new MediaControlsImpl(mediaElement);
   controls->setShadowPseudoId(AtomicString("-webkit-media-controls"));
   controls->initializeControls();
   controls->reset();
 
   // Initialize the orientation lock when going fullscreen feature.
   if (RuntimeEnabledFeatures::videoFullscreenOrientationLockEnabled() &&
       mediaElement.isHTMLVideoElement()) {
     controls->m_orientationLockDelegate =
         new MediaControlsOrientationLockDelegate(
             toHTMLVideoElement(mediaElement));
   }
 
   shadowRoot.appendChild(controls);
   return controls;
 }
 
 // The media controls DOM structure looks like:
 //
-// MediaControls
+// MediaControlsImpl
 //     (-webkit-media-controls)
 // +-MediaControlOverlayEnclosureElement
 // |    (-webkit-media-controls-overlay-enclosure)
 // | +-MediaControlOverlayPlayButtonElement
 // | |    (-webkit-media-controls-overlay-play-button)
 // | | {if mediaControlsOverlayPlayButtonEnabled}
 // | \-MediaControlCastButtonElement
 // |     (-internal-media-controls-overlay-cast-button)
 // \-MediaControlPanelEnclosureElement
 //   |    (-webkit-media-controls-enclosure)
@@ skipping 23 matching lines @@
 // |    (-internal-media-controls-text-track-list)
 // | {for each renderable text track}
 //  \-MediaControlTextTrackListItem
 //  |   (-internal-media-controls-text-track-list-item)
 //  +-MediaControlTextTrackListItemInput
 //  |    (-internal-media-controls-text-track-list-item-input)
 //  +-MediaControlTextTrackListItemCaptions
 //  |    (-internal-media-controls-text-track-list-kind-captions)
 //  +-MediaControlTextTrackListItemSubtitles
 //       (-internal-media-controls-text-track-list-kind-subtitles)
-void MediaControls::initializeControls() {
+void MediaControlsImpl::initializeControls() {
   MediaControlOverlayEnclosureElement* overlayEnclosure =
       MediaControlOverlayEnclosureElement::create(*this);
 
   if (RuntimeEnabledFeatures::mediaControlsOverlayPlayButtonEnabled()) {
     MediaControlOverlayPlayButtonElement* overlayPlayButton =
         MediaControlOverlayPlayButtonElement::create(*this);
     m_overlayPlayButton = overlayPlayButton;
     overlayEnclosure->appendChild(overlayPlayButton);
   }
 
@@ skipping 98 matching lines @@
       *this, MediaControlDownloadButtonElement::create(*this)));
   m_overflowList->appendChild(m_muteButton->createOverflowElement(
       *this, MediaControlMuteButtonElement::create(*this)));
   m_overflowList->appendChild(m_castButton->createOverflowElement(
       *this, MediaControlCastButtonElement::create(*this, false)));
   m_overflowList->appendChild(
       m_toggleClosedCaptionsButton->createOverflowElement(
           *this, MediaControlToggleClosedCaptionsButtonElement::create(*this)));
 }
 
-Node::InsertionNotificationRequest MediaControls::insertedInto(
+Node::InsertionNotificationRequest MediaControlsImpl::insertedInto(
     ContainerNode* root) {
   if (!mediaElement().isConnected())
     return HTMLDivElement::insertedInto(root);
 
   // TODO(mlamouri): we should show the controls instead of having
   // HTMLMediaElement do it.
 
   // m_windowEventListener doesn't need to be re-attached as it's only needed
   // when a menu is visible.
   m_mediaEventListener->attach();
   if (m_orientationLockDelegate)
     m_orientationLockDelegate->attach();
 
   if (!m_resizeObserver) {
     m_resizeObserver =
-        ResizeObserver::create(m_mediaElement->document(),
+        ResizeObserver::create(mediaElement().document(),
                                new MediaControlsResizeObserverCallback(this));
-    m_resizeObserver->observe(m_mediaElement);
+    HTMLMediaElement& htmlMediaElement = mediaElement();
+    m_resizeObserver->observe(&htmlMediaElement);
   }
 
   return HTMLDivElement::insertedInto(root);
 }
 
-void MediaControls::removedFrom(ContainerNode*) {
+void MediaControlsImpl::removedFrom(ContainerNode*) {
   DCHECK(!mediaElement().isConnected());
 
   // TODO(mlamouri): we hide show the controls instead of having
   // HTMLMediaElement do it.
 
   m_windowEventListener->stop();
   m_mediaEventListener->detach();
   if (m_orientationLockDelegate)
     m_orientationLockDelegate->detach();
 
   m_resizeObserver.clear();
 }
 
-void MediaControls::reset() {
+void MediaControlsImpl::reset() {
   EventDispatchForbiddenScope::AllowUserAgentEvents allowEventsInShadow;
   BatchedControlUpdate batch(this);
 
   const double duration = mediaElement().duration();
   m_durationDisplay->setTextContent(
       LayoutTheme::theme().formatMediaControlsTime(duration));
   m_durationDisplay->setCurrentValue(duration);
 
   // Show everything that we might hide.
   // If we don't have a duration, then mark it to be hidden.  For the
@@ skipping 13 matching lines @@
 
   m_timeline->setDuration(duration);
   m_timeline->setPosition(mediaElement().currentTime());
 
   onVolumeChange();
   onTextTracksAddedOrRemoved();
 
   onControlsListUpdated();
 }
 
-void MediaControls::onControlsListUpdated() {
+void MediaControlsImpl::onControlsListUpdated() {
   BatchedControlUpdate batch(this);
 
   m_fullscreenButton->setIsWanted(shouldShowFullscreenButton(mediaElement()));
 
   refreshCastButtonVisibilityWithoutUpdate();
 
   m_downloadButton->setIsWanted(
       m_downloadButton->shouldDisplayDownloadButton());
 }
 
-LayoutObject* MediaControls::layoutObjectForTextTrackLayout() {
+LayoutObject* MediaControlsImpl::panelLayoutObject() {
   return m_panel->layoutObject();
 }
 
-void MediaControls::show() {
+LayoutObject* MediaControlsImpl::containerLayoutObject() {
+  return layoutObject();
+}
+
+void MediaControlsImpl::show() {
   makeOpaque();
   m_panel->setIsWanted(true);
   m_panel->setIsDisplayed(true);
   if (m_overlayPlayButton)
     m_overlayPlayButton->updateDisplayType();
 }
 
-void MediaControls::hide() {
+void MediaControlsImpl::hide() {
   m_panel->setIsWanted(false);
   m_panel->setIsDisplayed(false);
   if (m_overlayPlayButton)
     m_overlayPlayButton->setIsWanted(false);
 }
 
-bool MediaControls::isVisible() const {
+bool MediaControlsImpl::isVisible() const {
   return m_panel->isOpaque();
 }
 
-void MediaControls::makeOpaque() {
+void MediaControlsImpl::makeOpaque() {
   m_panel->makeOpaque();
 }
 
-void MediaControls::makeTransparent() {
+void MediaControlsImpl::makeTransparent() {
   m_panel->makeTransparent();
 }
 
-bool MediaControls::shouldHideMediaControls(unsigned behaviorFlags) const {
+bool MediaControlsImpl::shouldHideMediaControls(unsigned behaviorFlags) const {
   // Never hide for a media element without visual representation.
   if (!mediaElement().isHTMLVideoElement() || !mediaElement().hasVideo() ||
       mediaElement().isPlayingRemotely()) {
     return false;
   }
 
   // Keep the controls visible as long as the timer is running.
   const bool ignoreWaitForTimer = behaviorFlags & IgnoreWaitForTimer;
   if (!ignoreWaitForTimer && m_keepShowingUntilTimerFires)
     return false;
@@ skipping 17 matching lines @@
     return false;
   }
 
   // Don't hide the media controls when a panel is showing.
   if (m_textTrackList->isWanted() || m_overflowList->isWanted())
     return false;
 
   return true;
 }
 
-void MediaControls::updatePlayState() {
+void MediaControlsImpl::updatePlayState() {
   if (m_isPausedForScrubbing)
     return;
 
   if (m_overlayPlayButton)
     m_overlayPlayButton->updateDisplayType();
   m_playButton->updateDisplayType();
 }
 
-void MediaControls::beginScrubbing() {
+void MediaControlsImpl::beginScrubbing() {
   if (!mediaElement().paused()) {
     m_isPausedForScrubbing = true;
     mediaElement().pause();
   }
 }
 
-void MediaControls::endScrubbing() {
+void MediaControlsImpl::endScrubbing() {
   if (m_isPausedForScrubbing) {
     m_isPausedForScrubbing = false;
     if (mediaElement().paused())
       mediaElement().play();
   }
 }
 
-void MediaControls::updateCurrentTimeDisplay() {
+void MediaControlsImpl::updateCurrentTimeDisplay() {
   double now = mediaElement().currentTime();
   double duration = mediaElement().duration();
 
   // Allow the theme to format the time.
   m_currentTimeDisplay->setInnerText(
       LayoutTheme::theme().formatMediaControlsCurrentTime(now, duration),
       IGNORE_EXCEPTION_FOR_TESTING);
   m_currentTimeDisplay->setCurrentValue(now);
 }
 
-void MediaControls::toggleTextTrackList() {
+void MediaControlsImpl::toggleTextTrackList() {
   if (!mediaElement().hasClosedCaptions()) {
     m_textTrackList->setVisible(false);
     return;
   }
 
   if (!m_textTrackList->isWanted())
     m_windowEventListener->start();
 
   m_textTrackList->setVisible(!m_textTrackList->isWanted());
 }
 
-void MediaControls::showTextTrackAtIndex(unsigned indexToEnable) {
+void MediaControlsImpl::showTextTrackAtIndex(unsigned indexToEnable) {
   TextTrackList* trackList = mediaElement().textTracks();
   if (indexToEnable >= trackList->length())
     return;
   TextTrack* track = trackList->anonymousIndexedGetter(indexToEnable);
   if (track && track->canBeRendered())
     track->setMode(TextTrack::showingKeyword());
 }
 
-void MediaControls::disableShowingTextTracks() {
+void MediaControlsImpl::disableShowingTextTracks() {
   TextTrackList* trackList = mediaElement().textTracks();
   for (unsigned i = 0; i < trackList->length(); ++i) {
     TextTrack* track = trackList->anonymousIndexedGetter(i);
     if (track->mode() == TextTrack::showingKeyword())
       track->setMode(TextTrack::disabledKeyword());
   }
 }
 
-void MediaControls::refreshCastButtonVisibility() {
+void MediaControlsImpl::refreshCastButtonVisibility() {
   refreshCastButtonVisibilityWithoutUpdate();
   BatchedControlUpdate batch(this);
 }
 
-void MediaControls::refreshCastButtonVisibilityWithoutUpdate() {
+void MediaControlsImpl::refreshCastButtonVisibilityWithoutUpdate() {
   if (!shouldShowCastButton(mediaElement())) {
     m_castButton->setIsWanted(false);
     m_overlayCastButton->setIsWanted(false);
     return;
   }
 
   // The reason for the autoplay test is that some pages (e.g. vimeo.com) have
   // an autoplay background video, which doesn't autoplay on Chrome for Android
   // (we prevent it) so starts paused. In such cases we don't want to
   // automatically show the cast button, since it looks strange and is unlikely
@@ skipping 11 matching lines @@
     // is shown, however, compute...() will take control of the
     // overlay cast button if it needs to hide it from the panel.
     m_overlayCastButton->tryShowOverlay();
     m_castButton->setIsWanted(false);
   } else if (mediaElement().shouldShowControls()) {
     m_overlayCastButton->setIsWanted(false);
     m_castButton->setIsWanted(true);
   }
 }
 
-void MediaControls::showOverlayCastButtonIfNeeded() {
+void MediaControlsImpl::showOverlayCastButtonIfNeeded() {
   if (mediaElement().shouldShowControls() ||
       !shouldShowCastButton(mediaElement()))
     return;
 
   m_overlayCastButton->tryShowOverlay();
   resetHideMediaControlsTimer();
 }
 
-void MediaControls::enterFullscreen() {
+void MediaControlsImpl::enterFullscreen() {
   Fullscreen::requestFullscreen(mediaElement());
 }
 
-void MediaControls::exitFullscreen() {
+void MediaControlsImpl::exitFullscreen() {
   Fullscreen::exitFullscreen(document());
 }
 
-void MediaControls::startedCasting() {
+void MediaControlsImpl::startedCasting() {
   m_castButton->setIsPlayingRemotely(true);
   m_overlayCastButton->setIsPlayingRemotely(true);
 }
 
-void MediaControls::stoppedCasting() {
+void MediaControlsImpl::stoppedCasting() {
   m_castButton->setIsPlayingRemotely(false);
   m_overlayCastButton->setIsPlayingRemotely(false);
 }
 
-void MediaControls::defaultEventHandler(Event* event) {
+void MediaControlsImpl::defaultEventHandler(Event* event) {
   HTMLDivElement::defaultEventHandler(event);
 
   // Do not handle events to not interfere with the rest of the page if no
   // controls should be visible.
   if (!mediaElement().shouldShowControls())
     return;
 
   // Add IgnoreControlsHover to m_hideTimerBehaviorFlags when we see a touch
   // event, to allow the hide-timer to do the right thing when it fires.
   // FIXME: Preferably we would only do this when we're actually handling the
@@ skipping 51 matching lines @@
   if (event->type() == EventTypeNames::mousemove) {
     // When we get a mouse move, show the media controls, and start a timer
     // that will hide the media controls after a 3 seconds without a mouse move.
     makeOpaque();
     if (shouldHideMediaControls(IgnoreVideoHover))
       startHideMediaControlsTimer();
     return;
   }
 }
 
-void MediaControls::hideMediaControlsTimerFired(TimerBase*) {
+void MediaControlsImpl::hideMediaControlsTimerFired(TimerBase*) {
   unsigned behaviorFlags =
       m_hideTimerBehaviorFlags | IgnoreFocus | IgnoreVideoHover;
   m_hideTimerBehaviorFlags = IgnoreNone;
   m_keepShowingUntilTimerFires = false;
 
   if (mediaElement().paused())
     return;
 
   if (!shouldHideMediaControls(behaviorFlags))
     return;
 
   makeTransparent();
   m_overlayCastButton->setIsWanted(false);
 }
 
-void MediaControls::startHideMediaControlsTimer() {
+void MediaControlsImpl::startHideMediaControlsTimer() {
   m_hideMediaControlsTimer.startOneShot(
       timeWithoutMouseMovementBeforeHidingMediaControls, BLINK_FROM_HERE);
 }
 
-void MediaControls::stopHideMediaControlsTimer() {
+void MediaControlsImpl::stopHideMediaControlsTimer() {
   m_keepShowingUntilTimerFires = false;
   m_hideMediaControlsTimer.stop();
 }
 
-void MediaControls::resetHideMediaControlsTimer() {
+void MediaControlsImpl::resetHideMediaControlsTimer() {
   stopHideMediaControlsTimer();
   if (!mediaElement().paused())
     startHideMediaControlsTimer();
 }
 
-bool MediaControls::containsRelatedTarget(Event* event) {
+bool MediaControlsImpl::containsRelatedTarget(Event* event) {
   if (!event->isMouseEvent())
     return false;
   EventTarget* relatedTarget = toMouseEvent(event)->relatedTarget();
   if (!relatedTarget)
     return false;
   return contains(relatedTarget->toNode());
 }
 
-void MediaControls::onVolumeChange() {
+void MediaControlsImpl::onVolumeChange() {
   m_muteButton->updateDisplayType();
   m_volumeSlider->setVolume(mediaElement().muted() ? 0
                                                    : mediaElement().volume());
 
   // Update visibility of volume controls.
   // TODO(mlamouri): it should not be part of the volumechange handling because
   // it is using audio availability as input.
   BatchedControlUpdate batch(this);
   m_volumeSlider->setIsWanted(mediaElement().hasAudio() &&
                               !preferHiddenVolumeControls(document()));
   m_muteButton->setIsWanted(mediaElement().hasAudio());
 }
 
-void MediaControls::onFocusIn() {
+void MediaControlsImpl::onFocusIn() {
   if (!mediaElement().shouldShowControls())
     return;
 
   show();
   resetHideMediaControlsTimer();
 }
 
-void MediaControls::onTimeUpdate() {
+void MediaControlsImpl::onTimeUpdate() {
   m_timeline->setPosition(mediaElement().currentTime());
   updateCurrentTimeDisplay();
 
   // 'timeupdate' might be called in a paused state. The controls should not
   // become transparent in that case.
   if (mediaElement().paused()) {
     makeOpaque();
     return;
   }
 
   if (isVisible() && shouldHideMediaControls())
     makeTransparent();
 }
 
-void MediaControls::onDurationChange() {
+void MediaControlsImpl::onDurationChange() {
   const double duration = mediaElement().duration();
 
   // Update the displayed current time/duration.
   m_durationDisplay->setTextContent(
       LayoutTheme::theme().formatMediaControlsTime(duration));
   m_durationDisplay->setCurrentValue(duration);
   updateCurrentTimeDisplay();
 
   // Update the timeline (the UI with the seek marker).
   m_timeline->setDuration(duration);
 }
 
-void MediaControls::onPlay() {
+void MediaControlsImpl::onPlay() {
   updatePlayState();
   m_timeline->setPosition(mediaElement().currentTime());
   updateCurrentTimeDisplay();
 
   startHideMediaControlsTimer();
 }
 
-void MediaControls::onPause() {
+void MediaControlsImpl::onPause() {
   updatePlayState();
   m_timeline->setPosition(mediaElement().currentTime());
   updateCurrentTimeDisplay();
   makeOpaque();
 
   stopHideMediaControlsTimer();
 }
 
-void MediaControls::onTextTracksAddedOrRemoved() {
+void MediaControlsImpl::onTextTracksAddedOrRemoved() {
   m_toggleClosedCaptionsButton->setIsWanted(mediaElement().hasClosedCaptions());
   BatchedControlUpdate batch(this);
 }
 
-void MediaControls::onTextTracksChanged() {
+void MediaControlsImpl::onTextTracksChanged() {
   m_toggleClosedCaptionsButton->updateDisplayType();
 }
 
-void MediaControls::onError() {
+void MediaControlsImpl::onError() {
   // TODO(mlamouri): we should only change the aspects of the control that need
   // to be changed.
   reset();
 }
 
-void MediaControls::onLoadedMetadata() {
+void MediaControlsImpl::onLoadedMetadata() {
   // TODO(mlamouri): we should only change the aspects of the control that need
   // to be changed.
   reset();
 }
 
-void MediaControls::onEnteredFullscreen() {
+void MediaControlsImpl::onEnteredFullscreen() {
   m_fullscreenButton->setIsFullscreen(true);
   stopHideMediaControlsTimer();
   startHideMediaControlsTimer();
 }
 
-void MediaControls::onExitedFullscreen() {
+void MediaControlsImpl::onExitedFullscreen() {
   m_fullscreenButton->setIsFullscreen(false);
   stopHideMediaControlsTimer();
   startHideMediaControlsTimer();
 }
 
-void MediaControls::notifyElementSizeChanged(ClientRect* newSize) {
+void MediaControlsImpl::notifyElementSizeChanged(ClientRect* newSize) {
   // Note that this code permits a bad frame on resize, since it is
   // run after the relayout / paint happens.  It would be great to improve
   // this, but it would be even greater to move this code entirely to
   // JS and fix it there.
 
   IntSize oldSize = m_size;
   m_size.setWidth(newSize->width());
   m_size.setHeight(newSize->height());
 
   // Adjust for effective zoom.
   if (m_panel->layoutObject() && m_panel->layoutObject()->style()) {
     m_size.setWidth(ceil(m_size.width() /
                          m_panel->layoutObject()->style()->effectiveZoom()));
     m_size.setHeight(ceil(m_size.height() /
                           m_panel->layoutObject()->style()->effectiveZoom()));
   }
 
   // Don't bother to do any work if this matches the most recent size.
   if (oldSize != m_size)
     m_elementSizeChangedTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
-void MediaControls::elementSizeChangedTimerFired(TimerBase*) {
+void MediaControlsImpl::elementSizeChangedTimerFired(TimerBase*) {
   computeWhichControlsFit();
 }
 
-void MediaControls::computeWhichControlsFit() {
+void MediaControlsImpl::computeWhichControlsFit() {
   // Hide all controls that don't fit, and show the ones that do.
   // This might be better suited for a layout, but since JS media controls
   // won't benefit from that anwyay, we just do it here like JS will.
 
   // Controls that we'll hide / show, in order of decreasing priority.
   MediaControlElement* elements[] = {
       // Exclude m_overflowMenu; we handle it specially.
       m_playButton.get(),
       m_fullscreenButton.get(),
       m_downloadButton.get(),
@@ skipping 92 matching lines @@
   }
 
   // Decide if the overlay play button fits.
   if (m_overlayPlayButton) {
     bool doesFit = m_size.width() >= kMinWidthForOverlayPlayButton &&
                    m_size.height() >= kMinHeightForOverlayPlayButton;
     m_overlayPlayButton->setDoesFit(doesFit);
   }
 }
 
-void MediaControls::invalidate(Element* element) {
+void MediaControlsImpl::invalidate(Element* element) {
   if (!element)
     return;
 
-  if (LayoutObject* layoutObject = element->layoutObject())
+  if (LayoutObject* layoutObject = element->layoutObject()) {
     layoutObject
         ->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
+  }
 }
 
-void MediaControls::networkStateChanged() {
+void MediaControlsImpl::networkStateChanged() {
   invalidate(m_playButton);
   invalidate(m_overlayPlayButton);
   invalidate(m_muteButton);
   invalidate(m_fullscreenButton);
   invalidate(m_downloadButton);
   invalidate(m_timeline);
   invalidate(m_volumeSlider);
 
   // Update the display state of the download button in case we now have a
   // source or no longer have a source.
   m_downloadButton->setIsWanted(
       m_downloadButton->shouldDisplayDownloadButton());
 }
 
-bool MediaControls::overflowMenuVisible() {
+bool MediaControlsImpl::overflowMenuVisible() {
   return m_overflowList ? m_overflowList->isWanted() : false;
 }
 
-void MediaControls::toggleOverflowMenu() {
+void MediaControlsImpl::toggleOverflowMenu() {
   DCHECK(m_overflowList);
 
   if (!m_overflowList->isWanted())
     m_windowEventListener->start();
   m_overflowList->setIsWanted(!m_overflowList->isWanted());
 }
 
-void MediaControls::hideAllMenus() {
+void MediaControlsImpl::hideAllMenus() {
   m_windowEventListener->stop();
 
   if (m_overflowList->isWanted())
     m_overflowList->setIsWanted(false);
   if (m_textTrackList->isWanted())
     m_textTrackList->setVisible(false);
 }
 
-DEFINE_TRACE(MediaControls) {
+DEFINE_TRACE(MediaControlsImpl) {
   visitor->trace(m_resizeObserver);
-  visitor->trace(m_mediaElement);
   visitor->trace(m_panel);
   visitor->trace(m_overlayPlayButton);
   visitor->trace(m_overlayEnclosure);
   visitor->trace(m_playButton);
   visitor->trace(m_currentTimeDisplay);
   visitor->trace(m_timeline);
   visitor->trace(m_muteButton);
   visitor->trace(m_volumeSlider);
   visitor->trace(m_toggleClosedCaptionsButton);
   visitor->trace(m_fullscreenButton);
   visitor->trace(m_downloadButton);
   visitor->trace(m_durationDisplay);
   visitor->trace(m_enclosure);
   visitor->trace(m_textTrackList);
   visitor->trace(m_overflowMenu);
   visitor->trace(m_overflowList);
   visitor->trace(m_castButton);
   visitor->trace(m_overlayCastButton);
   visitor->trace(m_mediaEventListener);
   visitor->trace(m_windowEventListener);
   visitor->trace(m_orientationLockDelegate);
+  MediaControls::trace(visitor);
   HTMLDivElement::trace(visitor);
 }
 
 }  // namespace blink