Changeset 183509 in webkit


Ignore:
Timestamp:
Apr 28, 2015, 2:40:10 PM (10 years ago)
Author:
eric.carlson@apple.com
Message:

[Mac] Simplify code to support media engines which do not support target playback
​https://bugs.webkit.org/show_bug.cgi?id=144332

Reviewed by Jer Noble.

  • Modules/mediasession/WebMediaSessionManager.cpp:

(WebCore::WebMediaSessionManager::externalOutputDeviceAvailableDidChange): Always make client
callback, let them decide if it is significant or not.

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::HTMLMediaElement): m_loadTimer -> m_pendingActionTimer.
(WebCore::HTMLMediaElement::scheduleDelayedAction): Handle CheckPlaybackTargetCompatablity.
(WebCore::HTMLMediaElement::scheduleNextSourceChild): m_loadTimer -> m_pendingActionTimer.
(WebCore::HTMLMediaElement::loadTimerFired): Renamed pendingActionTimerFired.
(WebCore::HTMLMediaElement::prepareForLoad): m_loadTimer -> m_pendingActionTimer.
(WebCore::HTMLMediaElement::setDefaultPlaybackRate): Add logging.
(WebCore::HTMLMediaElement::clearMediaPlayer): m_loadTimer -> m_pendingActionTimer.
(WebCore::HTMLMediaElement::webkitCurrentPlaybackTargetIsSupported): Removed.
(WebCore::HTMLMediaElement::dispatchEvent): If a 'webkitcurrentplaybacktargetiswirelesschanged'
event is dispatched when the current target is wireless but the media engine does not support
wireless playback, tell the media engine not to play to the target.

  • html/HTMLMediaElement.h:
  • html/HTMLMediaElement.idl:
  • html/HTMLMediaSession.cpp:

(WebCore::HTMLMediaSession::showPlaybackTargetPicker): Drive-by fix to disallow audio-only files.
(WebCore::HTMLMediaSession::currentPlaybackTargetIsSupported): Deleted.

  • html/HTMLMediaSession.h:
  • platform/graphics/MediaPlayer.cpp:

(WebCore::MediaPlayer::isCurrentPlaybackTargetSupported): Deleted.

  • platform/graphics/MediaPlayer.h:
  • platform/graphics/MediaPlayerPrivate.h:
  • platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:

(WebCore::MediaPlayerPrivateAVFoundationObjC::setShouldPlayToPlaybackTarget): Use a RetainPtr
to explicitly manage the lifetime of the temporary object.
(WebCore::MediaPlayerPrivateAVFoundationObjC::isPlayingToWirelessPlaybackTarget): Ditto.

  • platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
  • platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:

(WebCore::MediaPlayerPrivateMediaSourceAVFObjC::setShouldPlayToPlaybackTarget):
(WebCore::MediaPlayerPrivateMediaSourceAVFObjC::isCurrentPlaybackTargetWireless):
(WebCore::MediaPlayerPrivateMediaSourceAVFObjC::isCurrentPlaybackTargetSupported): Deleted.

  • platform/graphics/mac/MediaPlayerPrivateQTKit.h:
  • platform/graphics/mac/MediaPlayerPrivateQTKit.mm:

(WebCore::MediaPlayerPrivateQTKit::setShouldPlayToPlaybackTarget):
(WebCore::MediaPlayerPrivateQTKit::isCurrentPlaybackTargetWireless):
(WebCore::MediaPlayerPrivateQTKit::isCurrentPlaybackTargetSupported): Deleted.

