Changeset 278543 in webkit


Ignore:
Timestamp:
Jun 6, 2021 9:22:38 PM (3 years ago)
Author:
Chris Dumez
Message:

Stop using legacy EventLoopDeferrableTask
​https://bugs.webkit.org/show_bug.cgi?id=226700

Reviewed by Darin Adler.

Source/WebCore:

Stop using legacy EventLoopDeferrableTask and drop the class entirely. Call sites are
now using the HTML event loop directly and using WTF::CancellableTask to wrap the task
they schedule. This achieves the same result as EventLoopDeferrableTask but is more
lightweight and flexible.

  • animation/DocumentTimelinesController.cpp:

(WebCore::DocumentTimelinesController::DocumentTimelinesController):
(WebCore::DocumentTimelinesController::detachFromDocument):
(WebCore::DocumentTimelinesController::cacheCurrentTime):

  • animation/DocumentTimelinesController.h:
  • dom/ActiveDOMObject.h:
  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::HTMLMediaElement):
(WebCore::HTMLMediaElement::~HTMLMediaElement):
(WebCore::HTMLMediaElement::scheduleCheckPlaybackTargetCompatability):
(WebCore::HTMLMediaElement::seekWithTolerance):
(WebCore::HTMLMediaElement::setVolume):
(WebCore::HTMLMediaElement::scheduleConfigureTextTracks):
(WebCore::HTMLMediaElement::scheduleMediaEngineWasUpdated):
(WebCore::HTMLMediaElement::scheduleUpdatePlayState):
(WebCore::HTMLMediaElement::cancelPendingTasks):
(WebCore::HTMLMediaElement::closeTaskQueues):
(WebCore::HTMLMediaElement::suspend):
(WebCore::HTMLMediaElement::resume):
(WebCore::HTMLMediaElement::markCaptionAndSubtitleTracksAsUnconfigured):
(WebCore::HTMLMediaElement::mediaPlayerBufferedTimeRangesChanged):
(WebCore::HTMLMediaElement::scheduleUpdateMediaState):
(WebCore::HTMLMediaElement::playbackControlsManagerBehaviorRestrictionsTimerFired):

  • html/HTMLMediaElement.h:
  • platform/DeferrableTask.h:

Source/WTF:

Introduce new WTF::CancellableTask type which is a wrapper around a WTF::Function.
It can create a handle for the task and this handle can be used to check if the
task is still pending and to cancel it. This is useful when scheduling tasks in the
event loop for example as there are cases where we need to know if a task we
scheduled is still pending (to avoid double scheduling) or where we need to cancel
a previously scheduled task.

  • WTF.xcodeproj/project.pbxproj:
  • wtf/CMakeLists.txt:
  • wtf/CancellableTask.h: Added.

(WTF::CancellableTask::CancellableTask):
(WTF::CancellableTask::operator()):
(WTF::CancellableTask::isPending const):
(WTF::CancellableTask::cancel):
(WTF::CancellableTask::Handle::Handle):
(WTF::CancellableTask::Handle::isPending const):
(WTF::CancellableTask::Handle::cancel):
(WTF::CancellableTask::createHandle):

