Remove MediaController (already diabled by REF)

third_party/WebKit/Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple 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
@@ skipping 27 matching lines @@
 #include "core/dom/Fullscreen.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLMediaSource.h"
 #include "core/html/HTMLSourceElement.h"
 #include "core/html/HTMLTrackElement.h"
-#include "core/html/MediaController.h"
 #include "core/html/MediaError.h"
 #include "core/html/MediaFragmentURIParser.h"
 #include "core/html/TimeRanges.h"
 #include "core/html/shadow/MediaControls.h"
 #include "core/html/track/AudioTrack.h"
 #include "core/html/track/AudioTrackList.h"
 #include "core/html/track/AutomaticTrackSelection.h"
 #include "core/html/track/CueTimeline.h"
 #include "core/html/track/InbandTextTrack.h"
 #include "core/html/track/TextTrackContainer.h"
@@ skipping 313 matching lines @@
     // the same GC. We don't need to close it explicitly in Oilpan.
     m_asyncEventQueue->close();
 
     setShouldDelayLoadEvent(false);
 
     if (m_textTracks)
         m_textTracks->clearOwner();
     m_audioTracks->shutdown();
     m_videoTracks->shutdown();
 
-    if (m_mediaController) {
-        m_mediaController->removeMediaElement(this);
-        m_mediaController = nullptr;
-    }
     closeMediaSource();
 
     removeElementFromDocumentMap(this, &document());
 
     // Destroying the player may cause a resource load to be canceled,
     // which could result in userCancelledLoad() being called back.
     // Setting m_isFinalizing ensures that such a call will not cause
     // us to dispatch an abort event, which would result in a crash.
     // See http://crbug.com/233654 for more details.
     m_isFinalizing = true;
@@ skipping 114 matching lines @@
     if (name == srcAttr) {
         // Trigger a reload, as long as the 'src' attribute is present.
         if (!value.isNull()) {
             clearMediaPlayer(LoadMediaResource);
             scheduleDelayedAction(LoadMediaResource);
         }
     } else if (name == controlsAttr) {
         configureMediaControls();
     } else if (name == preloadAttr) {
         setPlayerPreload();
-    } else if (name == mediagroupAttr && RuntimeEnabledFeatures::mediaControllerEnabled()) {
-        setMediaGroup(value);
     } else {
         HTMLElement::parseAttribute(name, value);
     }
 }
 
 void HTMLMediaElement::finishParsingChildren()
 {
     HTMLElement::finishParsingChildren();
 
     if (Traversal<HTMLTrackElement>::firstChild(*this))
@@ skipping 248 matching lines @@
         //       If this changed the official playback position, then queue a task to fire a simple event named timeupdate at the media element.
         // FIXME: Add support for firing this event.
 
         // 4.8 - Set the initial playback position to 0.
         // FIXME: Make this less subtle. The position only becomes 0 because the ready state is HAVE_NOTHING.
         invalidateCachedTime();
 
         // 4.9 - Set the timeline offset to Not-a-Number (NaN).
         // 4.10 - Update the duration attribute to Not-a-Number (NaN).
 
-
-        updateMediaController();
         cueTimeline().updateActiveCues(0);
     }
 
     // 5 - Set the playbackRate attribute to the value of the defaultPlaybackRate attribute.
     setPlaybackRate(defaultPlaybackRate());
 
     // 6 - Set the error attribute to null and the autoplaying flag to true.
     m_error = nullptr;
     m_autoplaying = true;
 
@@ skipping 714 matching lines @@
         if (std::isnan(initialPlaybackPosition))
             initialPlaybackPosition = 0;
 
         if (!jumped && initialPlaybackPosition > 0) {
             m_sentEndEvent = false;
             UseCounter::count(document(), UseCounter::HTMLMediaElementSeekToFragmentStart);
             seek(initialPlaybackPosition);
             jumped = true;
         }
 