Location:
trunk/Source/WebCore
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r183499 r183509  
     12015-04-28  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [Mac] Simplify code to support media engines which do not support target playback
     4        https://bugs.webkit.org/show_bug.cgi?id=144332
     5
     6        Reviewed by Jer Noble.
     7
     8        * Modules/mediasession/WebMediaSessionManager.cpp:
     9        (WebCore::WebMediaSessionManager::externalOutputDeviceAvailableDidChange): Always make client
     10        callback, let them decide if it is significant or not.
     11
     12        * html/HTMLMediaElement.cpp:
     13        (WebCore::HTMLMediaElement::HTMLMediaElement): m_loadTimer -> m_pendingActionTimer.
     14        (WebCore::HTMLMediaElement::scheduleDelayedAction): Handle CheckPlaybackTargetCompatablity.
     15        (WebCore::HTMLMediaElement::scheduleNextSourceChild): m_loadTimer -> m_pendingActionTimer.
     16        (WebCore::HTMLMediaElement::loadTimerFired): Renamed pendingActionTimerFired.
     17        (WebCore::HTMLMediaElement::prepareForLoad): m_loadTimer -> m_pendingActionTimer.
     18        (WebCore::HTMLMediaElement::setDefaultPlaybackRate): Add logging.
     19        (WebCore::HTMLMediaElement::clearMediaPlayer): m_loadTimer -> m_pendingActionTimer.
     20        (WebCore::HTMLMediaElement::webkitCurrentPlaybackTargetIsSupported): Removed.
     21        (WebCore::HTMLMediaElement::dispatchEvent): If a 'webkitcurrentplaybacktargetiswirelesschanged'
     22        event is dispatched when the current target is wireless but the media engine does not support
     23        wireless playback, tell the media engine not to play to the target.
     24        * html/HTMLMediaElement.h:
     25        * html/HTMLMediaElement.idl:
     26
     27        * html/HTMLMediaSession.cpp:
     28        (WebCore::HTMLMediaSession::showPlaybackTargetPicker): Drive-by fix to disallow audio-only files.
     29        (WebCore::HTMLMediaSession::currentPlaybackTargetIsSupported): Deleted.
     30        * html/HTMLMediaSession.h:
     31
     32        * platform/graphics/MediaPlayer.cpp:
     33        (WebCore::MediaPlayer::isCurrentPlaybackTargetSupported): Deleted.
     34        * platform/graphics/MediaPlayer.h:
     35        * platform/graphics/MediaPlayerPrivate.h:
     36
     37        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
     38        (WebCore::MediaPlayerPrivateAVFoundationObjC::setShouldPlayToPlaybackTarget): Use a RetainPtr
     39        to explicitly manage the lifetime of the temporary object.
     40        (WebCore::MediaPlayerPrivateAVFoundationObjC::isPlayingToWirelessPlaybackTarget): Ditto.
     41        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
     42
     43        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
     44        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::setShouldPlayToPlaybackTarget):
     45        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::isCurrentPlaybackTargetWireless):
     46        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::isCurrentPlaybackTargetSupported): Deleted.
     47
     48        * platform/graphics/mac/MediaPlayerPrivateQTKit.h:
     49        * platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
     50        (WebCore::MediaPlayerPrivateQTKit::setShouldPlayToPlaybackTarget):
     51        (WebCore::MediaPlayerPrivateQTKit::isCurrentPlaybackTargetWireless):
     52        (WebCore::MediaPlayerPrivateQTKit::isCurrentPlaybackTargetSupported): Deleted.
     53
    1542015-04-28  Alex Christensen  <achristensen@webkit.org>
    255

  • trunk/Source/WebCore/Modules/mediasession/WebMediaSessionManager.cpp

    r183096 r183509  
    197197void WebMediaSessionManager::externalOutputDeviceAvailableDidChange(bool available)
    198198{
    199     if (m_externalOutputDeviceAvailable == available)
    200         return;
    201 
    202199    m_externalOutputDeviceAvailable = available;
    203200    for (auto& state : m_clientState)

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r183428 r183509  
    257257    : HTMLElement(tagName, document)
    258258    , ActiveDOMObject(&document)
    259     , m_loadTimer(*this, &HTMLMediaElement::loadTimerFired)
     259    , m_pendingActionTimer(*this, &HTMLMediaElement::pendingActionTimerFired)
    260260    , m_progressEventTimer(*this, &HTMLMediaElement::progressEventTimerFired)
    261261    , m_playbackProgressTimer(*this, &HTMLMediaElement::playbackProgressTimerFired)
    … …  
    695695#endif
    696696
    697     m_loadTimer.startOneShot(0);
     697#if ENABLE(WIRELESS_PLAYBACK_TARGET)
     698    if (actionType & CheckPlaybackTargetCompatablity)
     699        setFlags(m_pendingActionFlags, CheckPlaybackTargetCompatablity);
     700#endif
     701
     702    m_pendingActionTimer.startOneShot(0);
    698703}
    699704
    … …  
    702707    // Schedule the timer to try the next <source> element WITHOUT resetting state ala prepareForLoad.
    703708    setFlags(m_pendingActionFlags, LoadMediaResource);
    704     m_loadTimer.startOneShot(0);
     709    m_pendingActionTimer.startOneShot(0);
    705710}
    706711
    … …  
    718723}
    719724
    720 void HTMLMediaElement::loadTimerFired()
     725void HTMLMediaElement::pendingActionTimerFired()
    721726{
    722727    Ref<HTMLMediaElement> protect(*this); // loadNextSourceChild may fire 'beforeload', which can make arbitrary DOM mutations.
    … …  
    737742    if (RuntimeEnabledFeatures::sharedFeatures().webkitVideoTrackEnabled() && (m_pendingActionFlags & TextTrackChangesNotification))
    738743        notifyMediaPlayerOfTextTrackChanges();
     744#endif
     745
     746#if ENABLE(WIRELESS_PLAYBACK_TARGET)
     747    if (m_pendingActionFlags & CheckPlaybackTargetCompatablity && m_player && m_player->isCurrentPlaybackTargetWireless() && !m_player->canPlayToWirelessPlaybackTarget()) {
     748        LOG(Media, "HTMLMediaElement::pendingActionTimerFired(%p) - calling setShouldPlayToPlaybackTarget(false)", this);
     749        m_player->setShouldPlayToPlaybackTarget(false);
     750    }
    739751#endif
    740752
    … …  
    827839    // Perform the cleanup required for the resource load algorithm to run.
    828840    stopPeriodicTimers();
    829     m_loadTimer.stop();
     841    m_pendingActionTimer.stop();
    830842    // FIXME: Figure out appropriate place to reset LoadTextTrackResource if necessary and set m_pendingActionFlags to 0 here.
    831843    m_pendingActionFlags &= ~LoadMediaResource;
    … …  
    26452657{
    26462658    if (m_defaultPlaybackRate != rate) {
     2659        LOG(Media, "HTMLMediaElement::setDefaultPlaybackRate(%p) - %f", this, rate);
    26472660        m_defaultPlaybackRate = rate;
    26482661        scheduleEvent(eventNames().ratechangeEvent);
    … …  
    47104723
    47114724    stopPeriodicTimers();
    4712     m_loadTimer.stop();
     4725    m_pendingActionTimer.stop();
    47134726
    47144727    clearFlags(m_pendingActionFlags, flags);
    … …  
    48594872}
    48604873
    4861 bool HTMLMediaElement::webkitCurrentPlaybackTargetIsSupported() const
    4862 {
    4863     return m_mediaSession->currentPlaybackTargetIsSupported(*this);
    4864 }
    4865 
    48664874void HTMLMediaElement::wirelessRoutesAvailableDidChange()
    48674875{
    … …  
    48744882    scheduleEvent(eventNames().webkitcurrentplaybacktargetiswirelesschangedEvent);
    48754883
    4876 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
    48774884    m_mediaSession->mediaStateDidChange(*this, mediaState());
    4878 #endif
     4885}
     4886
     4887bool HTMLMediaElement::dispatchEvent(PassRefPtr<Event> prpEvent)
     4888{
     4889    RefPtr<Event> event = prpEvent;
     4890    if (event->type() == eventNames().webkitcurrentplaybacktargetiswirelesschangedEvent)
     4891        scheduleDelayedAction(CheckPlaybackTargetCompatablity);
     4892    return HTMLElement::dispatchEvent(event);
    48794893}
    48804894

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r183160 r183509  
    140140        TextTrackChangesNotification = 1 << 2,
    141141        ConfigureTextTrackDisplay = 1 << 3,
    142 
    143         EveryDelayedAction = LoadMediaResource | ConfigureTextTracks | TextTrackChangesNotification | ConfigureTextTrackDisplay,
     142        CheckPlaybackTargetCompatablity = 1 << 4,
     143
     144        EveryDelayedAction = LoadMediaResource | ConfigureTextTracks | TextTrackChangesNotification | ConfigureTextTrackDisplay | CheckPlaybackTargetCompatablity,
    144145    };
    145146    void scheduleDelayedAction(DelayedActionType);
    … …  
    357358    void webkitShowPlaybackTargetPicker();
    358359    bool webkitCurrentPlaybackTargetIsWireless() const;
    359     bool webkitCurrentPlaybackTargetIsSupported() const;
    360360
    361361    virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture) override;
    … …  
    563563    virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) override;
    564564    void enqueuePlaybackTargetAvailabilityChangedEvent();
     565
     566    using EventTarget::dispatchEvent;
     567    virtual bool dispatchEvent(PassRefPtr<Event>) override;
    565568#endif
    566569
    … …  
    605608    virtual double mediaPlayerRequestedPlaybackRate() const override final;
    606609
    607     void loadTimerFired();
     610    void pendingActionTimerFired();
    608611    void progressEventTimerFired();
    609612    void playbackProgressTimerFired();
    … …  
    734737    void updateCaptionContainer();
    735738
    736     Timer m_loadTimer;
     739    Timer m_pendingActionTimer;
    737740    Timer m_progressEventTimer;
    738741    Timer m_playbackProgressTimer;

  • trunk/Source/WebCore/html/HTMLMediaElement.idl

    r182240 r183509  
    117117    [Conditional=WIRELESS_PLAYBACK_TARGET] void webkitShowPlaybackTargetPicker();
    118118    [Conditional=WIRELESS_PLAYBACK_TARGET] readonly attribute boolean webkitCurrentPlaybackTargetIsWireless;
    119     [Conditional=WIRELESS_PLAYBACK_TARGET] readonly attribute boolean webkitCurrentPlaybackTargetIsSupported;
    120119};

  • trunk/Source/WebCore/html/HTMLMediaSession.cpp

    r183428 r183509  
    190190}
    191191
    192 bool HTMLMediaSession::currentPlaybackTargetIsSupported(const HTMLMediaElement& element) const
    193 {
    194     MediaPlayer* player = element.player();
    195     if (!player) {
    196         LOG(Media, "HTMLMediaSession::currentPlaybackTargetIsSupported - returning FALSE because player is NULL");
    197         return false;
    198     }
    199 
    200     bool isSupported = player->isCurrentPlaybackTargetSupported();
    201     LOG(Media, "HTMLMediaSession::currentPlaybackTargetIsSupported - returning %s", isSupported ? "TRUE" : "FALSE");
    202    
    203     return isSupported;
    204 }
    205 
    206192void HTMLMediaSession::showPlaybackTargetPicker(const HTMLMediaElement& element)
    207193{
    … …  
    217203        return;
    218204    }
     205
     206#if !PLATFORM(IOS)
     207    if (!element.hasVideo()) {
     208        LOG(Media, "HTMLMediaSession::showPlaybackTargetPicker - returning early because element has no video");
     209        return;
     210    }
     211#endif
    219212
    220213    element.document().showPlaybackTargetPicker(*this, is<HTMLVideoElement>(element));
    … …  
    389382
    390383#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    391     setWirelessVideoPlaybackDisabled(element, m_restrictions & WirelessVideoPlaybackDisabled);
     384    if (m_restrictions & WirelessVideoPlaybackDisabled)
     385        setWirelessVideoPlaybackDisabled(element, true);
    392386    if (m_playbackTarget)
    393387        client().setWirelessPlaybackTarget(*m_playbackTarget.copyRef());

  • trunk/Source/WebCore/html/HTMLMediaSession.h

    r183428 r183509  
    5757    void showPlaybackTargetPicker(const HTMLMediaElement&);
    5858    bool currentPlaybackTargetIsWireless(const HTMLMediaElement&) const;
    59     bool currentPlaybackTargetIsSupported(const HTMLMediaElement&) const;
    6059    bool hasWirelessPlaybackTargets(const HTMLMediaElement&) const;
    6160

  • trunk/Source/WebCore/platform/graphics/MediaPlayer.cpp

    r183096 r183509  
    844844}
    845845
    846 bool MediaPlayer::isCurrentPlaybackTargetSupported() const
    847 {
    848     return m_private->isCurrentPlaybackTargetSupported();
    849 }
    850 
    851846String MediaPlayer::wirelessPlaybackTargetName() const
    852847{

  • trunk/Source/WebCore/platform/graphics/MediaPlayer.h

    r183234 r183509  
    465465#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    466466    bool isCurrentPlaybackTargetWireless() const;
    467     bool isCurrentPlaybackTargetSupported() const;
    468467
    469468    enum WirelessPlaybackTargetType { TargetTypeNone, TargetTypeAirPlay, TargetTypeTVOut };

  • trunk/Source/WebCore/platform/graphics/MediaPlayerPrivate.h

    r183096 r183509  
    162162#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    163163    virtual bool isCurrentPlaybackTargetWireless() const { return false; }
    164     virtual bool isCurrentPlaybackTargetSupported() const { return true; }
    165164
    166165    virtual String wirelessPlaybackTargetName() const { return emptyString(); }

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm

    r183431 r183509  
    27992799
    28002800    AVOutputContext *newContext = shouldPlay ? m_outputContext.get() : nil;
    2801     AVOutputContext *currentContext = m_avPlayer.get().outputContext;
    2802     if ((!newContext && !currentContext) || [currentContext isEqual:newContext])
     2801    RetainPtr<AVOutputContext> currentContext = m_avPlayer.get().outputContext;
     2802    if ((!newContext && !currentContext.get()) || [currentContext.get() isEqual:newContext])
    28032803        return;
    28042804
    … …  
    28152815        return false;
    28162816
    2817     if (!m_outputContext || !m_outputContext.get().deviceName)
    2818         return false;
    2819 
    2820     return m_cachedRate;
     2817    RetainPtr<AVOutputContext> currentContext = m_avPlayer.get().outputContext;
     2818    return currentContext && currentContext.get().deviceName;
    28212819}
    28222820#endif // !PLATFORM(IOS)

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h

    r183096 r183509  
    173173
    174174#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    175     virtual bool isCurrentPlaybackTargetSupported() const override;
     175    virtual bool isCurrentPlaybackTargetWireless() const override;
    176176    virtual void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&);
    177177    virtual void setShouldPlayToPlaybackTarget(bool) override;
    … …  
    221221#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    222222    RefPtr<MediaPlaybackTarget> m_playbackTarget;
    223     bool m_currentPlaybackTargetIsSupported { true };
     223    bool m_shouldPlayToTarget { false };
    224224#endif
    225225};

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm

    r183096 r183509  
    808808
    809809#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    810 bool MediaPlayerPrivateMediaSourceAVFObjC::isCurrentPlaybackTargetSupported() const
     810void MediaPlayerPrivateMediaSourceAVFObjC::setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&& target)
     811{
     812    m_playbackTarget = WTF::move(target);
     813}
     814
     815void MediaPlayerPrivateMediaSourceAVFObjC::setShouldPlayToPlaybackTarget(bool shouldPlayToTarget)
     816{
     817    if (shouldPlayToTarget == m_shouldPlayToTarget)
     818        return;
     819
     820    m_shouldPlayToTarget = shouldPlayToTarget;
     821
     822    if (m_player)
     823        m_player->currentPlaybackTargetIsWirelessChanged();
     824}
     825
     826bool MediaPlayerPrivateMediaSourceAVFObjC::isCurrentPlaybackTargetWireless() const
    811827{
    812828    if (!m_playbackTarget)
    813         return true;
    814 
    815     return !m_playbackTarget->hasActiveRoute();
    816 }
    817 
    818 void MediaPlayerPrivateMediaSourceAVFObjC::setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&& target)
    819 {
    820     m_playbackTarget = WTF::move(target);
    821 }
    822 
    823 void MediaPlayerPrivateMediaSourceAVFObjC::setShouldPlayToPlaybackTarget(bool shouldPlayToTarget)
    824 {
    825     bool oldSupported = m_currentPlaybackTargetIsSupported;
    826     m_currentPlaybackTargetIsSupported = !shouldPlayToTarget;
    827 
    828     if (m_player && oldSupported != m_currentPlaybackTargetIsSupported)
    829         m_player->currentPlaybackTargetIsWirelessChanged();
     829        return false;
     830
     831    return m_shouldPlayToTarget && m_playbackTarget->hasActiveRoute();
    830832}
    831833#endif

  • trunk/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h

    r183096 r183509  
    181181
    182182#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    183     virtual bool isCurrentPlaybackTargetSupported() const override;
     183    virtual bool isCurrentPlaybackTargetWireless() const override;
    184184    virtual void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&);
    185185    virtual void setShouldPlayToPlaybackTarget(bool) override;
    186     void togglePlayingToPlaybackTarget();
    187186#endif
    188187
    … …  
    216215#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    217216    RefPtr<MediaPlaybackTarget> m_playbackTarget;
    218     bool m_currentPlaybackTargetIsSupported { true };
     217    bool m_shouldPlayToTarget { false };
    219218#endif
    220219};

  • trunk/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm

    r183096 r183509  
    15421542
    15431543#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    1544 bool MediaPlayerPrivateQTKit::isCurrentPlaybackTargetSupported() const
     1544void MediaPlayerPrivateQTKit::setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&& target)
     1545{
     1546    m_playbackTarget = WTF::move(target);
     1547}
     1548
     1549void MediaPlayerPrivateQTKit::setShouldPlayToPlaybackTarget(bool shouldPlayToTarget)
     1550{
     1551    if (shouldPlayToTarget == m_shouldPlayToTarget)
     1552        return;
     1553
     1554    m_shouldPlayToTarget = shouldPlayToTarget;
     1555
     1556    if (m_player)
     1557        m_player->currentPlaybackTargetIsWirelessChanged();
     1558}
     1559
     1560bool MediaPlayerPrivateQTKit::isCurrentPlaybackTargetWireless() const
    15451561{
    15461562    if (!m_playbackTarget)
    1547         return true;
    1548 
    1549     return !m_playbackTarget->hasActiveRoute();
    1550 }
    1551 
    1552 void MediaPlayerPrivateQTKit::setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&& target)
    1553 {
    1554     m_playbackTarget = WTF::move(target);
    1555 }
    1556 
    1557 void MediaPlayerPrivateQTKit::setShouldPlayToPlaybackTarget(bool shouldPlayToTarget)
    1558 {
    1559     bool oldSupported = m_currentPlaybackTargetIsSupported;
    1560     m_currentPlaybackTargetIsSupported = !shouldPlayToTarget;
    1561 
    1562     if (m_player && oldSupported != m_currentPlaybackTargetIsSupported)
    1563         m_player->currentPlaybackTargetIsWirelessChanged();
     1563        return false;
     1564   
     1565    return m_shouldPlayToTarget && m_playbackTarget->hasActiveRoute();
    15641566}
    15651567#endif
Note: See TracChangeset for help on using the changeset viewer.