Location:
trunk/Source
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r278521 r278543  
     12021-06-06  Chris Dumez  <cdumez@apple.com>
     2
     3        Stop using legacy EventLoopDeferrableTask
     4        https://bugs.webkit.org/show_bug.cgi?id=226700
     5
     6        Reviewed by Darin Adler.
     7
     8        Introduce new WTF::CancellableTask type which is a wrapper around a WTF::Function.
     9        It can create a handle for the task and this handle can be used to check if the
     10        task is still pending and to cancel it. This is useful when scheduling tasks in the
     11        event loop for example as there are cases where we need to know if a task we
     12        scheduled is still pending (to avoid double scheduling) or where we need to cancel
     13        a previously scheduled task.
     14
     15        * WTF.xcodeproj/project.pbxproj:
     16        * wtf/CMakeLists.txt:
     17        * wtf/CancellableTask.h: Added.
     18        (WTF::CancellableTask::CancellableTask):
     19        (WTF::CancellableTask::operator()):
     20        (WTF::CancellableTask::isPending const):
     21        (WTF::CancellableTask::cancel):
     22        (WTF::CancellableTask::Handle::Handle):
     23        (WTF::CancellableTask::Handle::isPending const):
     24        (WTF::CancellableTask::Handle::cancel):
     25        (WTF::CancellableTask::createHandle):
     26
    1272021-06-04  Chris Dumez  <cdumez@apple.com>
    228

  • trunk/Source/WTF/WTF.xcodeproj/project.pbxproj

    r278404 r278543  
    379379                4427C5A921F6D6C300A612A4 /* ASCIICType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ASCIICType.cpp; sourceTree = "<group>"; };
    380380                4468567225094FE8008CCA05 /* ThreadSanitizerSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadSanitizerSupport.h; sourceTree = "<group>"; };
     381                46209A27266D543A007F8F4A /* CancellableTask.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CancellableTask.h; sourceTree = "<group>"; };
    381382                46BA9EAB1F4CD61E009A2BBC /* CompletionHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CompletionHandler.h; sourceTree = "<group>"; };
    382383                46BEB6E922FFDDD500269867 /* RefCounted.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RefCounted.cpp; sourceTree = "<group>"; };
    … …  
    654655                A8A47323151A825B004123FF /* StringBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringBuffer.h; sourceTree = "<group>"; };
    655656                A8A47324151A825B004123FF /* StringBuilder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StringBuilder.cpp; sourceTree = "<group>"; };
     657                A8A47325151A825B004123EE /* StringBuilderInternals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringBuilderInternals.h; sourceTree = "<group>"; };
    656658                A8A47325151A825B004123FF /* StringBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringBuilder.h; sourceTree = "<group>"; };
    657                 A8A47325151A825B004123EE /* StringBuilderInternals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringBuilderInternals.h; sourceTree = "<group>"; };
    658659                A8A47326151A825B004123FF /* StringConcatenate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringConcatenate.h; sourceTree = "<group>"; };
    659660                A8A47327151A825B004123FF /* StringHash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringHash.h; sourceTree = "<group>"; };
    … …  
    984985                                0F5F3D681F3FEBA600B115A2 /* CagedUniquePtr.h */,
    985986                                413FE8F51F8D2EAB00F6D7D7 /* CallbackAggregator.h */,
     987                                46209A27266D543A007F8F4A /* CancellableTask.h */,
    986988                                A8A4726A151A825A004123FF /* CheckedArithmetic.h */,
    987989                                A8A4726B151A825A004123FF /* CheckedBoolean.h */,

  • trunk/Source/WTF/wtf/CMakeLists.txt

    r278404 r278543  
    2727    CagedUniquePtr.h
    2828    CallbackAggregator.h
     29    CancellableTask.h
    2930    CheckedArithmetic.h
    3031    CheckedBoolean.h

  • trunk/Source/WebCore/ChangeLog

    r278542 r278543  
     12021-06-06  Chris Dumez  <cdumez@apple.com>
     2
     3        Stop using legacy EventLoopDeferrableTask
     4        https://bugs.webkit.org/show_bug.cgi?id=226700
     5
     6        Reviewed by Darin Adler.
     7
     8        Stop using legacy EventLoopDeferrableTask and drop the class entirely. Call sites are
     9        now using the HTML event loop directly and using WTF::CancellableTask to wrap the task
     10        they schedule. This achieves the same result as EventLoopDeferrableTask but is more
     11        lightweight and flexible.
     12
     13        * animation/DocumentTimelinesController.cpp:
     14        (WebCore::DocumentTimelinesController::DocumentTimelinesController):
     15        (WebCore::DocumentTimelinesController::detachFromDocument):
     16        (WebCore::DocumentTimelinesController::cacheCurrentTime):
     17        * animation/DocumentTimelinesController.h:
     18        * dom/ActiveDOMObject.h:
     19        * html/HTMLMediaElement.cpp:
     20        (WebCore::HTMLMediaElement::HTMLMediaElement):
     21        (WebCore::HTMLMediaElement::~HTMLMediaElement):
     22        (WebCore::HTMLMediaElement::scheduleCheckPlaybackTargetCompatability):
     23        (WebCore::HTMLMediaElement::seekWithTolerance):
     24        (WebCore::HTMLMediaElement::setVolume):
     25        (WebCore::HTMLMediaElement::scheduleConfigureTextTracks):
     26        (WebCore::HTMLMediaElement::scheduleMediaEngineWasUpdated):
     27        (WebCore::HTMLMediaElement::scheduleUpdatePlayState):
     28        (WebCore::HTMLMediaElement::cancelPendingTasks):
     29        (WebCore::HTMLMediaElement::closeTaskQueues):
     30        (WebCore::HTMLMediaElement::suspend):
     31        (WebCore::HTMLMediaElement::resume):
     32        (WebCore::HTMLMediaElement::markCaptionAndSubtitleTracksAsUnconfigured):
     33        (WebCore::HTMLMediaElement::mediaPlayerBufferedTimeRangesChanged):
     34        (WebCore::HTMLMediaElement::scheduleUpdateMediaState):
     35        (WebCore::HTMLMediaElement::playbackControlsManagerBehaviorRestrictionsTimerFired):
     36        * html/HTMLMediaElement.h:
     37        * platform/DeferrableTask.h:
     38
    1392021-06-06  Wenson Hsieh  <wenson_hsieh@apple.com>
    240

  • trunk/Source/WebCore/animation/DocumentTimelinesController.cpp

    r278538 r278543  
    4444
    4545DocumentTimelinesController::DocumentTimelinesController(Document& document)
    46     : m_currentTimeClearingTask(&document)
    47     , m_document(document)
     46    : m_document(document)
    4847{
    4948    if (auto* page = document.page()) {
    … …  
    5554DocumentTimelinesController::~DocumentTimelinesController()
    5655{
     56    m_currentTimeClearingTask.cancel();
    5757}
    5858
    … …  
    7474void DocumentTimelinesController::detachFromDocument()
    7575{
    76     m_currentTimeClearingTask.close();
     76    m_currentTimeClearingTask.cancel();
    7777
    7878    while (!m_timelines.computesEmpty())
    … …  
    234234    // fire syncronously if no JS is running.
    235235    m_waitingOnVMIdle = true;
    236     if (!m_currentTimeClearingTask.isPending())
    237         m_currentTimeClearingTask.scheduleTask(std::bind(&DocumentTimelinesController::maybeClearCachedCurrentTime, this));
     236    if (!m_currentTimeClearingTask.isPending()) {
     237        CancellableTask task(std::bind(&DocumentTimelinesController::maybeClearCachedCurrentTime, this));
     238        m_currentTimeClearingTask = task.createHandle();
     239        m_document.eventLoop().queueTask(TaskSource::InternalAsyncTask, WTFMove(task));
     240    }
    238241    // We extent the associated Document's lifecycle until the VM became idle since the DocumentTimelinesController
    239242    // is owned by the Document.

  • trunk/Source/WebCore/animation/DocumentTimelinesController.h

    r278538 r278543  
    2626#pragma once
    2727
    28 #include "DeferrableTask.h"
    2928#include "ReducedResolutionSeconds.h"
    3029#include "Timer.h"
     30#include <wtf/CancellableTask.h>
    3131#include <wtf/Markable.h>
    3232#include <wtf/Seconds.h>
    … …  
    6868
    6969    WeakHashSet<DocumentTimeline> m_timelines;
    70     EventLoopDeferrableTask m_currentTimeClearingTask;
     70    CancellableTask::Handle m_currentTimeClearingTask;
    7171    Document& m_document;
    7272    Markable<Seconds, Seconds::MarkableTraits> m_cachedCurrentTime;

  • trunk/Source/WebCore/dom/ActiveDOMObject.h

    r278372 r278543  
    3030#include "TaskSource.h"
    3131#include <wtf/Assertions.h>
     32#include <wtf/CancellableTask.h>
    3233#include <wtf/Forward.h>
    3334#include <wtf/Function.h>
    … …  
    111112    }
    112113
     114    template<typename T>
     115    static CancellableTask::Handle queueCancellableTaskKeepingObjectAlive(T& object, TaskSource source, Function<void()>&& task)
     116    {
     117        CancellableTask cancellableTask(WTFMove(task));
     118        auto taskHandle = cancellableTask.createHandle();
     119        object.queueTaskInEventLoop(source, [protectedObject = makeRef(object), activity = object.ActiveDOMObject::makePendingActivity(object), cancellableTask = WTFMove(cancellableTask)]() mutable {
     120            cancellableTask();
     121        });
     122        return taskHandle;
     123    }
     124
    113125    template<typename EventTargetType, typename EventType>
    114126    static void queueTaskToDispatchEvent(EventTargetType& target, TaskSource source, Ref<EventType>&& event)

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

    r278538 r278543  
    395395    , m_playbackControlsManagerBehaviorRestrictionsTimer(*this, &HTMLMediaElement::playbackControlsManagerBehaviorRestrictionsTimerFired)
    396396    , m_seekToPlaybackPositionEndedTimer(*this, &HTMLMediaElement::seekToPlaybackPositionEndedTimerFired)
    397     , m_configureTextTracksTask(&document)
    398     , m_checkPlaybackTargetCompatibilityTask(&document)
    399     , m_updateMediaStateTask(&document)
    400     , m_mediaEngineUpdatedTask(&document)
    401     , m_updatePlayStateTask(&document)
    402     , m_resumeTask(&document)
    403     , m_seekTask(&document)
    404     , m_playbackControlsManagerBehaviorRestrictionsTask(&document)
    405     , m_bufferedTimeRangesChangedTask(&document)
    406397    , m_resourceSelectionTaskQueue(&document)
    407398    , m_asyncEventQueue(EventLoopEventQueue::create(*this))
    408 #if PLATFORM(IOS_FAMILY)
    409     , m_volumeRevertTask(&document)
    410 #endif
    411399    , m_lastTimeUpdateEventMovieTime(MediaTime::positiveInfiniteTime())
    412400    , m_firstTimePlaying(true)
    … …  
    580568        m_isolatedWorld->clearWrappers();
    581569
    582     m_seekTask.close();
    583     m_resumeTask.close();
    584     m_playbackControlsManagerBehaviorRestrictionsTask.close();
     570    m_seekTask.cancel();
     571    m_resumeTask.cancel();
     572    m_playbackControlsManagerBehaviorRestrictionsTask.cancel();
    585573    m_resourceSelectionTaskQueue.close();
    586574
    … …  
    997985
    998986    ALWAYS_LOG(LOGIDENTIFIER);
    999     m_checkPlaybackTargetCompatibilityTask.scheduleTask([this] {
     987    m_checkPlaybackTargetCompatibilityTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, [this] {
    1000988        checkPlaybackTargetCompatibility();
    1001989    });
    … …  
    29762964    if (m_seekTask.isPending()) {
    29772965        INFO_LOG(LOGIDENTIFIER, "cancelling pending seeks");
    2978         m_seekTask.cancelTask();
     2966        m_seekTask.cancel();
    29792967        if (m_pendingSeek) {
    29802968            now = m_pendingSeek->now;
    … …  
    29982986    if (fromDOM) {
    29992987        INFO_LOG(LOGIDENTIFIER, "enqueuing seek from ", now, " to ", time);
    3000         m_seekTask.scheduleTask(std::bind(&HTMLMediaElement::seekTask, this));
     2988        m_seekTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, std::bind(&HTMLMediaElement::seekTask, this));
    30012989    } else
    30022990        seekTask();
    … …  
    37133701        return { };
    37143702
    3715     m_volumeRevertTask.scheduleTask([this, oldVolume] {
     3703    m_volumeRevertTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, [this, oldVolume] {
    37163704        m_volume = oldVolume;
    37173705    });
    … …  
    45034491    auto logSiteIdentifier = LOGIDENTIFIER;
    45044492    ALWAYS_LOG(logSiteIdentifier, "task scheduled");
    4505     m_configureTextTracksTask.scheduleTask([this, logSiteIdentifier] {
     4493    m_configureTextTracksTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, [this, logSiteIdentifier] {
    45064494        UNUSED_PARAM(logSiteIdentifier);
    45074495        ALWAYS_LOG(logSiteIdentifier, "lambda(), task fired");
    … …  
    50515039    auto logSiteIdentifier = LOGIDENTIFIER;
    50525040    ALWAYS_LOG(logSiteIdentifier, "task scheduled");
    5053     m_mediaEngineUpdatedTask.scheduleTask([this, logSiteIdentifier] {
     5041    m_mediaEngineUpdatedTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, [this, logSiteIdentifier] {
    50545042        UNUSED_PARAM(logSiteIdentifier);
    50555043        ALWAYS_LOG(logSiteIdentifier, "lambda(), task fired");
    … …  
    53445332    auto logSiteIdentifier = LOGIDENTIFIER;
    53455333    ALWAYS_LOG(logSiteIdentifier, "task scheduled");
    5346     m_updatePlayStateTask.scheduleTask([this, logSiteIdentifier] {
     5334    m_updatePlayStateTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, [this, logSiteIdentifier] {
    53475335        UNUSED_PARAM(logSiteIdentifier);
    53485336        ALWAYS_LOG(logSiteIdentifier, "lambda(), task fired");
    … …  
    54765464void HTMLMediaElement::cancelPendingTasks()
    54775465{
    5478     m_configureTextTracksTask.cancelTask();
    5479     m_checkPlaybackTargetCompatibilityTask.cancelTask();
    5480     m_updateMediaStateTask.cancelTask();
    5481     m_mediaEngineUpdatedTask.cancelTask();
    5482     m_updatePlayStateTask.cancelTask();
     5466    m_configureTextTracksTask.cancel();
     5467    m_checkPlaybackTargetCompatibilityTask.cancel();
     5468    m_updateMediaStateTask.cancel();
     5469    m_mediaEngineUpdatedTask.cancel();
     5470    m_updatePlayStateTask.cancel();
     5471    m_resumeTask.cancel();
     5472    m_seekTask.cancel();
     5473    m_playbackControlsManagerBehaviorRestrictionsTask.cancel();
    54835474#if PLATFORM(IOS_FAMILY)
    5484     m_volumeRevertTask.cancelTask();
     5475    m_volumeRevertTask.cancel();
    54855476#endif
    54865477}
    … …  
    56385629void HTMLMediaElement::closeTaskQueues()
    56395630{
    5640     m_configureTextTracksTask.close();
    5641     m_checkPlaybackTargetCompatibilityTask.close();
    5642     m_updateMediaStateTask.close();
    5643     m_mediaEngineUpdatedTask.close();
    5644     m_updatePlayStateTask.close();
    5645     m_resumeTask.close();
    5646     m_seekTask.close();
    5647     m_playbackControlsManagerBehaviorRestrictionsTask.close();
    5648     m_seekTask.close();
    5649     m_resumeTask.close();
     5631    cancelPendingTasks();
    56505632    m_resourceSelectionTaskQueue.close();
    56515633    m_asyncEventQueue->close();
    5652 #if PLATFORM(IOS_FAMILY)
    5653     m_volumeRevertTask.close();
    5654 #endif
    56555634}
    56565635
    … …  
    56865665    Ref<HTMLMediaElement> protectedThis(*this);
    56875666
    5688     m_resumeTask.cancelTask();
     5667    m_resumeTask.cancel();
    56895668
    56905669    switch (reason) {
    … …  
    57255704        // This behavior is not specified but it seems like a sensible thing to do.
    57265705        // As it is not safe to immedately start loading now, let's schedule a load.
    5727         m_resumeTask.scheduleTask(std::bind(&HTMLMediaElement::prepareForLoad, this));
     5706        m_resumeTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, std::bind(&HTMLMediaElement::prepareForLoad, this));
    57285707    }
    57295708
    … …  
    66376616
    66386617    m_processingPreferenceChange = true;
    6639     m_configureTextTracksTask.cancelTask();
     6618    m_configureTextTracksTask.cancel();
    66406619    if (mode == Immediately) {
    66416620        Ref<HTMLMediaElement> protectedThis(*this); // configureTextTracks calls methods that can trigger arbitrary DOM mutations.
    … …  
    71587137    auto logSiteIdentifier = LOGIDENTIFIER;
    71597138    ALWAYS_LOG(logSiteIdentifier, "task scheduled");
    7160     m_bufferedTimeRangesChangedTask.scheduleTask([this, logSiteIdentifier] {
     7139    m_bufferedTimeRangesChangedTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, [this, logSiteIdentifier] {
    71617140        UNUSED_PARAM(logSiteIdentifier);
    71627141        ALWAYS_LOG(logSiteIdentifier, "lambda(), task fired");
    … …  
    77897768    auto logSiteIdentifier = LOGIDENTIFIER;
    77907769    ALWAYS_LOG(logSiteIdentifier, "task scheduled");
    7791     m_updateMediaStateTask.scheduleTask([this, logSiteIdentifier] {
     7770    m_updateMediaStateTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, [this, logSiteIdentifier] {
    77927771        UNUSED_PARAM(logSiteIdentifier);
    77937772        ALWAYS_LOG(logSiteIdentifier, "lambda(), task fired");
    … …  
    80638042        return;
    80648043
    8065     RefPtr<HTMLMediaElement> protectedThis(this);
    8066     m_playbackControlsManagerBehaviorRestrictionsTask.scheduleTask([protectedThis] () {
    8067         auto& mediaElementSession = protectedThis->mediaSession();
    8068         if (protectedThis->isPlaying() || mediaElementSession.state() == PlatformMediaSession::Autoplaying || mediaElementSession.state() == PlatformMediaSession::Playing)
     8044    m_playbackControlsManagerBehaviorRestrictionsTask = queueCancellableTaskKeepingObjectAlive(*this, TaskSource::MediaElement, [this] () {
     8045        auto& mediaElementSession = mediaSession();
     8046        if (isPlaying() || mediaElementSession.state() == PlatformMediaSession::Autoplaying || mediaElementSession.state() == PlatformMediaSession::Playing)
    80698047            return;
    80708048
    80718049        mediaElementSession.addBehaviorRestriction(MediaElementSession::RequirePlaybackToControlControlsManager);
    8072         protectedThis->schedulePlaybackControlsManagerUpdate();
     8050        schedulePlaybackControlsManagerUpdate();
    80738051    });
    80748052}

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

    r278538 r278543  
    3232#include "AutoplayEvent.h"
    3333#include "CaptionUserPreferences.h"
    34 #include "DeferrableTask.h"
    3534#include "EventLoopEventQueue.h"
    3635#include "HTMLElement.h"
    … …  
    942941    Timer m_playbackControlsManagerBehaviorRestrictionsTimer;
    943942    Timer m_seekToPlaybackPositionEndedTimer;
    944     EventLoopDeferrableTask m_configureTextTracksTask;
    945     EventLoopDeferrableTask m_checkPlaybackTargetCompatibilityTask;
    946     EventLoopDeferrableTask m_updateMediaStateTask;
    947     EventLoopDeferrableTask m_mediaEngineUpdatedTask;
    948     EventLoopDeferrableTask m_updatePlayStateTask;
    949     EventLoopDeferrableTask m_resumeTask;
    950     EventLoopDeferrableTask m_seekTask;
    951     EventLoopDeferrableTask m_playbackControlsManagerBehaviorRestrictionsTask;
    952     EventLoopDeferrableTask m_bufferedTimeRangesChangedTask;
     943    CancellableTask::Handle m_configureTextTracksTask;
     944    CancellableTask::Handle m_checkPlaybackTargetCompatibilityTask;
     945    CancellableTask::Handle m_updateMediaStateTask;
     946    CancellableTask::Handle m_mediaEngineUpdatedTask;
     947    CancellableTask::Handle m_updatePlayStateTask;
     948    CancellableTask::Handle m_resumeTask;
     949    CancellableTask::Handle m_seekTask;
     950    CancellableTask::Handle m_playbackControlsManagerBehaviorRestrictionsTask;
     951    CancellableTask::Handle m_bufferedTimeRangesChangedTask;
    953952    EventLoopTaskQueue m_resourceSelectionTaskQueue;
    954953    RefPtr<TimeRanges> m_playedTimeRanges;
    955954    UniqueRef<EventLoopEventQueue> m_asyncEventQueue;
    956955#if PLATFORM(IOS_FAMILY)
    957     EventLoopDeferrableTask m_volumeRevertTask;
     956    CancellableTask::Handle m_volumeRevertTask;
    958957#endif
    959958

  • trunk/Source/WebCore/platform/DeferrableTask.h

    r278426 r278543  
    2626#pragma once
    2727
    28 #include "ContextDestructionObserver.h"
    29 #include "EventLoop.h"
    3028#include "GenericTaskQueue.h"
    31 #include "ScriptExecutionContext.h"
    3229
    3330namespace WebCore {
    3431
    35 class DeferrableTaskBase : public CanMakeWeakPtr<DeferrableTaskBase> {
     32class MainThreadDeferrableTask : public CanMakeWeakPtr<MainThreadDeferrableTask> {
    3633public:
     34    MainThreadDeferrableTask() = default;
     35
    3736    void close()
    3837    {
    … …  
    4948    bool isPending() const { return m_isPending; }
    5049
    51 protected:
    52     ~DeferrableTaskBase() = default;
    53     bool isClosed() const { return m_isClosed; }
    54     void setIsPending(bool isPending) { m_isPending = isPending; }
    55 
    56 private:
    57     bool m_isPending { false };
    58     bool m_isClosed { false };
    59 };
    60 
    61 class MainThreadDeferrableTask : public DeferrableTaskBase {
    62 public:
    63     MainThreadDeferrableTask()
    64         : m_dispatcher()
    65     { }
    66 
    6750    void scheduleTask(Function<void()>&& task)
    6851    {
    69         if (isClosed())
     52        if (m_isClosed)
    7053            return;
    7154
    7255        cancelTask();
    7356
    74         setIsPending(true);
     57        m_isPending = true;
    7558        m_dispatcher.postTask([weakThis = makeWeakPtr(*this), task = WTFMove(task)] {
    7659            if (!weakThis)
    7760                return;
    7861            ASSERT(weakThis->isPending());
    79             weakThis->setIsPending(false);
     62            weakThis->m_isPending = false;
    8063            task();
    8164        });
    … …  
    8467private:
    8568    MainThreadTaskDispatcher m_dispatcher;
     69    bool m_isPending { false };
     70    bool m_isClosed { false };
    8671};
    8772
    88 // Similar to DeferrableTask but based on the HTML event loop.
    89 class EventLoopDeferrableTask : public DeferrableTaskBase, private ContextDestructionObserver {
    90 public:
    91     EventLoopDeferrableTask(ScriptExecutionContext* context)
    92         : ContextDestructionObserver(context)
    93     { }
    94 
    95     // FIXME: Pass TaskSource instead of assuming TaskSource::MediaElement.
    96     void scheduleTask(Function<void()>&& task)
    97     {
    98         if (isClosed() || !scriptExecutionContext())
    99             return;
    100 
    101         cancelTask();
    102 
    103         setIsPending(true);
    104         scriptExecutionContext()->eventLoop().queueTask(TaskSource::MediaElement, [weakThis = makeWeakPtr(*this), task = WTFMove(task)] {
    105             if (!weakThis)
    106                 return;
    107             ASSERT(weakThis->isPending());
    108             weakThis->setIsPending(false);
    109             task();
    110         });
    111     }
    112 };
    113 
    114 }
     73} // namespace WebCore
Note: See TracChangeset for help on using the changeset viewer.