-        if (m_mediaController) {
-            if (jumped && initialPlaybackPosition > m_mediaController->currentTime())
-                m_mediaController->setCurrentTime(initialPlaybackPosition);
-            else
-                seek(m_mediaController->currentTime());
-        }
-
         if (mediaControls())
             mediaControls()->reset();
         if (layoutObject())
             layoutObject()->updateFromElement();
     }
 
     bool shouldUpdateDisplayState = false;
 
     if (m_readyState >= HAVE_CURRENT_DATA && oldState < HAVE_CURRENT_DATA && !m_haveFiredLoadedData) {
         m_haveFiredLoadedData = true;
@@ skipping 36 matching lines @@
         shouldUpdateDisplayState = true;
     }
 
     if (shouldUpdateDisplayState) {
         updateDisplayState();
         if (mediaControls())
             mediaControls()->refreshClosedCaptionsButtonVisibility();
     }
 
     updatePlayState();
-    updateMediaController();
     cueTimeline().updateActiveCues(currentTime());
 }
 
 void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)
 {
     if (m_networkState != NETWORK_LOADING)
         return;
 
     double time = WTF::currentTime();
     double timedelta = time - m_previousProgressTime;
@@ skipping 176 matching lines @@
             WTF_LOG(Media, "HTMLMediaElement::currentTime(%p) - WARNING, cached time is %f seconds off of media time when paused", this, delta);
 #endif
         return m_cachedTime;
     }
 
     refreshCachedTime();
 
     return m_cachedTime;
 }
 
-void HTMLMediaElement::setCurrentTime(double time, ExceptionState& exceptionState)
+void HTMLMediaElement::setCurrentTime(double time)
 {
-    if (m_mediaController) {
-        exceptionState.throwDOMException(InvalidStateError, "The element is slaved to a MediaController.");
-        return;
-    }
-
     // If the media element's readyState is HAVE_NOTHING, then set the default
     // playback start position to that time.
     if (m_readyState == HAVE_NOTHING) {
         m_defaultPlaybackStartPosition = time;
         return;
     }
 
     seek(time);
 }
 
@@ skipping 51 matching lines @@
 
     if (m_playbackRate != rate) {
         m_playbackRate = rate;
         invalidateCachedTime();
         scheduleEvent(EventTypeNames::ratechange);
     }
 
     updatePlaybackRate();
 }
 
-double HTMLMediaElement::effectivePlaybackRate() const
-{
-    return m_mediaController ? m_mediaController->playbackRate() : m_playbackRate;
-}
-
 HTMLMediaElement::DirectionOfPlayback HTMLMediaElement::directionOfPlayback() const
 {
     return m_playbackRate >= 0 ? Forward : Backward;
 }
 
 void HTMLMediaElement::updatePlaybackRate()
 {
-    double effectiveRate = effectivePlaybackRate();
     // FIXME: remove m_webMediaPlayer check once we figure out how
     // m_webMediaPlayer is going out of sync with readystate.
     // m_webMediaPlayer is cleared but readystate is not set to HAVE_NOTHING.
     if (m_webMediaPlayer && potentiallyPlaying())
-        webMediaPlayer()->setRate(effectiveRate);
+        webMediaPlayer()->setRate(playbackRate());
 }
 
 bool HTMLMediaElement::ended() const
 {
     // 4.8.10.8 Playing the media resource
     // The ended attribute must return true if the media element has ended
     // playback and the direction of playback is forwards, and false otherwise.
     return endedPlayback() && directionOfPlayback() == Forward;
 }
 
@@ skipping 106 matching lines @@
     // 4.8.10.9. Playing the media resource
     if (m_networkState == NETWORK_EMPTY)
         scheduleDelayedAction(LoadMediaResource);
 
     // Generally "ended" and "looping" are exclusive. Here, the loop attribute
     // is ignored to seek back to start in case loop was set after playback
     // ended. See http://crbug.com/364442
     if (endedPlayback(LoopCondition::Ignored))
         seek(0);
 
-    if (m_mediaController)
-        m_mediaController->bringElementUpToSpeed(this);
-
     if (m_paused) {
         m_paused = false;
         invalidateCachedTime();
         scheduleEvent(EventTypeNames::play);
 
         if (m_readyState <= HAVE_CURRENT_DATA)
             scheduleEvent(EventTypeNames::waiting);
         else if (m_readyState >= HAVE_FUTURE_DATA)
             scheduleEvent(EventTypeNames::playing);
     }
     m_autoplaying = false;
 
     updatePlayState();
