Changeset 166052 in webkit


Ignore:
Timestamp:
Mar 21, 2014 1:04:59 AM (10 years ago)
Author:
Carlos Garcia Campos
Message:

[GTK] Use GMainLoopSource for idle and timeout sources in WebCore
https://bugs.webkit.org/show_bug.cgi?id=130078

Reviewed by Philippe Normand.

  • platform/audio/gstreamer/AudioFileReaderGStreamer.cpp:
  • platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.cpp:
  • platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.h:
  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:
  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h:
  • platform/graphics/gstreamer/TrackPrivateBaseGStreamer.cpp:
  • platform/graphics/gstreamer/TrackPrivateBaseGStreamer.h:
  • platform/graphics/gstreamer/VideoSinkGStreamer.cpp:
  • platform/graphics/gstreamer/WebKitMediaSourceGStreamer.cpp:
  • platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:
  • platform/gtk/GtkDragAndDropHelper.cpp:
  • platform/gtk/SharedTimerGtk.cpp:
Location:
trunk/Source/WebCore
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r166049 r166052  
     12014-03-20  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK] Use GMainLoopSource for idle and timeout sources in WebCore
     4        https://bugs.webkit.org/show_bug.cgi?id=130078
     5
     6        Reviewed by Philippe Normand.
     7
     8        * platform/audio/gstreamer/AudioFileReaderGStreamer.cpp:
     9        * platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.cpp:
     10        * platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.h:
     11        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
     12        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
     13        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:
     14        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h:
     15        * platform/graphics/gstreamer/TrackPrivateBaseGStreamer.cpp:
     16        * platform/graphics/gstreamer/TrackPrivateBaseGStreamer.h:
     17        * platform/graphics/gstreamer/VideoSinkGStreamer.cpp:
     18        * platform/graphics/gstreamer/WebKitMediaSourceGStreamer.cpp:
     19        * platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:
     20        * platform/gtk/GtkDragAndDropHelper.cpp:
     21        * platform/gtk/SharedTimerGtk.cpp:
     22
    1232014-03-21  Andreas Kling  <akling@apple.com>
    224
  • trunk/Source/WebCore/platform/audio/gstreamer/AudioFileReaderGStreamer.cpp

    r163797 r166052  
    2828#include <gio/gio.h>
    2929#include <gst/app/gstappsink.h>
     30#include <gst/audio/audio.h>
    3031#include <gst/gst.h>
    3132#include <gst/pbutils/pbutils.h>
    3233#include <wtf/Noncopyable.h>
     34#include <wtf/gobject/GMainLoopSource.h>
    3335#include <wtf/gobject/GRefPtr.h>
    3436#include <wtf/gobject/GUniquePtr.h>
    35 
    36 #include <gst/audio/audio.h>
    3737
    3838namespace WebCore {
     
    107107{
    108108    reader->plugDeinterleave(pad);
    109 }
    110 
    111 gboolean enteredMainLoopCallback(gpointer userData)
    112 {
    113     AudioFileReader* reader = reinterpret_cast<AudioFileReader*>(userData);
    114     reader->decodeAudioForBusCreation();
    115     return FALSE;
    116109}
    117110
     
    342335
    343336    // Start the pipeline processing just after the loop is started.
    344     GRefPtr<GSource> timeoutSource = adoptGRef(g_timeout_source_new(0));
    345     g_source_attach(timeoutSource.get(), context.get());
    346     g_source_set_callback(timeoutSource.get(), reinterpret_cast<GSourceFunc>(enteredMainLoopCallback), this, 0);
     337    GMainLoopSource source;
     338    source.schedule("[WebKit] AudioFileReader::decodeAudioForBusCreation", std::bind(&AudioFileReader::decodeAudioForBusCreation, this), G_PRIORITY_DEFAULT, nullptr, context.get());
    347339
    348340    g_main_loop_run(m_loop.get());
  • trunk/Source/WebCore/platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.cpp

    r159730 r166052  
    5353}
    5454
    55 static gboolean textTrackPrivateSampleTimeoutCallback(InbandTextTrackPrivateGStreamer* track)
    56 {
    57     track->notifyTrackOfSample();
    58     return FALSE;
    59 }
    60 
    61 static gboolean textTrackPrivateStreamTimeoutCallback(InbandTextTrackPrivateGStreamer* track)
    62 {
    63     track->notifyTrackOfStreamChanged();
    64     return FALSE;
    65 }
    66 
    6755InbandTextTrackPrivateGStreamer::InbandTextTrackPrivateGStreamer(gint index, GRefPtr<GstPad> pad)
    6856    : InbandTextTrackPrivate(WebVTT), TrackPrivateBaseGStreamer(this, index, pad)
    69     , m_sampleTimerHandler(0)
    70     , m_streamTimerHandler(0)
    7157{
    7258    m_eventProbe = gst_pad_add_probe(m_pad.get(), GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM,
     
    8369    gst_pad_remove_probe(m_pad.get(), m_eventProbe);
    8470
    85     if (m_streamTimerHandler)
    86         g_source_remove(m_streamTimerHandler);
     71    m_streamTimerHandler.cancel();
    8772
    8873    TrackPrivateBaseGStreamer::disconnect();
     
    9176void InbandTextTrackPrivateGStreamer::handleSample(GRefPtr<GstSample> sample)
    9277{
    93     if (m_sampleTimerHandler)
    94         g_source_remove(m_sampleTimerHandler);
     78    m_sampleTimerHandler.cancel();
    9579    {
    9680        MutexLocker lock(m_sampleMutex);
    9781        m_pendingSamples.append(sample);
    9882    }
    99     m_sampleTimerHandler = g_timeout_add(0,
    100         reinterpret_cast<GSourceFunc>(textTrackPrivateSampleTimeoutCallback), this);
     83    m_sampleTimerHandler.schedule("[WebKit] InbandTextTrackPrivateGStreamer::notifyTrackOfSample", std::bind(&InbandTextTrackPrivateGStreamer::notifyTrackOfSample, this));
    10184}
    10285
    10386void InbandTextTrackPrivateGStreamer::streamChanged()
    10487{
    105     if (m_streamTimerHandler)
    106         g_source_remove(m_streamTimerHandler);
    107     m_streamTimerHandler = g_timeout_add(0,
    108         reinterpret_cast<GSourceFunc>(textTrackPrivateStreamTimeoutCallback), this);
     88    m_streamTimerHandler.schedule("[WebKit] InbandTextTrackPrivateGStreamer::notifyTrackOfStreamChanged", std::bind(&InbandTextTrackPrivateGStreamer::notifyTrackOfStreamChanged, this));
    10989}
    11090
    11191void InbandTextTrackPrivateGStreamer::notifyTrackOfSample()
    11292{
    113     m_sampleTimerHandler = 0;
    114 
    11593    Vector<GRefPtr<GstSample> > samples;
    11694    {
     
    143121void InbandTextTrackPrivateGStreamer::notifyTrackOfStreamChanged()
    144122{
    145     m_streamTimerHandler = 0;
    146 
    147123    GRefPtr<GstEvent> event = adoptGRef(gst_pad_get_sticky_event(m_pad.get(),
    148124        GST_EVENT_STREAM_START, 0));
  • trunk/Source/WebCore/platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.h

    r162139 r166052  
    3232#include "InbandTextTrackPrivate.h"
    3333#include "TrackPrivateBaseGStreamer.h"
     34#include <wtf/gobject/GMainLoopSource.h>
    3435
    3536namespace WebCore {
     
    6263    InbandTextTrackPrivateGStreamer(gint index, GRefPtr<GstPad>);
    6364
    64     guint m_sampleTimerHandler;
    65     guint m_streamTimerHandler;
     65    GMainLoopSource m_sampleTimerHandler;
     66    GMainLoopSource m_streamTimerHandler;
    6667    gulong m_eventProbe;
    6768    Vector<GRefPtr<GstSample> > m_pendingSamples;
  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp

    r165607 r166052  
    5959// Max interval in seconds to stay in the READY state on manual
    6060// state change requests.
    61 static const guint gReadyStateTimerInterval = 60;
     61static const unsigned gReadyStateTimerInterval = 60;
    6262
    6363GST_DEBUG_CATEGORY_EXTERN(webkit_media_player_debug);
     
    9393}
    9494
    95 static gboolean mediaPlayerPrivateAudioChangeTimeoutCallback(MediaPlayerPrivateGStreamer* player)
    96 {
    97     // This is the callback of the timeout source created in ::audioChanged.
    98     player->notifyPlayerOfAudio();
    99     return FALSE;
    100 }
    101 
    10295static void setAudioStreamPropertiesCallback(GstChildProxy*, GObject* object, gchar*,
    10396    MediaPlayerPrivateGStreamer* player)
     
    10699}
    107100
    108 static gboolean mediaPlayerPrivateVideoChangeTimeoutCallback(MediaPlayerPrivateGStreamer* player)
    109 {
    110     // This is the callback of the timeout source created in ::videoChanged.
    111     player->notifyPlayerOfVideo();
    112     return FALSE;
    113 }
    114 
    115 static gboolean mediaPlayerPrivateVideoCapsChangeTimeoutCallback(MediaPlayerPrivateGStreamer* player)
    116 {
    117     // This is the callback of the timeout source created in ::videoCapsChanged.
    118     player->notifyPlayerOfVideoCaps();
    119     return FALSE;
    120 }
    121 
    122101#if ENABLE(VIDEO_TRACK)
    123102static void mediaPlayerPrivateTextChangedCallback(GObject*, MediaPlayerPrivateGStreamer* player)
     
    126105}
    127106
    128 static gboolean mediaPlayerPrivateTextChangeTimeoutCallback(MediaPlayerPrivateGStreamer* player)
    129 {
    130     // This is the callback of the timeout source created in ::textChanged.
    131     player->notifyPlayerOfText();
    132     return FALSE;
    133 }
    134 
    135107static GstFlowReturn mediaPlayerPrivateNewTextSampleCallback(GObject*, MediaPlayerPrivateGStreamer* player)
    136108{
     
    139111}
    140112#endif
    141 
    142 static gboolean mediaPlayerPrivateReadyStateTimeoutCallback(MediaPlayerPrivateGStreamer* player)
    143 {
    144     // This is the callback of the timeout source created in ::changePipelineState.
    145     // Reset pipeline if we are sitting on READY state when timeout is reached
    146     player->changePipelineState(GST_STATE_NULL);
    147     return FALSE;
    148 }
    149113
    150114static void mediaPlayerPrivatePluginInstallerResultFunction(GstInstallPluginsReturn result, gpointer userData)
     
    250214    , m_hasVideo(false)
    251215    , m_hasAudio(false)
    252     , m_audioTimerHandler(0)
    253     , m_textTimerHandler(0)
    254     , m_videoTimerHandler(0)
    255     , m_videoCapsTimerHandler(0)
    256     , m_readyTimerHandler(0)
    257216    , m_totalBytes(-1)
    258217    , m_preservesPitch(false)
     
    286245            reinterpret_cast<gpointer>(setAudioStreamPropertiesCallback), this);
    287246
    288     if (m_readyTimerHandler)
    289         g_source_remove(m_readyTimerHandler);
     247    m_readyTimerHandler.cancel();
    290248
    291249    if (m_playBin) {
     
    309267    GRefPtr<GstPad> videoSinkPad = adoptGRef(gst_element_get_static_pad(m_webkitVideoSink.get(), "sink"));
    310268    g_signal_handlers_disconnect_by_func(videoSinkPad.get(), reinterpret_cast<gpointer>(mediaPlayerPrivateVideoSinkCapsChangedCallback), this);
    311 
    312     if (m_videoTimerHandler)
    313         g_source_remove(m_videoTimerHandler);
    314 
    315     if (m_audioTimerHandler)
    316         g_source_remove(m_audioTimerHandler);
    317 
    318     if (m_textTimerHandler)
    319         g_source_remove(m_textTimerHandler);
    320 
    321     if (m_videoCapsTimerHandler)
    322         g_source_remove(m_videoCapsTimerHandler);
    323269}
    324270
     
    444390    // Also lets remove the timer if we request a state change for any state other than READY.
    445391    // See also https://bugs.webkit.org/show_bug.cgi?id=117354
    446     if (newState == GST_STATE_READY && !m_readyTimerHandler) {
    447         m_readyTimerHandler = g_timeout_add_seconds(gReadyStateTimerInterval, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateReadyStateTimeoutCallback), this);
    448         g_source_set_name_by_id(m_readyTimerHandler, "[WebKit] mediaPlayerPrivateReadyStateTimeoutCallback");
    449     } else if (newState != GST_STATE_READY && m_readyTimerHandler) {
    450         g_source_remove(m_readyTimerHandler);
    451         m_readyTimerHandler = 0;
     392    if (newState == GST_STATE_READY && !m_readyTimerHandler.isScheduled()) {
     393        m_readyTimerHandler.scheduleAfterDelay("[WebKit] mediaPlayerPrivateReadyStateTimeoutCallback", [this] { changePipelineState(GST_STATE_NULL); },
     394            std::chrono::seconds(gReadyStateTimerInterval));
     395    } else if (newState != GST_STATE_READY && m_readyTimerHandler.isScheduled()) {
     396        m_readyTimerHandler.cancel();
    452397    }
    453398
     
    670615void MediaPlayerPrivateGStreamer::videoChanged()
    671616{
    672     if (m_videoTimerHandler)
    673         g_source_remove(m_videoTimerHandler);
    674     m_videoTimerHandler = g_idle_add_full(G_PRIORITY_DEFAULT, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateVideoChangeTimeoutCallback), this, 0);
    675     g_source_set_name_by_id(m_videoTimerHandler, "[WebKit] mediaPlayerPrivateVideoChangeTimeoutCallback");
     617    m_videoTimerHandler.schedule("[WebKit] MediaPlayerPrivateGStreamer::videoChanged", std::bind(&MediaPlayerPrivateGStreamer::notifyPlayerOfVideo, this));
    676618}
    677619
    678620void MediaPlayerPrivateGStreamer::videoCapsChanged()
    679621{
    680     if (m_videoCapsTimerHandler)
    681         g_source_remove(m_videoCapsTimerHandler);
    682     m_videoCapsTimerHandler = g_timeout_add(0, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateVideoCapsChangeTimeoutCallback), this);
    683     g_source_set_name_by_id(m_videoCapsTimerHandler, "[WebKit] mediaPlayerPrivateVideoCapsChangeTimeoutCallback");
     622    m_videoCapsTimerHandler.schedule("[WebKit] MediaPlayerPrivateGStreamer::videoCapsChanged", std::bind(&MediaPlayerPrivateGStreamer::notifyPlayerOfVideoCaps, this));
    684623}
    685624
    686625void MediaPlayerPrivateGStreamer::notifyPlayerOfVideo()
    687626{
    688     m_videoTimerHandler = 0;
    689 
    690627    gint numTracks = 0;
    691628    if (m_playBin)
     
    725662void MediaPlayerPrivateGStreamer::notifyPlayerOfVideoCaps()
    726663{
    727     m_videoCapsTimerHandler = 0;
    728664    m_videoSize = IntSize();
    729665    m_player->mediaPlayerClient()->mediaPlayerEngineUpdated(m_player);
     
    732668void MediaPlayerPrivateGStreamer::audioChanged()
    733669{
    734     if (m_audioTimerHandler)
    735         g_source_remove(m_audioTimerHandler);
    736     m_audioTimerHandler = g_idle_add_full(G_PRIORITY_DEFAULT, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateAudioChangeTimeoutCallback), this, 0);
    737     g_source_set_name_by_id(m_audioTimerHandler, "[WebKit] mediaPlayerPrivateAudioChangeTimeoutCallback");
     670    m_audioTimerHandler.schedule("[WebKit] MediaPlayerPrivateGStreamer::audioChanged", std::bind(&MediaPlayerPrivateGStreamer::notifyPlayerOfAudio, this));
    738671}
    739672
    740673void MediaPlayerPrivateGStreamer::notifyPlayerOfAudio()
    741674{
    742     m_audioTimerHandler = 0;
    743 
    744675    gint numTracks = 0;
    745676    if (m_playBin)
     
    780711void MediaPlayerPrivateGStreamer::textChanged()
    781712{
    782     if (m_textTimerHandler)
    783         g_source_remove(m_textTimerHandler);
    784     m_textTimerHandler = g_timeout_add(0, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateTextChangeTimeoutCallback), this);
    785     g_source_set_name_by_id(m_textTimerHandler, "[WebKit] mediaPlayerPrivateTextChangeTimeoutCallback");
     713    m_textTimerHandler.schedule("[WebKit] MediaPlayerPrivateGStreamer::textChanged", std::bind(&MediaPlayerPrivateGStreamer::notifyPlayerOfText, this));
    786714}
    787715
    788716void MediaPlayerPrivateGStreamer::notifyPlayerOfText()
    789717{
    790     m_textTimerHandler = 0;
    791 
    792718    gint numTracks = 0;
    793719    if (m_playBin)
     
    16411567
    16421568    // Loading failed, remove ready timer.
    1643     if (m_readyTimerHandler) {
    1644         g_source_remove(m_readyTimerHandler);
    1645         m_readyTimerHandler = 0;
    1646     }
     1569    m_readyTimerHandler.cancel();
    16471570}
    16481571
  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h

    r164498 r166052  
    3333#include <gst/pbutils/install-plugins.h>
    3434#include <wtf/Forward.h>
     35#include <wtf/gobject/GMainLoopSource.h>
    3536
    3637#if ENABLE(MEDIA_SOURCE)
     
    190191    bool m_hasVideo;
    191192    bool m_hasAudio;
    192     guint m_audioTimerHandler;
    193     guint m_textTimerHandler;
    194     guint m_videoTimerHandler;
    195     guint m_videoCapsTimerHandler;
    196     guint m_readyTimerHandler;
     193    GMainLoopSource m_audioTimerHandler;
     194    GMainLoopSource m_textTimerHandler;
     195    GMainLoopSource m_videoTimerHandler;
     196    GMainLoopSource m_videoCapsTimerHandler;
     197    GMainLoopSource m_readyTimerHandler;
    197198    mutable long m_totalBytes;
    198199    URL m_url;
  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp

    r165955 r166052  
    7373}
    7474
    75 static gboolean mediaPlayerPrivateVolumeChangeTimeoutCallback(MediaPlayerPrivateGStreamerBase* player)
    76 {
    77     // This is the callback of the timeout source created in ::volumeChanged.
    78     player->notifyPlayerOfVolumeChange();
    79     return FALSE;
    80 }
    81 
    8275static void mediaPlayerPrivateMuteChangedCallback(GObject*, GParamSpec*, MediaPlayerPrivateGStreamerBase* player)
    8376{
    8477    // This is called when m_volumeElement receives the notify::mute signal.
    8578    player->muteChanged();
    86 }
    87 
    88 static gboolean mediaPlayerPrivateMuteChangeTimeoutCallback(MediaPlayerPrivateGStreamerBase* player)
    89 {
    90     // This is the callback of the timeout source created in ::muteChanged.
    91     player->notifyPlayerOfMute();
    92     return FALSE;
    9379}
    9480
     
    10490    , m_networkState(MediaPlayer::Empty)
    10591    , m_buffer(0)
    106     , m_volumeTimerHandler(0)
    107     , m_muteTimerHandler(0)
    10892    , m_repaintHandler(0)
    10993    , m_volumeSignalHandler(0)
     
    134118
    135119    m_player = 0;
    136 
    137     if (m_muteTimerHandler)
    138         g_source_remove(m_muteTimerHandler);
    139 
    140     if (m_volumeTimerHandler)
    141         g_source_remove(m_volumeTimerHandler);
    142120
    143121    if (m_volumeSignalHandler) {
     
    232210void MediaPlayerPrivateGStreamerBase::notifyPlayerOfVolumeChange()
    233211{
    234     m_volumeTimerHandler = 0;
    235 
    236212    if (!m_player || !m_volumeElement)
    237213        return;
     
    247223void MediaPlayerPrivateGStreamerBase::volumeChanged()
    248224{
    249     if (m_volumeTimerHandler)
    250         g_source_remove(m_volumeTimerHandler);
    251     m_volumeTimerHandler = g_idle_add_full(G_PRIORITY_DEFAULT, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateVolumeChangeTimeoutCallback), this, 0);
    252     g_source_set_name_by_id(m_volumeTimerHandler, "[WebKit] mediaPlayerPrivateVolumeChangeTimeoutCallback");
     225    m_volumeTimerHandler.schedule("[WebKit] MediaPlayerPrivateGStreamerBase::volumeChanged", std::bind(&MediaPlayerPrivateGStreamerBase::notifyPlayerOfVolumeChange, this));
    253226}
    254227
     
    288261void MediaPlayerPrivateGStreamerBase::notifyPlayerOfMute()
    289262{
    290     m_muteTimerHandler = 0;
    291 
    292263    if (!m_player || !m_volumeElement)
    293264        return;
     
    300271void MediaPlayerPrivateGStreamerBase::muteChanged()
    301272{
    302     if (m_muteTimerHandler)
    303         g_source_remove(m_muteTimerHandler);
    304     m_muteTimerHandler = g_idle_add_full(G_PRIORITY_DEFAULT, reinterpret_cast<GSourceFunc>(mediaPlayerPrivateMuteChangeTimeoutCallback), this, 0);
    305     g_source_set_name_by_id(m_muteTimerHandler, "[WebKit] mediaPlayerPrivateMuteChangeTimeoutCallback");
    306 }
    307 
     273    m_muteTimerHandler.schedule("[WebKit] MediaPlayerPrivateGStreamerBase::muteChanged", std::bind(&MediaPlayerPrivateGStreamerBase::notifyPlayerOfMute, this));
     274}
    308275
    309276#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h

    r163435 r166052  
    3131
    3232#include <wtf/Forward.h>
     33#include <wtf/gobject/GMainLoopSource.h>
    3334
    3435#if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS)
     
    120121    GMutex* m_bufferMutex;
    121122    GstBuffer* m_buffer;
    122     unsigned long m_volumeTimerHandler;
    123     unsigned long m_muteTimerHandler;
     123    GMainLoopSource m_volumeTimerHandler;
     124    GMainLoopSource m_muteTimerHandler;
    124125    unsigned long m_repaintHandler;
    125126    unsigned long m_volumeSignalHandler;
  • trunk/Source/WebCore/platform/graphics/gstreamer/TrackPrivateBaseGStreamer.cpp

    r165763 r166052  
    5454}
    5555
    56 static gboolean trackPrivateActiveChangeTimeoutCallback(TrackPrivateBaseGStreamer* track)
    57 {
    58     track->notifyTrackOfActiveChanged();
    59     return FALSE;
    60 }
    61 
    62 static gboolean trackPrivateTagsChangeTimeoutCallback(TrackPrivateBaseGStreamer* track)
    63 {
    64     track->notifyTrackOfTagsChanged();
    65     return FALSE;
    66 }
    67 
    6856TrackPrivateBaseGStreamer::TrackPrivateBaseGStreamer(TrackPrivateBase* owner, gint index, GRefPtr<GstPad> pad)
    6957    : m_index(index)
    7058    , m_pad(pad)
    7159    , m_owner(owner)
    72     , m_activeTimerHandler(0)
    73     , m_tagTimerHandler(0)
    7460{
    7561    ASSERT(m_pad);
     
    9884        reinterpret_cast<gpointer>(trackPrivateTagsChangedCallback), this);
    9985
    100     if (m_activeTimerHandler)
    101         g_source_remove(m_activeTimerHandler);
    102     m_activeTimerHandler = 0;
    103 
    104     if (m_tagTimerHandler)
    105         g_source_remove(m_tagTimerHandler);
    106     m_tagTimerHandler = 0;
     86    m_activeTimerHandler.cancel();
     87    m_tagTimerHandler.cancel();
    10788
    10889    m_pad.clear();
     
    11293void TrackPrivateBaseGStreamer::activeChanged()
    11394{
    114     if (m_activeTimerHandler)
    115         g_source_remove(m_activeTimerHandler);
    116     m_activeTimerHandler = g_timeout_add(0,
    117         reinterpret_cast<GSourceFunc>(trackPrivateActiveChangeTimeoutCallback), this);
    118     g_source_set_name_by_id(m_activeTimerHandler, "[WebKit] trackPrivateActiveChangeTimeoutCallback");
     95    m_activeTimerHandler.schedule("[WebKit] TrackPrivateBaseGStreamer::notifyTrackOfActiveChanged", std::bind(&TrackPrivateBaseGStreamer::notifyTrackOfActiveChanged, this));
    11996}
    12097
    12198void TrackPrivateBaseGStreamer::tagsChanged()
    12299{
    123     if (m_tagTimerHandler)
    124         g_source_remove(m_tagTimerHandler);
     100    m_tagTimerHandler.cancel();
    125101
    126102    GRefPtr<GstTagList> tags;
     
    131107    }
    132108
    133     m_tagTimerHandler = g_timeout_add(0,
    134         reinterpret_cast<GSourceFunc>(trackPrivateTagsChangeTimeoutCallback), this);
    135     g_source_set_name_by_id(m_tagTimerHandler, "[WebKit] trackPrivateTagsChangeTimeoutCallback");
     109    m_tagTimerHandler.schedule("[WebKit] TrackPrivateBaseGStreamer::notifyTrackOfTagsChanged", std::bind(&TrackPrivateBaseGStreamer::notifyTrackOfTagsChanged, this));
    136110}
    137111
    138112void TrackPrivateBaseGStreamer::notifyTrackOfActiveChanged()
    139113{
    140     m_activeTimerHandler = 0;
    141114    if (!m_pad)
    142115        return;
     
    176149void TrackPrivateBaseGStreamer::notifyTrackOfTagsChanged()
    177150{
    178     m_tagTimerHandler = 0;
    179151    if (!m_pad)
    180152        return;
  • trunk/Source/WebCore/platform/graphics/gstreamer/TrackPrivateBaseGStreamer.h

    r165763 r166052  
    3131#include "GRefPtrGStreamer.h"
    3232#include <wtf/ThreadingPrimitives.h>
     33#include <wtf/gobject/GMainLoopSource.h>
    3334#include <wtf/text/WTFString.h>
    3435
     
    6869
    6970    TrackPrivateBase* m_owner;
    70     guint m_activeTimerHandler;
    71     guint m_tagTimerHandler;
     71    GMainLoopSource m_activeTimerHandler;
     72    GMainLoopSource m_tagTimerHandler;
    7273
    7374    Mutex m_tagMutex;
  • trunk/Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp

    r160593 r166052  
    3737#include <gst/video/gstvideometa.h>
    3838#include <wtf/OwnPtr.h>
     39#include <wtf/gobject/GMainLoopSource.h>
    3940#include <wtf/gobject/GMutexLocker.h>
    4041
     
    7576struct _WebKitVideoSinkPrivate {
    7677    GstBuffer* buffer;
    77     guint timeoutId;
     78    GMainLoopSource timeoutSource;
    7879    GMutex* bufferMutex;
    7980    GCond* dataCondition;
     
    101102{
    102103    sink->priv = G_TYPE_INSTANCE_GET_PRIVATE(sink, WEBKIT_TYPE_VIDEO_SINK, WebKitVideoSinkPrivate);
     104    new (sink->priv) WebKitVideoSinkPrivate();
    103105#if GLIB_CHECK_VERSION(2, 31, 0)
    104106    sink->priv->dataCondition = new GCond;
     
    114116}
    115117
    116 static gboolean webkitVideoSinkTimeoutCallback(gpointer data)
    117 {
    118     WebKitVideoSink* sink = reinterpret_cast<WebKitVideoSink*>(data);
     118static void webkitVideoSinkTimeoutCallback(WebKitVideoSink* sink)
     119{
    119120    WebKitVideoSinkPrivate* priv = sink->priv;
    120121
     
    122123    GstBuffer* buffer = priv->buffer;
    123124    priv->buffer = 0;
    124     priv->timeoutId = 0;
    125125
    126126    if (!buffer || priv->unlocked || UNLIKELY(!GST_IS_BUFFER(buffer))) {
    127127        g_cond_signal(priv->dataCondition);
    128         return FALSE;
     128        return;
    129129    }
    130130
     
    132132    gst_buffer_unref(buffer);
    133133    g_cond_signal(priv->dataCondition);
    134 
    135     return FALSE;
    136134}
    137135
     
    217215    // lower priority sources.
    218216    // See: https://bugzilla.gnome.org/show_bug.cgi?id=610830.
    219     priv->timeoutId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, webkitVideoSinkTimeoutCallback,
    220                                           gst_object_ref(sink), reinterpret_cast<GDestroyNotify>(gst_object_unref));
    221     g_source_set_name_by_id(priv->timeoutId, "[WebKit] webkitVideoSinkTimeoutCallback");
     217    gst_object_ref(sink);
     218    priv->timeoutSource.schedule("[WebKit] webkitVideoSinkTimeoutCallback", std::bind(webkitVideoSinkTimeoutCallback, sink), G_PRIORITY_DEFAULT,
     219        [sink] { gst_object_unref(sink); });
    222220
    223221    g_cond_wait(priv->dataCondition, priv->bufferMutex);
     
    251249
    252250    G_OBJECT_CLASS(parent_class)->dispose(object);
     251}
     252
     253static void webkitVideoSinkFinalize(GObject* object)
     254{
     255    WEBKIT_VIDEO_SINK(object)->priv->~WebKitVideoSinkPrivate();
     256    G_OBJECT_CLASS(parent_class)->finalize(object);
    253257}
    254258
     
    377381
    378382    gobjectClass->dispose = webkitVideoSinkDispose;
     383    gobjectClass->finalize = webkitVideoSinkFinalize;
    379384    gobjectClass->get_property = webkitVideoSinkGetProperty;
    380385
  • trunk/Source/WebCore/platform/graphics/gstreamer/WebKitMediaSourceGStreamer.cpp

    r165891 r166052  
    3131#include <gst/gst.h>
    3232#include <gst/pbutils/missing-plugins.h>
     33#include <wtf/gobject/GMainLoopSource.h>
    3334#include <wtf/gobject/GUniquePtr.h>
    3435#include <wtf/text/CString.h>
     
    4445    gboolean paused;
    4546
    46     guint startId;
    47     guint stopId;
    48     guint needDataId;
    49     guint enoughDataId;
    50     guint seekId;
     47    GMainLoopSource start;
     48    GMainLoopSource stop;
     49    GMainLoopSource needData;
     50    GMainLoopSource enoughData;
     51    GMainLoopSource seek;
    5152
    5253    guint64 requestedOffset;
     
    173174    WebKitMediaSrcPrivate* priv = WEBKIT_MEDIA_SRC_GET_PRIVATE(src);
    174175    src->priv = priv;
     176    new (priv) WebKitMediaSrcPrivate();
    175177
    176178    priv->sourceVideo.appsrc = gst_element_factory_make("appsrc", "videoappsrc");
     
    189191
    190192    g_free(priv->uri);
     193    priv->~WebKitMediaSrcPrivate();
    191194
    192195    GST_CALL_PARENT(G_OBJECT_CLASS, finalize, (object));
     
    224227
    225228// must be called on main thread and with object unlocked
    226 static gboolean webKitMediaVideoSrcStop(WebKitMediaSrc* src)
     229static void webKitMediaVideoSrcStop(WebKitMediaSrc* src)
    227230{
    228231    WebKitMediaSrcPrivate* priv = src->priv;
     
    231234    GST_OBJECT_LOCK(src);
    232235
    233     seeking = priv->sourceVideo.seekId;
    234 
    235     if (priv->sourceVideo.startId) {
    236         g_source_remove(priv->sourceVideo.startId);
    237         priv->sourceVideo.startId = 0;
    238     }
     236    seeking = priv->sourceVideo.seek.isActive();
     237
     238    priv->sourceVideo.start.cancel();
    239239
    240240    priv->player = 0;
    241241    priv->playbin = 0;
    242242
    243     if (priv->sourceVideo.needDataId)
    244         g_source_remove(priv->sourceVideo.needDataId);
    245     priv->sourceVideo.needDataId = 0;
    246 
    247     if (priv->sourceVideo.enoughDataId)
    248         g_source_remove(priv->sourceVideo.enoughDataId);
    249     priv->sourceVideo.enoughDataId = 0;
    250 
    251     if (priv->sourceVideo.seekId)
    252         g_source_remove(priv->sourceVideo.seekId);
    253 
    254     priv->sourceVideo.seekId = 0;
     243    priv->sourceVideo.needData.cancel();
     244    priv->sourceVideo.enoughData.cancel();
     245    priv->sourceVideo.seek.cancel();
    255246
    256247    priv->sourceVideo.paused = FALSE;
     
    260251    priv->duration = 0;
    261252    priv->nbSource = 0;
    262 
    263     priv->sourceVideo.stopId = 0;
    264253
    265254    GST_OBJECT_UNLOCK(src);
     
    272261
    273262    GST_DEBUG_OBJECT(src, "Stopped request");
    274 
    275     return FALSE;
    276 }
    277 
    278 static gboolean webKitMediaAudioSrcStop(WebKitMediaSrc* src)
     263}
     264
     265static void webKitMediaAudioSrcStop(WebKitMediaSrc* src)
    279266{
    280267    WebKitMediaSrcPrivate* priv = src->priv;
     
    283270    GST_OBJECT_LOCK(src);
    284271
    285     seeking = priv->sourceAudio.seekId;
    286 
    287     if (priv->sourceAudio.startId) {
    288         g_source_remove(priv->sourceAudio.startId);
    289         priv->sourceAudio.startId = 0;
    290     }
     272    seeking = priv->sourceAudio.seek.isActive();
     273
     274    priv->sourceAudio.start.cancel();
    291275
    292276    priv->player = 0;
     
    294278    priv->playbin = 0;
    295279
    296     if (priv->sourceAudio.needDataId)
    297         g_source_remove(priv->sourceAudio.needDataId);
    298     priv->sourceAudio.needDataId = 0;
    299 
    300     if (priv->sourceAudio.enoughDataId)
    301         g_source_remove(priv->sourceAudio.enoughDataId);
    302     priv->sourceAudio.enoughDataId = 0;
    303 
    304     if (priv->sourceAudio.seekId)
    305         g_source_remove(priv->sourceAudio.seekId);
    306 
    307     priv->sourceAudio.seekId = 0;
     280    priv->sourceAudio.needData.cancel();
     281    priv->sourceAudio.enoughData.cancel();
     282    priv->sourceAudio.seek.cancel();
    308283
    309284    priv->sourceAudio.paused = FALSE;
     
    315290    priv->duration = 0;
    316291    priv->nbSource = 0;
    317 
    318     priv->sourceAudio.stopId = 0;
    319292
    320293    GST_OBJECT_UNLOCK(src);
     
    327300
    328301    GST_DEBUG_OBJECT(src, "Stopped request");
    329 
    330     return FALSE;
    331302}
    332303
    333304// must be called on main thread and with object unlocked
    334 static gboolean webKitMediaVideoSrcStart(WebKitMediaSrc* src)
     305static void webKitMediaVideoSrcStart(WebKitMediaSrc* src)
    335306{
    336307    WebKitMediaSrcPrivate* priv = src->priv;
     
    341312        GST_OBJECT_UNLOCK(src);
    342313        webKitMediaVideoSrcStop(src);
    343         return FALSE;
    344     }
    345 
    346     priv->sourceVideo.startId = 0;
     314        return;
     315    }
    347316
    348317    GST_OBJECT_UNLOCK(src);
    349318    GST_DEBUG_OBJECT(src, "Started request");
    350 
    351     return FALSE;
    352319}
    353320
    354321// must be called on main thread and with object unlocked
    355 static gboolean webKitMediaAudioSrcStart(WebKitMediaSrc* src)
     322static void webKitMediaAudioSrcStart(WebKitMediaSrc* src)
    356323{
    357324    WebKitMediaSrcPrivate* priv = src->priv;
     
    362329        GST_OBJECT_UNLOCK(src);
    363330        webKitMediaAudioSrcStop(src);
    364         return FALSE;
    365     }
    366 
    367     priv->sourceAudio.startId = 0;
     331        return;
     332    }
    368333
    369334    GST_OBJECT_UNLOCK(src);
    370335    GST_DEBUG_OBJECT(src, "Started request");
    371 
    372     return FALSE;
    373336}
    374337
     
    402365        GST_DEBUG_OBJECT(src, "READY->PAUSED");
    403366        GST_OBJECT_LOCK(src);
    404         priv->sourceVideo.startId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaVideoSrcStart, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    405         g_source_set_name_by_id(priv->sourceVideo.startId, "[WebKit] webKitMediaVideoSrcStart");
    406         priv->sourceAudio.startId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaAudioSrcStart, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    407         g_source_set_name_by_id(priv->sourceAudio.startId, "[WebKit] webKitMediaAudioSrcStart");
     367
     368        gst_object_ref(src);
     369        priv->sourceVideo.start.schedule("[WebKit] webKitMediaVideoSrcStart", std::bind(webKitMediaVideoSrcStart, src), G_PRIORITY_DEFAULT,
     370            [src] { gst_object_unref(src); });
     371
     372        gst_object_ref(src);
     373        priv->sourceAudio.start.schedule("[WebKit] webKitMediaAudioSrcStart", std::bind(webKitMediaAudioSrcStart, src), G_PRIORITY_DEFAULT,
     374            [src] { gst_object_unref(src); });
     375
    408376        GST_OBJECT_UNLOCK(src);
    409377        break;
     
    411379        GST_DEBUG_OBJECT(src, "PAUSED->READY");
    412380        GST_OBJECT_LOCK(src);
    413         priv->sourceVideo.stopId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaVideoSrcStop, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    414         g_source_set_name_by_id(priv->sourceVideo.stopId, "[WebKit] webKitMediaVideoSrcStop");
    415         priv->sourceAudio.stopId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaAudioSrcStop, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    416         g_source_set_name_by_id(priv->sourceAudio.stopId, "[WebKit] webKitMediaAudioSrcStop");
     381
     382        gst_object_ref(src);
     383        priv->sourceVideo.stop.schedule("[WebKit] webKitMediaVideoSrcStop", std::bind(webKitMediaVideoSrcStop, src), G_PRIORITY_DEFAULT,
     384            [src] { gst_object_unref(src); });
     385
     386        gst_object_ref(src);
     387        priv->sourceAudio.stop.schedule("[WebKit] webKitMediaAudioSrcStop", std::bind(webKitMediaAudioSrcStop, src), G_PRIORITY_DEFAULT,
     388            [src] { gst_object_unref(src); });
     389
    417390        GST_OBJECT_UNLOCK(src);
    418391        break;
     
    520493
    521494// appsrc callbacks
    522 static gboolean webKitMediaVideoSrcNeedDataMainCb(WebKitMediaSrc* src)
    523 {
    524     WebKitMediaSrcPrivate* priv = src->priv;
    525 
    526     GST_OBJECT_LOCK(src);
    527     // already stopped
    528     if (!priv->sourceVideo.needDataId) {
    529         GST_OBJECT_UNLOCK(src);
    530         return FALSE;
    531     }
    532 
     495static void webKitMediaVideoSrcNeedDataMainCb(WebKitMediaSrc* src)
     496{
     497    WebKitMediaSrcPrivate* priv = src->priv;
     498
     499    GST_OBJECT_LOCK(src);
    533500    priv->sourceVideo.paused = FALSE;
    534     priv->sourceVideo.needDataId = 0;
    535     GST_OBJECT_UNLOCK(src);
    536 
    537     return FALSE;
    538 }
    539 
    540 static gboolean webKitMediaAudioSrcNeedDataMainCb(WebKitMediaSrc* src)
    541 {
    542     WebKitMediaSrcPrivate* priv = src->priv;
    543 
    544     GST_OBJECT_LOCK(src);
    545     // already stopped
    546     if (!priv->sourceAudio.needDataId) {
    547         GST_OBJECT_UNLOCK(src);
    548         return FALSE;
    549     }
    550 
     501    GST_OBJECT_UNLOCK(src);
     502}
     503
     504static void webKitMediaAudioSrcNeedDataMainCb(WebKitMediaSrc* src)
     505{
     506    WebKitMediaSrcPrivate* priv = src->priv;
     507
     508    GST_OBJECT_LOCK(src);
    551509    priv->sourceAudio.paused = FALSE;
    552     priv->sourceAudio.needDataId = 0;
    553     GST_OBJECT_UNLOCK(src);
    554 
    555     return FALSE;
     510    GST_OBJECT_UNLOCK(src);
    556511}
    557512
     
    564519
    565520    GST_OBJECT_LOCK(src);
    566     if (priv->sourceVideo.needDataId || !priv->sourceVideo.paused) {
     521    if (priv->sourceVideo.needData.isScheduled() || !priv->sourceVideo.paused) {
    567522        GST_OBJECT_UNLOCK(src);
    568523        return;
    569524    }
    570525
    571     priv->sourceVideo.needDataId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaVideoSrcNeedDataMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    572     g_source_set_name_by_id(priv->sourceVideo.needDataId, "[WebKit] webKitMediaVideoSrcNeedDataMainCb");
     526    gst_object_ref(src);
     527    priv->sourceVideo.needData.schedule("[WebKit] webKitMediaVideoSrcNeedDataMainCb", std::bind(webKitMediaVideoSrcNeedDataMainCb, src), G_PRIORITY_DEFAULT,
     528        [src] { gst_object_unref(src); });
    573529    GST_OBJECT_UNLOCK(src);
    574530}
     
    582538
    583539    GST_OBJECT_LOCK(src);
    584     if (priv->sourceAudio.needDataId || !priv->sourceAudio.paused) {
     540    if (priv->sourceAudio.needData.isScheduled() || !priv->sourceAudio.paused) {
    585541        GST_OBJECT_UNLOCK(src);
    586542        return;
    587543    }
    588544
    589     priv->sourceAudio.needDataId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaAudioSrcNeedDataMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    590     g_source_set_name_by_id(priv->sourceAudio.needDataId, "[WebKit] webKitMediaAudioSrcNeedDataMainCb");
    591     GST_OBJECT_UNLOCK(src);
    592 }
    593 
    594 static gboolean webKitMediaVideoSrcEnoughDataMainCb(WebKitMediaSrc* src)
    595 {
    596     WebKitMediaSrcPrivate* priv = src->priv;
    597 
    598     GST_OBJECT_LOCK(src);
    599     // already stopped
    600     if (!priv->sourceVideo.enoughDataId) {
    601         GST_OBJECT_UNLOCK(src);
    602         return FALSE;
    603     }
    604 
     545    gst_object_ref(src);
     546    priv->sourceAudio.needData.schedule("[WebKit] webKitMediaAudioSrcNeedDataMainCb", std::bind(webKitMediaAudioSrcNeedDataMainCb, src), G_PRIORITY_DEFAULT,
     547        [src] { gst_object_unref(src); });
     548    GST_OBJECT_UNLOCK(src);
     549}
     550
     551static void webKitMediaVideoSrcEnoughDataMainCb(WebKitMediaSrc* src)
     552{
     553    WebKitMediaSrcPrivate* priv = src->priv;
     554
     555    GST_OBJECT_LOCK(src);
    605556    priv->sourceVideo.paused = TRUE;
    606     priv->sourceVideo.enoughDataId = 0;
    607     GST_OBJECT_UNLOCK(src);
    608 
    609     return FALSE;
    610 }
    611 
    612 static gboolean webKitMediaAudioSrcEnoughDataMainCb(WebKitMediaSrc* src)
    613 {
    614     WebKitMediaSrcPrivate* priv = src->priv;
    615 
    616     GST_OBJECT_LOCK(src);
    617     // already stopped
    618     if (!priv->sourceAudio.enoughDataId) {
    619         GST_OBJECT_UNLOCK(src);
    620         return FALSE;
    621     }
    622 
     557    GST_OBJECT_UNLOCK(src);
     558}
     559
     560static void webKitMediaAudioSrcEnoughDataMainCb(WebKitMediaSrc* src)
     561{
     562    WebKitMediaSrcPrivate* priv = src->priv;
     563
     564    GST_OBJECT_LOCK(src);
    623565    priv->sourceAudio.paused = TRUE;
    624     priv->sourceAudio.enoughDataId = 0;
    625     GST_OBJECT_UNLOCK(src);
    626 
    627     return FALSE;
     566    GST_OBJECT_UNLOCK(src);
    628567}
    629568
     
    636575
    637576    GST_OBJECT_LOCK(src);
    638     if (priv->sourceVideo.enoughDataId || priv->sourceVideo.paused) {
     577    if (priv->sourceVideo.enoughData.isScheduled() || priv->sourceVideo.paused) {
    639578        GST_OBJECT_UNLOCK(src);
    640579        return;
    641580    }
    642581
    643     priv->sourceVideo.enoughDataId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaVideoSrcEnoughDataMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    644     g_source_set_name_by_id(priv->sourceVideo.enoughDataId, "[WebKit] webKitMediaVideoSrcEnoughDataMainCb");
     582    gst_object_ref(src);
     583    priv->sourceVideo.enoughData.schedule("[WebKit] webKitMediaVideoSrcEnoughDataMainCb", std::bind(webKitMediaVideoSrcEnoughDataMainCb, src), G_PRIORITY_DEFAULT,
     584        [src] { gst_object_unref(src); });
     585
    645586    GST_OBJECT_UNLOCK(src);
    646587}
     
    654595
    655596    GST_OBJECT_LOCK(src);
    656     if (priv->sourceAudio.enoughDataId || priv->sourceAudio.paused) {
     597    if (priv->sourceAudio.enoughData.isScheduled() || priv->sourceAudio.paused) {
    657598        GST_OBJECT_UNLOCK(src);
    658599        return;
    659600    }
    660601
    661     priv->sourceAudio.enoughDataId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaAudioSrcEnoughDataMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    662     g_source_set_name_by_id(priv->sourceAudio.enoughDataId, "[WebKit] webKitMediaAudioSrcEnoughDataMainCb");
    663     GST_OBJECT_UNLOCK(src);
    664 }
    665 
    666 static gboolean webKitMediaVideoSrcSeekMainCb(WebKitMediaSrc* src)
     602    gst_object_ref(src);
     603    priv->sourceAudio.enoughData.schedule("[WebKit] webKitMediaAudioSrcEnoughDataMainCb", std::bind(webKitMediaAudioSrcEnoughDataMainCb, src), G_PRIORITY_DEFAULT,
     604        [src] { gst_object_unref(src); });
     605
     606    GST_OBJECT_UNLOCK(src);
     607}
     608
     609static void webKitMediaVideoSrcSeekMainCb(WebKitMediaSrc*)
    667610{
    668611    notImplemented();
    669     src->priv->sourceVideo.seekId = 0;
    670     return FALSE;
    671 }
    672 
    673 static gboolean webKitMediaAudioSrcSeekMainCb(WebKitMediaSrc* src)
     612}
     613
     614
     615static void webKitMediaAudioSrcSeekMainCb(WebKitMediaSrc*)
    674616{
    675617    notImplemented();
    676     src->priv->sourceAudio.seekId = 0;
    677     return FALSE;
    678618}
    679619
     
    702642    priv->sourceVideo.requestedOffset = offset;
    703643
    704     if (priv->sourceVideo.seekId)
    705         g_source_remove(priv->sourceVideo.seekId);
    706     priv->sourceVideo.seekId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaVideoSrcSeekMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    707     g_source_set_name_by_id(priv->sourceVideo.seekId, "[WebKit] webKitMediaVideoSrcSeekMainCb");
     644    gst_object_ref(src);
     645    priv->sourceVideo.seek.schedule("[WebKit] webKitMediaVideoSrcSeekMainCb", std::bind(webKitMediaVideoSrcSeekMainCb, src), G_PRIORITY_DEFAULT,
     646        [src] { gst_object_unref(src); });
     647
    708648    GST_OBJECT_UNLOCK(src);
    709649
     
    735675    priv->sourceAudio.requestedOffset = offset;
    736676
    737     if (priv->sourceAudio.seekId)
    738         g_source_remove(priv->sourceAudio.seekId);
    739     priv->sourceAudio.seekId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, (GSourceFunc) webKitMediaAudioSrcSeekMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    740     g_source_set_name_by_id(priv->sourceAudio.seekId, "[WebKit] webKitMediaAudioSrcSeekMainCb");
     677    gst_object_ref(src);
     678    priv->sourceAudio.seek.schedule("[WebKit] webKitMediaAudioSrcSeekMainCb", std::bind(webKitMediaAudioSrcSeekMainCb, src), G_PRIORITY_DEFAULT,
     679        [src] { gst_object_unref(src); });
     680
    741681    GST_OBJECT_UNLOCK(src);
    742682
     
    823763
    824764    GST_OBJECT_LOCK(m_src);
    825     if (!priv->sourceVideo.seekId) {
     765    if (!priv->sourceVideo.seek.isActive()) {
    826766        GST_OBJECT_UNLOCK(m_src);
    827767        gst_app_src_end_of_stream(GST_APP_SRC(priv->sourceVideo.appsrc));
     
    830770
    831771    GST_OBJECT_LOCK(m_src);
    832     if (!priv->sourceAudio.seekId) {
     772    if (!priv->sourceAudio.seek.isActive()) {
    833773        GST_OBJECT_UNLOCK(m_src);
    834774        gst_app_src_end_of_stream(GST_APP_SRC(priv->sourceAudio.appsrc));
  • trunk/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp

    r165688 r166052  
    4141#include <gst/pbutils/missing-plugins.h>
    4242#include <wtf/Noncopyable.h>
     43#include <wtf/gobject/GMainLoopSource.h>
    4344#include <wtf/gobject/GMutexLocker.h>
    4445#include <wtf/gobject/GRefPtr.h>
     
    127128    guint64 requestedOffset;
    128129
    129     guint startID;
    130     guint stopID;
    131     guint needDataID;
    132     guint enoughDataID;
    133     guint seekID;
     130    GMainLoopSource startSource;
     131    GMainLoopSource stopSource;
     132    GMainLoopSource needDataSource;
     133    GMainLoopSource enoughDataSource;
     134    GMainLoopSource seekSource;
    134135
    135136    GRefPtr<GstBuffer> buffer;
     
    254255
    255256    src->priv = priv;
     257    new (priv) WebKitWebSrcPrivate();
    256258
    257259    priv->appsrc = GST_APP_SRC(gst_element_factory_make("appsrc", 0));
     
    315317
    316318    g_free(priv->uri);
     319    priv->~WebKitWebSrcPrivate();
    317320
    318321    GST_CALL_PARENT(G_OBJECT_CLASS, finalize, (object));
     
    365368    WebKitWebSrcPrivate* priv = src->priv;
    366369
    367     if (priv->startID)
    368         g_source_remove(priv->startID);
    369     priv->startID = 0;
    370 
    371     if (priv->needDataID)
    372         g_source_remove(priv->needDataID);
    373     priv->needDataID = 0;
    374 
    375     if (priv->enoughDataID)
    376         g_source_remove(priv->enoughDataID);
    377     priv->enoughDataID = 0;
    378 
    379     if (priv->seekID)
    380         g_source_remove(priv->seekID);
    381     priv->seekID = 0;
    382 }
    383 
    384 static gboolean webKitWebSrcStop(WebKitWebSrc* src)
     370    priv->startSource.cancel();
     371    priv->needDataSource.cancel();
     372    priv->enoughDataSource.cancel();
     373    priv->seekSource.cancel();
     374}
     375
     376static void webKitWebSrcStop(WebKitWebSrc* src)
    385377{
    386378    WebKitWebSrcPrivate* priv = src->priv;
     
    390382    GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    391383
    392     bool seeking = priv->seekID;
     384    bool seeking = priv->seekSource.isActive();
    393385
    394386    removeTimeoutSources(src);
    395     priv->stopID = 0;
    396387
    397388    if (priv->client) {
     
    437428
    438429    GST_DEBUG_OBJECT(src, "Stopped request");
    439 
    440     return FALSE;
    441 }
    442 
    443 static gboolean webKitWebSrcStart(WebKitWebSrc* src)
     430}
     431
     432static void webKitWebSrcStart(WebKitWebSrc* src)
    444433{
    445434    WebKitWebSrcPrivate* priv = src->priv;
     
    448437
    449438    GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    450 
    451     priv->startID = 0;
    452439
    453440    if (!priv->uri) {
     
    455442        locker.unlock();
    456443        webKitWebSrcStop(src);
    457         return FALSE;
     444        return;
    458445    }
    459446
     
    511498        locker.unlock();
    512499        webKitWebSrcStop(src);
    513         return FALSE;
     500        return;
    514501    }
    515502    GST_DEBUG_OBJECT(src, "Started request");
    516     return FALSE;
    517503}
    518504
     
    546532    case GST_STATE_CHANGE_READY_TO_PAUSED:
    547533        GST_DEBUG_OBJECT(src, "READY->PAUSED");
    548         priv->startID = g_idle_add_full(G_PRIORITY_DEFAULT, (GSourceFunc) webKitWebSrcStart, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
     534        gst_object_ref(src);
     535        priv->startSource.schedule("[WebKit] webKitWebSrcStart", std::bind(webKitWebSrcStart, src), G_PRIORITY_DEFAULT,
     536            [src] { gst_object_unref(src); });
    549537        break;
    550538    case GST_STATE_CHANGE_PAUSED_TO_READY:
     
    552540        // cancel pending sources
    553541        removeTimeoutSources(src);
    554         priv->stopID = g_idle_add_full(G_PRIORITY_DEFAULT, (GSourceFunc) webKitWebSrcStop, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
     542        gst_object_ref(src);
     543        priv->stopSource.schedule("[WebKit] webKitWebSrcStop", std::bind(webKitWebSrcStop, src), G_PRIORITY_DEFAULT,
     544            [src] { gst_object_unref(src); });
    555545        break;
    556546    default:
     
    667657// appsrc callbacks
    668658
    669 static gboolean webKitWebSrcNeedDataMainCb(WebKitWebSrc* src)
     659static void webKitWebSrcNeedDataMainCb(WebKitWebSrc* src)
    670660{
    671661    WebKitWebSrcPrivate* priv = src->priv;
     
    674664
    675665    GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    676     // already stopped
    677     if (!priv->needDataID)
    678         return FALSE;
    679 
    680666    priv->paused = FALSE;
    681     priv->needDataID = 0;
    682667    locker.unlock();
    683668
    684669    if (priv->client)
    685670        priv->client->setDefersLoading(false);
    686     return FALSE;
    687671}
    688672
     
    695679
    696680    GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    697     if (priv->needDataID || !priv->paused) {
     681    if (priv->needDataSource.isScheduled() || !priv->paused)
    698682        return;
    699     }
    700 
    701     priv->needDataID = g_idle_add_full(G_PRIORITY_DEFAULT, (GSourceFunc) webKitWebSrcNeedDataMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    702 }
    703 
    704 static gboolean webKitWebSrcEnoughDataMainCb(WebKitWebSrc* src)
     683
     684    gst_object_ref(src);
     685    priv->needDataSource.schedule("[WebKit] webKitWebSrcNeedDataMainCb", std::bind(webKitWebSrcNeedDataMainCb, src), G_PRIORITY_DEFAULT,
     686        [src] { gst_object_unref(src); });
     687}
     688
     689static void webKitWebSrcEnoughDataMainCb(WebKitWebSrc* src)
    705690{
    706691    WebKitWebSrcPrivate* priv = src->priv;
     
    709694
    710695    GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    711     // already stopped
    712     if (!priv->enoughDataID)
    713         return FALSE;
    714 
    715696    priv->paused = TRUE;
    716     priv->enoughDataID = 0;
    717697    locker.unlock();
    718698
    719699    if (priv->client)
    720700        priv->client->setDefersLoading(true);
    721     return FALSE;
    722701}
    723702
     
    730709
    731710    GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    732     if (priv->enoughDataID || priv->paused) {
     711    if (priv->enoughDataSource.isScheduled() || priv->paused)
    733712        return;
    734     }
    735 
    736     priv->enoughDataID = g_idle_add_full(G_PRIORITY_DEFAULT, (GSourceFunc) webKitWebSrcEnoughDataMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
    737 }
    738 
    739 static gboolean webKitWebSrcSeekMainCb(WebKitWebSrc* src)
    740 {
    741     WebKitWebSrcPrivate* priv = src->priv;
    742 
     713
     714    gst_object_ref(src);
     715    priv->enoughDataSource.schedule("[WebKit] webKitWebSrcEnoughDataMainCb", std::bind(webKitWebSrcEnoughDataMainCb, src), G_PRIORITY_DEFAULT,
     716        [src] { gst_object_unref(src); });
     717}
     718
     719static void webKitWebSrcSeekMainCb(WebKitWebSrc* src)
     720{
    743721    ASSERT(isMainThread());
    744 
    745     GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    746     // already stopped
    747     if (!priv->seekID)
    748         return FALSE;
    749     locker.unlock();
    750722
    751723    webKitWebSrcStop(src);
    752724    webKitWebSrcStart(src);
    753 
    754     return FALSE;
    755725}
    756726
     
    771741    priv->requestedOffset = offset;
    772742
    773     if (priv->seekID)
    774         g_source_remove(priv->seekID);
    775     priv->seekID = g_idle_add_full(G_PRIORITY_DEFAULT, (GSourceFunc) webKitWebSrcSeekMainCb, gst_object_ref(src), (GDestroyNotify) gst_object_unref);
     743    gst_object_ref(src);
     744    priv->seekSource.schedule("[WebKit] webKitWebSrcSeekMainCb", std::bind(webKitWebSrcSeekMainCb, src), G_PRIORITY_DEFAULT,
     745        [src] { gst_object_unref(src); });
    776746    return TRUE;
    777747}
     
    829799    GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    830800
    831     if (priv->seekID) {
     801    if (priv->seekSource.isActive()) {
    832802        GST_DEBUG_OBJECT(src, "Seek in progress, ignoring response");
    833803        return;
     
    933903        unmapGstBuffer(priv->buffer.get());
    934904
    935     if (priv->seekID) {
     905    if (priv->seekSource.isActive()) {
    936906        GST_DEBUG_OBJECT(src, "Seek in progress, ignoring data");
    937907        priv->buffer.clear();
     
    994964
    995965    GMutexLocker locker(GST_OBJECT_GET_LOCK(src));
    996     if (!priv->seekID) {
     966    if (!priv->seekSource.isActive()) {
    997967        locker.unlock();
    998968        gst_app_src_end_of_stream(priv->appsrc);
  • trunk/Source/WebCore/platform/gtk/GtkDragAndDropHelper.cpp

    r158103 r166052  
    2626#include "PasteboardHelper.h"
    2727#include <gtk/gtk.h>
     28#include <wtf/gobject/GMainLoopSource.h>
    2829
    2930namespace WebCore {
     
    6970}
    7071
    71 struct HandleDragLaterData {
    72     DroppingContext* context;
    73     GtkDragAndDropHelper* glue;
    74 };
    75 
    76 static gboolean handleDragLeaveLaterCallback(HandleDragLaterData* data)
    77 {
    78     data->glue->handleDragLeaveLater(data->context);
    79     delete data;
    80     return FALSE;
    81 }
    82 
    8372void GtkDragAndDropHelper::handleDragLeaveLater(DroppingContext* context)
    8473{
     
    11099    // the drag-drop signal. We want the actions for drag-leave to happen after
    111100    // those for drag-drop, so schedule them to happen asynchronously here.
    112     HandleDragLaterData* data = new HandleDragLaterData;
    113     data->context = context;
    114     data->context->exitedCallback = exitedCallback;
    115     data->glue = this;
    116     g_idle_add_full(G_PRIORITY_DEFAULT, reinterpret_cast<GSourceFunc>(handleDragLeaveLaterCallback), data, 0);
     101    context->exitedCallback = exitedCallback;
     102    GMainLoopSource::createAndDeleteOnDestroy().schedule("[WebKit] handleDragLeaveLater", std::bind(&GtkDragAndDropHelper::handleDragLeaveLater, this, context));
    117103}
    118104
  • trunk/Source/WebCore/platform/gtk/SharedTimerGtk.cpp

    r165676 r166052  
    2929#include "SharedTimer.h"
    3030
    31 #include <wtf/Assertions.h>
    32 #include <wtf/CurrentTime.h>
    3331#include <gdk/gdk.h>
    34 #include <glib.h>
     32#include <wtf/gobject/GMainLoopSource.h>
    3533
    3634namespace WebCore {
    3735
    38 static guint sharedTimer;
     36static GMainLoopSource gSharedTimer;
    3937static void (*sharedTimerFiredFunction)();
    4038
     
    4240{
    4341    sharedTimerFiredFunction = f;
    44 }
    45 
    46 static gboolean sharedTimerTimeoutCallback(gpointer)
    47 {
    48     if (sharedTimerFiredFunction)
    49         sharedTimerFiredFunction();
    50     return FALSE;
     42    if (!sharedTimerFiredFunction)
     43        gSharedTimer.cancel();
    5144}
    5245
     
    5548    ASSERT(sharedTimerFiredFunction);
    5649
    57     guint intervalInMS = static_cast<guint>(interval * 1000);
    58 
    59     stopSharedTimer();
    60     sharedTimer = g_timeout_add_full(GDK_PRIORITY_REDRAW, intervalInMS, sharedTimerTimeoutCallback, 0, 0);
    61     g_source_set_name_by_id(sharedTimer, "[WebKit] sharedTimerTimeoutCallback");
     50    gSharedTimer.scheduleAfterDelay("[WebKit] sharedTimerTimeoutCallback", sharedTimerFiredFunction,
     51        std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::duration<double>(interval)), GDK_PRIORITY_REDRAW);
    6252}
    6353
    6454void stopSharedTimer()
    6555{
    66     if (sharedTimer == 0)
    67         return;
    68 
    69     gboolean removedSource = g_source_remove(sharedTimer);
    70     ASSERT_UNUSED(removedSource, removedSource);
    71     sharedTimer = 0;
     56    gSharedTimer.cancel();
    7257}
    7358
Note: See TracChangeset for help on using the changeset viewer.