-    updateMediaController();
 }
 
 void HTMLMediaElement::autoplayMediaEncountered()
 {
     if (!m_autoplayMediaCounted) {
         m_autoplayMediaCounted = true;
         recordAutoplayMetric(AutoplayMediaFound);
 
         if (!m_userGestureRequiredForPlay)
             m_initialPlayWithoutUserGesture = true;
@@ skipping 128 matching lines @@
 
     if (mediaControls())
         mediaControls()->updateVolume();
 }
 
 double HTMLMediaElement::effectiveMediaVolume() const
 {
     if (m_muted)
         return 0;
 
-    if (m_mediaController && m_mediaController->muted())
-        return 0;
-
-    double volume = m_volume;
-
-    if (m_mediaController)
-        volume *= m_mediaController->volume();
-
-    return volume;
+    return m_volume;
 }
 
 // The spec says to fire periodic timeupdate events (those sent while playing) every
 // "15 to 250ms", we choose the slowest frequency
 static const double maxTimeupdateEventFrequency = 0.25;
 
 void HTMLMediaElement::startPlaybackProgressTimer()
 {
     if (m_playbackProgressTimer.isActive())
         return;
 
     m_previousProgressTime = WTF::currentTime();
     m_playbackProgressTimer.startRepeating(maxTimeupdateEventFrequency, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::playbackProgressTimerFired(Timer<HTMLMediaElement>*)
 {
     if (!std::isnan(m_fragmentEndTime) && currentTime() >= m_fragmentEndTime && directionOfPlayback() == Forward) {
         m_fragmentEndTime = std::numeric_limits<double>::quiet_NaN();
-        if (!m_mediaController && !m_paused) {
+        if (!m_paused) {
             UseCounter::count(document(), UseCounter::HTMLMediaElementPauseAtFragmentEnd);
             // changes paused to true and fires a simple event named pause at the media element.
             pause();
         }
     }
 
     if (!m_seeking)
         scheduleTimeupdateEvent(true);
 
-    if (!effectivePlaybackRate())
+    if (!playbackRate())
         return;
 
     if (!m_paused && mediaControls())
         mediaControls()->playbackProgressed();
 
     cueTimeline().updateActiveCues(currentTime());
 }
 
 void HTMLMediaElement::scheduleTimeupdateEvent(bool periodicEvent)
 {
     double now = WTF::currentTime();
     double movieTime = currentTime();
 
     bool haveNotRecentlyFiredTimeupdate = (now - m_lastTimeUpdateEventWallTime) >= maxTimeupdateEventFrequency;
     bool movieTimeHasProgressed = movieTime != m_lastTimeUpdateEventMovieTime;
 
     // Non-periodic timeupdate events must always fire as mandated by the spec,
     // otherwise we shouldn't fire duplicate periodic timeupdate events when the
     // movie time hasn't changed.
     if (!periodicEvent || (haveNotRecentlyFiredTimeupdate && movieTimeHasProgressed)) {
         scheduleEvent(EventTypeNames::timeupdate);
         m_lastTimeUpdateEventWallTime = now;
         m_lastTimeUpdateEventMovieTime = movieTime;
     }
 }
 
-bool HTMLMediaElement::togglePlayStateWillPlay() const
-{
-    if (m_mediaController)
-        return m_mediaController->paused() || m_mediaController->isRestrained();
-    return paused();
-}
-
 void HTMLMediaElement::togglePlayState()
 {
-    if (m_mediaController) {
-        if (m_mediaController->isRestrained())
-            m_mediaController->play();
-        else if (m_mediaController->paused())
-            m_mediaController->unpause();
-        else
-            m_mediaController->pause();
-    } else {
-        if (paused())
-            play();
-        else
-            pause();
-    }
+    if (paused())
+        play();
+    else
+        pause();
 }
 
 AudioTrackList& HTMLMediaElement::audioTracks()
 {
     ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
     return *m_audioTracks;
 }
 
 void HTMLMediaElement::audioTrackChanged()
 {
@@ skipping 486 matching lines @@
     // it will only queue a 'timeupdate' event if we haven't already posted one at the current
     // movie time.
     scheduleTimeupdateEvent(false);
 
     double now = currentTime();
     double dur = duration();
 
     // When the current playback position reaches the end of the media resource when the direction of
     // playback is forwards, then the user agent must follow these steps:
     if (!std::isnan(dur) && dur && now >= dur && directionOfPlayback() == Forward) {
-        // If the media element has a loop attribute specified and does not have a current media controller,
-        if (loop() && !m_mediaController) {
+        // If the media element has a loop attribute specified
+        if (loop()) {
             m_sentEndEvent = false;
             //  then seek to the earliest possible position of the media resource and abort these steps.
             seek(0);
         } else {
-            // If the media element does not have a current media controller, and the media element
-            // has still ended playback, and the direction of playback is still forwards, and paused
-            // is false,
-            if (!m_mediaController && !m_paused) {
+            // If the media element has still ended playback, and the direction of playback is still
+            // forwards, and paused is false,
+            if (!m_paused) {
                 // changes paused to true and fires a simple event named pause at the media element.
                 m_paused = true;
                 scheduleEvent(EventTypeNames::pause);
             }
             // Queue a task to fire a simple event named ended at the media element.
             if (!m_sentEndEvent) {
                 m_sentEndEvent = true;
                 scheduleEvent(EventTypeNames::ended);
             }
             recordMetricsIfPausing();
-            // If the media element has a current media controller, then report the controller state
-            // for the media element's current media controller.
-            updateMediaController();
         }
     } else {
         m_sentEndEvent = false;
     }
 
     updatePlayState();
 }
 
 void HTMLMediaElement::durationChanged()
 {
@@ skipping 35 matching lines @@
 
     if (webMediaPlayer()->paused())
         pause();
     else
         playInternal();
 }
 
 void HTMLMediaElement::requestSeek(double time)
 {
     // The player is the source of this seek request.
-    if (m_mediaController) {
-        m_mediaController->setCurrentTime(time);
-        return;
-    }
-    setCurrentTime(time, ASSERT_NO_EXCEPTION);
+    setCurrentTime(time);
 }
 
 void HTMLMediaElement::remoteRouteAvailabilityChanged(bool routesAvailable)
 {
     m_remoteRoutesAvailable = routesAvailable;
     if (mediaControls())
         mediaControls()->refreshCastButtonVisibility();
 }
 
 void HTMLMediaElement::connectedToRemoteDevice()
@@ skipping 68 matching lines @@
 
     return TimeRanges::create(webMediaPlayer()->seekable());
 }
 
 bool HTMLMediaElement::potentiallyPlaying() const
 {
     // "pausedToBuffer" means the media engine's rate is 0, but only because it had to stop playing
     // when it ran out of buffered data. A movie in this state is "potentially playing", modulo the
     // checks in couldPlayIfEnoughData().
     bool pausedToBuffer = m_readyStateMaximum >= HAVE_FUTURE_DATA && m_readyState < HAVE_FUTURE_DATA;
-    return (pausedToBuffer || m_readyState >= HAVE_FUTURE_DATA) && couldPlayIfEnoughData() && !isBlockedOnMediaController();
+    return (pausedToBuffer || m_readyState >= HAVE_FUTURE_DATA) && couldPlayIfEnoughData();
 }
 
 bool HTMLMediaElement::couldPlayIfEnoughData() const
 {
     return !paused() && !endedPlayback() && !stoppedDueToErrors();
 }
 
 bool HTMLMediaElement::endedPlayback(LoopCondition loopCondition) const
 {
     double dur = duration();
     if (std::isnan(dur))
         return false;
 
     // 4.8.10.8 Playing the media resource
 
     // A media element is said to have ended playback when the element's
     // readyState attribute is HAVE_METADATA or greater,
     if (m_readyState < HAVE_METADATA)
         return false;
 
     // and the current playback position is the end of the media resource and the direction
     // of playback is forwards, Either the media element does not have a loop attribute specified,
-    // or the media element has a current media controller.
     double now = currentTime();
     if (directionOfPlayback() == Forward)
-        return dur > 0 && now >= dur && (loopCondition == LoopCondition::Ignored || !loop() || m_mediaController);
+        return dur > 0 && now >= dur && (loopCondition == LoopCondition::Ignored || !loop());
 
     // or the current playback position is the earliest possible position and the direction
     // of playback is backwards
     ASSERT(directionOfPlayback() == Backward);
     return now <= 0;
 }
 
 bool HTMLMediaElement::stoppedDueToErrors() const
 {
     if (m_readyState >= HAVE_METADATA && m_error) {
@@ skipping 13 matching lines @@
     WTF_LOG(Media, "HTMLMediaElement::updatePlayState(%p) - shouldBePlaying = %s, isPlaying = %s",
         this, boolString(shouldBePlaying), boolString(isPlaying));
 
     if (shouldBePlaying) {
         setDisplayMode(Video);
         invalidateCachedTime();
 
         if (!isPlaying) {
             // Set rate, muted before calling play in case they were set before the media engine was setup.
             // The media engine should just stash the rate and muted values since it isn't already playing.
-            webMediaPlayer()->setRate(effectivePlaybackRate());
+            webMediaPlayer()->setRate(playbackRate());
             updateVolume();
             webMediaPlayer()->play();
         }
 
         if (mediaControls())
             mediaControls()->playbackStarted();
         startPlaybackProgressTimer();
         m_playing = true;
         recordAutoplayMetric(AnyPlaybackStarted);
 
     } else { // Should not be playing right now
         if (isPlaying)
             webMediaPlayer()->pause();
         refreshCachedTime();
 
         m_playbackProgressTimer.stop();
         m_playing = false;
         double time = currentTime();
         if (time > m_lastSeekTime)
             addPlayedRange(m_lastSeekTime, time);
 
         if (couldPlayIfEnoughData())
             prepareToPlay();
 
         if (mediaControls())
             mediaControls()->playbackStopped();
     }
 
-    updateMediaController();
-
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::stopPeriodicTimers()
 {
     m_progressEventTimer.stop();
     m_playbackProgressTimer.stop();
 }
 
@@ skipping 31 matching lines @@
         m_networkState = NETWORK_IDLE;
     }
 
     // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     // 6 - Abort the overall resource selection algorithm.
     m_currentSourceNode = nullptr;
 
     invalidateCachedTime();
-    updateMediaController();
     cueTimeline().updateActiveCues(0);
 }
 
 void HTMLMediaElement::clearMediaPlayerAndAudioSourceProviderClientWithoutLocking()
 {
 #if ENABLE(WEB_AUDIO)
     audioSourceProvider().setClient(nullptr);
 #endif
     if (m_webMediaPlayer) {
 #if ENABLE(WEB_AUDIO)
@@ skipping 83 matching lines @@
     if (m_mediaSource)
         return true;
 
     // Wait for any pending events to be fired.
     if (m_asyncEventQueue->hasPendingEvents())
         return true;
 
     return false;
 }
 
-void HTMLMediaElement::contextDestroyed()
-{
-    // With Oilpan the ExecutionContext is weakly referenced from the media
-    // controller and so it will clear itself on destruction.
-#if !ENABLE(OILPAN)
-    if (m_mediaController)
-        m_mediaController->clearExecutionContext();
-#endif
-    ActiveDOMObject::contextDestroyed();
-}
-
 bool HTMLMediaElement::isFullscreen() const
 {
     return Fullscreen::isActiveFullScreenElement(*this);
 }
 
 void HTMLMediaElement::enterFullscreen()
 {
     WTF_LOG(Media, "HTMLMediaElement::enterFullscreen(%p)", this);
 
     Fullscreen::from(document()).requestFullscreen(*this, Fullscreen::PrefixedRequest);
@@ skipping 322 matching lines @@
 void HTMLMediaElement::setAudioSourceNode(AudioSourceProviderClient* sourceNode)
 {
     ASSERT(isMainThread());
     m_audioSourceNode = sourceNode;
 
     AudioSourceProviderClientLockScope scope(*this);
     audioSourceProvider().setClient(m_audioSourceNode);
 }
 #endif
 
-const AtomicString& HTMLMediaElement::mediaGroup() const
-{
-    return fastGetAttribute(mediagroupAttr);
-}
-
-void HTMLMediaElement::setMediaGroup(const AtomicString& group)
-{
-    // When a media element is created with a mediagroup attribute, and when a media element's mediagroup
-    // attribute is set, changed, or removed, the user agent must run the following steps:
-    // 1. Let _R [this] be the media element in question.
-    // 2. Let m have no current media controller, if it currently has one.
-    setControllerInternal(nullptr);
-
-    // 3. If m's mediagroup attribute is being removed, then abort these steps.
-    if (group.isNull() || group.isEmpty())
-        return;
-
-    // 4. If there is another media element whose Document is the same as m's Document (even if one or both
-    // of these elements are not actually in the Document),
-    WeakMediaElementSet elements = documentToElementSetMap().get(&document());
-    for (const auto& element : elements) {
-        if (element == this)
-            continue;
-
-        // and which also has a mediagroup attribute, and whose mediagroup attribute has the same value as
-        // the new value of m's mediagroup attribute,
-        if (element->mediaGroup() == group) {
-            //  then let controller be that media element's current media controller.
-            setControllerInternal(element->controller());
-            return;
-        }
-    }
-
-    // Otherwise, let controller be a newly created MediaController.
-    setControllerInternal(MediaController::create(Node::executionContext()));
-}
-
-MediaController* HTMLMediaElement::controller() const
-{
-    return m_mediaController.get();
-}
-
-void HTMLMediaElement::setController(MediaController* controller)
-{
-    // 4.8.10.11.2 Media controllers: controller attribute.
-    // On setting, it must first remove the element's mediagroup attribute, if any,
-    removeAttribute(mediagroupAttr);
-    // and then set the current media controller to the given value.
-    setControllerInternal(controller);
-}
-
-void HTMLMediaElement::setControllerInternal(MediaController* controller)
-{
-    if (m_mediaController)
-        m_mediaController->removeMediaElement(this);
-
-    m_mediaController = controller;
-
-    if (m_mediaController)
-        m_mediaController->addMediaElement(this);
-}
-
-void HTMLMediaElement::updateMediaController()
-{
-    if (m_mediaController)
-        m_mediaController->reportControllerState();
-}
-
-bool HTMLMediaElement::isBlocked() const
-{
-    // A media element is a blocked media element if its readyState attribute is in the
-    // HAVE_NOTHING state, the HAVE_METADATA state, or the HAVE_CURRENT_DATA state,
-    // or if the element has paused for user interaction or paused for in-band content.
-    if (m_readyState <= HAVE_CURRENT_DATA)
-        return true;
-
-    return false;
-}
-
-bool HTMLMediaElement::isBlockedOnMediaController() const
-{
-    if (!m_mediaController)
-        return false;
-
-    // A media element is blocked on its media controller if the MediaController is a blocked
-    // media controller,
-    if (m_mediaController->isBlocked())
-        return true;
-
-    // or if its media controller position is either before the media resource's earliest possible
-    // position relative to the MediaController's timeline or after the end of the media resource
-    // relative to the MediaController's timeline.
-    double mediaControllerPosition = m_mediaController->currentTime();
-    if (mediaControllerPosition < 0 || mediaControllerPosition > duration())
-        return true;
-
-    return false;
-}
-
 void HTMLMediaElement::setAllowHiddenVolumeControls(bool allow)
 {
     ensureMediaControls();
     mediaControls()->setAllowHiddenVolumeControls(allow);
 }
 
 WebMediaPlayer::CORSMode HTMLMediaElement::corsMode() const
 {
     const AtomicString& crossOriginMode = fastGetAttribute(crossoriginAttr);
     if (crossOriginMode.isNull())
@@ skipping 49 matching lines @@
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_error);
     visitor->trace(m_currentSourceNode);
     visitor->trace(m_nextChildNodeToConsider);
     visitor->trace(m_mediaSource);
     visitor->trace(m_audioTracks);
     visitor->trace(m_videoTracks);
     visitor->trace(m_cueTimeline);
     visitor->trace(m_textTracks);
     visitor->trace(m_textTracksWhenResourceSelectionBegan);
-    visitor->trace(m_mediaController);
 #if ENABLE(WEB_AUDIO)
     visitor->trace(m_audioSourceProvider);
     visitor->template registerWeakMembers<HTMLMediaElement, &HTMLMediaElement::clearWeakMembers>(this);
 #endif
     HeapSupplementable<HTMLMediaElement>::trace(visitor);
 #endif
     HTMLElement::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
@@ skipping 102 matching lines @@
     visitor->trace(m_client);
 }
 
 DEFINE_TRACE(HTMLMediaElement::AudioSourceProviderImpl)
 {
     visitor->trace(m_client);
 }
 #endif
 
 }