Changeset 166052 in webkit
- Timestamp:
- Mar 21, 2014 1:04:59 AM (10 years ago)
- Location:
- trunk/Source/WebCore
- Files:
-
- 15 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/WebCore/ChangeLog
r166049 r166052 1 2014-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 1 23 2014-03-21 Andreas Kling <akling@apple.com> 2 24 -
trunk/Source/WebCore/platform/audio/gstreamer/AudioFileReaderGStreamer.cpp
r163797 r166052 28 28 #include <gio/gio.h> 29 29 #include <gst/app/gstappsink.h> 30 #include <gst/audio/audio.h> 30 31 #include <gst/gst.h> 31 32 #include <gst/pbutils/pbutils.h> 32 33 #include <wtf/Noncopyable.h> 34 #include <wtf/gobject/GMainLoopSource.h> 33 35 #include <wtf/gobject/GRefPtr.h> 34 36 #include <wtf/gobject/GUniquePtr.h> 35 36 #include <gst/audio/audio.h>37 37 38 38 namespace WebCore { … … 107 107 { 108 108 reader->plugDeinterleave(pad); 109 }110 111 gboolean enteredMainLoopCallback(gpointer userData)112 {113 AudioFileReader* reader = reinterpret_cast<AudioFileReader*>(userData);114 reader->decodeAudioForBusCreation();115 return FALSE;116 109 } 117 110 … … 342 335 343 336 // 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()); 347 339 348 340 g_main_loop_run(m_loop.get()); -
trunk/Source/WebCore/platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.cpp
r159730 r166052 53 53 } 54 54 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 67 55 InbandTextTrackPrivateGStreamer::InbandTextTrackPrivateGStreamer(gint index, GRefPtr<GstPad> pad) 68 56 : InbandTextTrackPrivate(WebVTT), TrackPrivateBaseGStreamer(this, index, pad) 69 , m_sampleTimerHandler(0)70 , m_streamTimerHandler(0)71 57 { 72 58 m_eventProbe = gst_pad_add_probe(m_pad.get(), GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, … … 83 69 gst_pad_remove_probe(m_pad.get(), m_eventProbe); 84 70 85 if (m_streamTimerHandler) 86 g_source_remove(m_streamTimerHandler); 71 m_streamTimerHandler.cancel(); 87 72 88 73 TrackPrivateBaseGStreamer::disconnect(); … … 91 76 void InbandTextTrackPrivateGStreamer::handleSample(GRefPtr<GstSample> sample) 92 77 { 93 if (m_sampleTimerHandler) 94 g_source_remove(m_sampleTimerHandler); 78 m_sampleTimerHandler.cancel(); 95 79 { 96 80 MutexLocker lock(m_sampleMutex); 97 81 m_pendingSamples.append(sample); 98 82 } 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)); 101 84 } 102 85 103 86 void InbandTextTrackPrivateGStreamer::streamChanged() 104 87 { 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)); 109 89 } 110 90 111 91 void InbandTextTrackPrivateGStreamer::notifyTrackOfSample() 112 92 { 113 m_sampleTimerHandler = 0;114 115 93 Vector<GRefPtr<GstSample> > samples; 116 94 { … … 143 121 void InbandTextTrackPrivateGStreamer::notifyTrackOfStreamChanged() 144 122 { 145 m_streamTimerHandler = 0;146 147 123 GRefPtr<GstEvent> event = adoptGRef(gst_pad_get_sticky_event(m_pad.get(), 148 124 GST_EVENT_STREAM_START, 0)); -
trunk/Source/WebCore/platform/graphics/gstreamer/InbandTextTrackPrivateGStreamer.h
r162139 r166052 32 32 #include "InbandTextTrackPrivate.h" 33 33 #include "TrackPrivateBaseGStreamer.h" 34 #include <wtf/gobject/GMainLoopSource.h> 34 35 35 36 namespace WebCore { … … 62 63 InbandTextTrackPrivateGStreamer(gint index, GRefPtr<GstPad>); 63 64 64 guintm_sampleTimerHandler;65 guintm_streamTimerHandler;65 GMainLoopSource m_sampleTimerHandler; 66 GMainLoopSource m_streamTimerHandler; 66 67 gulong m_eventProbe; 67 68 Vector<GRefPtr<GstSample> > m_pendingSamples; -
trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp
r165607 r166052 59 59 // Max interval in seconds to stay in the READY state on manual 60 60 // state change requests. 61 static const guintgReadyStateTimerInterval = 60;61 static const unsigned gReadyStateTimerInterval = 60; 62 62 63 63 GST_DEBUG_CATEGORY_EXTERN(webkit_media_player_debug); … … 93 93 } 94 94 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 102 95 static void setAudioStreamPropertiesCallback(GstChildProxy*, GObject* object, gchar*, 103 96 MediaPlayerPrivateGStreamer* player) … … 106 99 } 107 100 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 122 101 #if ENABLE(VIDEO_TRACK) 123 102 static void mediaPlayerPrivateTextChangedCallback(GObject*, MediaPlayerPrivateGStreamer* player) … … 126 105 } 127 106 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 135 107 static GstFlowReturn mediaPlayerPrivateNewTextSampleCallback(GObject*, MediaPlayerPrivateGStreamer* player) 136 108 { … … 139 111 } 140 112 #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 reached146 player->changePipelineState(GST_STATE_NULL);147 return FALSE;148 }149 113 150 114 static void mediaPlayerPrivatePluginInstallerResultFunction(GstInstallPluginsReturn result, gpointer userData) … … 250 214 , m_hasVideo(false) 251 215 , m_hasAudio(false) 252 , m_audioTimerHandler(0)253 , m_textTimerHandler(0)254 , m_videoTimerHandler(0)255 , m_videoCapsTimerHandler(0)256 , m_readyTimerHandler(0)257 216 , m_totalBytes(-1) 258 217 , m_preservesPitch(false) … … 286 245 reinterpret_cast<gpointer>(setAudioStreamPropertiesCallback), this); 287 246 288 if (m_readyTimerHandler) 289 g_source_remove(m_readyTimerHandler); 247 m_readyTimerHandler.cancel(); 290 248 291 249 if (m_playBin) { … … 309 267 GRefPtr<GstPad> videoSinkPad = adoptGRef(gst_element_get_static_pad(m_webkitVideoSink.get(), "sink")); 310 268 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);323 269 } 324 270 … … 444 390 // Also lets remove the timer if we request a state change for any state other than READY. 445 391 // 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(); 452 397 } 453 398 … … 670 615 void MediaPlayerPrivateGStreamer::videoChanged() 671 616 { 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)); 676 618 } 677 619 678 620 void MediaPlayerPrivateGStreamer::videoCapsChanged() 679 621 { 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)); 684 623 } 685 624 686 625 void MediaPlayerPrivateGStreamer::notifyPlayerOfVideo() 687 626 { 688 m_videoTimerHandler = 0;689 690 627 gint numTracks = 0; 691 628 if (m_playBin) … … 725 662 void MediaPlayerPrivateGStreamer::notifyPlayerOfVideoCaps() 726 663 { 727 m_videoCapsTimerHandler = 0;728 664 m_videoSize = IntSize(); 729 665 m_player->mediaPlayerClient()->mediaPlayerEngineUpdated(m_player); … … 732 668 void MediaPlayerPrivateGStreamer::audioChanged() 733 669 { 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)); 738 671 } 739 672 740 673 void MediaPlayerPrivateGStreamer::notifyPlayerOfAudio() 741 674 { 742 m_audioTimerHandler = 0;743 744 675 gint numTracks = 0; 745 676 if (m_playBin) … … 780 711 void MediaPlayerPrivateGStreamer::textChanged() 781 712 { 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)); 786 714 } 787 715 788 716 void MediaPlayerPrivateGStreamer::notifyPlayerOfText() 789 717 { 790 m_textTimerHandler = 0;791 792 718 gint numTracks = 0; 793 719 if (m_playBin) … … 1641 1567 1642 1568 // Loading failed, remove ready timer. 1643 if (m_readyTimerHandler) { 1644 g_source_remove(m_readyTimerHandler); 1645 m_readyTimerHandler = 0; 1646 } 1569 m_readyTimerHandler.cancel(); 1647 1570 } 1648 1571 -
trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h
r164498 r166052 33 33 #include <gst/pbutils/install-plugins.h> 34 34 #include <wtf/Forward.h> 35 #include <wtf/gobject/GMainLoopSource.h> 35 36 36 37 #if ENABLE(MEDIA_SOURCE) … … 190 191 bool m_hasVideo; 191 192 bool m_hasAudio; 192 guintm_audioTimerHandler;193 guintm_textTimerHandler;194 guintm_videoTimerHandler;195 guintm_videoCapsTimerHandler;196 guintm_readyTimerHandler;193 GMainLoopSource m_audioTimerHandler; 194 GMainLoopSource m_textTimerHandler; 195 GMainLoopSource m_videoTimerHandler; 196 GMainLoopSource m_videoCapsTimerHandler; 197 GMainLoopSource m_readyTimerHandler; 197 198 mutable long m_totalBytes; 198 199 URL m_url; -
trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
r165955 r166052 73 73 } 74 74 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 82 75 static void mediaPlayerPrivateMuteChangedCallback(GObject*, GParamSpec*, MediaPlayerPrivateGStreamerBase* player) 83 76 { 84 77 // This is called when m_volumeElement receives the notify::mute signal. 85 78 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;93 79 } 94 80 … … 104 90 , m_networkState(MediaPlayer::Empty) 105 91 , m_buffer(0) 106 , m_volumeTimerHandler(0)107 , m_muteTimerHandler(0)108 92 , m_repaintHandler(0) 109 93 , m_volumeSignalHandler(0) … … 134 118 135 119 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);142 120 143 121 if (m_volumeSignalHandler) { … … 232 210 void MediaPlayerPrivateGStreamerBase::notifyPlayerOfVolumeChange() 233 211 { 234 m_volumeTimerHandler = 0;235 236 212 if (!m_player || !m_volumeElement) 237 213 return; … … 247 223 void MediaPlayerPrivateGStreamerBase::volumeChanged() 248 224 { 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)); 253 226 } 254 227 … … 288 261 void MediaPlayerPrivateGStreamerBase::notifyPlayerOfMute() 289 262 { 290 m_muteTimerHandler = 0;291 292 263 if (!m_player || !m_volumeElement) 293 264 return; … … 300 271 void MediaPlayerPrivateGStreamerBase::muteChanged() 301 272 { 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 } 308 275 309 276 #if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS) -
trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.h
r163435 r166052 31 31 32 32 #include <wtf/Forward.h> 33 #include <wtf/gobject/GMainLoopSource.h> 33 34 34 35 #if USE(TEXTURE_MAPPER_GL) && !USE(COORDINATED_GRAPHICS) … … 120 121 GMutex* m_bufferMutex; 121 122 GstBuffer* m_buffer; 122 unsigned longm_volumeTimerHandler;123 unsigned longm_muteTimerHandler;123 GMainLoopSource m_volumeTimerHandler; 124 GMainLoopSource m_muteTimerHandler; 124 125 unsigned long m_repaintHandler; 125 126 unsigned long m_volumeSignalHandler; -
trunk/Source/WebCore/platform/graphics/gstreamer/TrackPrivateBaseGStreamer.cpp
r165763 r166052 54 54 } 55 55 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 68 56 TrackPrivateBaseGStreamer::TrackPrivateBaseGStreamer(TrackPrivateBase* owner, gint index, GRefPtr<GstPad> pad) 69 57 : m_index(index) 70 58 , m_pad(pad) 71 59 , m_owner(owner) 72 , m_activeTimerHandler(0)73 , m_tagTimerHandler(0)74 60 { 75 61 ASSERT(m_pad); … … 98 84 reinterpret_cast<gpointer>(trackPrivateTagsChangedCallback), this); 99 85 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(); 107 88 108 89 m_pad.clear(); … … 112 93 void TrackPrivateBaseGStreamer::activeChanged() 113 94 { 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)); 119 96 } 120 97 121 98 void TrackPrivateBaseGStreamer::tagsChanged() 122 99 { 123 if (m_tagTimerHandler) 124 g_source_remove(m_tagTimerHandler); 100 m_tagTimerHandler.cancel(); 125 101 126 102 GRefPtr<GstTagList> tags; … … 131 107 } 132 108 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)); 136 110 } 137 111 138 112 void TrackPrivateBaseGStreamer::notifyTrackOfActiveChanged() 139 113 { 140 m_activeTimerHandler = 0;141 114 if (!m_pad) 142 115 return; … … 176 149 void TrackPrivateBaseGStreamer::notifyTrackOfTagsChanged() 177 150 { 178 m_tagTimerHandler = 0;179 151 if (!m_pad) 180 152 return; -
trunk/Source/WebCore/platform/graphics/gstreamer/TrackPrivateBaseGStreamer.h
r165763 r166052 31 31 #include "GRefPtrGStreamer.h" 32 32 #include <wtf/ThreadingPrimitives.h> 33 #include <wtf/gobject/GMainLoopSource.h> 33 34 #include <wtf/text/WTFString.h> 34 35 … … 68 69 69 70 TrackPrivateBase* m_owner; 70 guintm_activeTimerHandler;71 guintm_tagTimerHandler;71 GMainLoopSource m_activeTimerHandler; 72 GMainLoopSource m_tagTimerHandler; 72 73 73 74 Mutex m_tagMutex; -
trunk/Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp
r160593 r166052 37 37 #include <gst/video/gstvideometa.h> 38 38 #include <wtf/OwnPtr.h> 39 #include <wtf/gobject/GMainLoopSource.h> 39 40 #include <wtf/gobject/GMutexLocker.h> 40 41 … … 75 76 struct _WebKitVideoSinkPrivate { 76 77 GstBuffer* buffer; 77 guint timeoutId;78 GMainLoopSource timeoutSource; 78 79 GMutex* bufferMutex; 79 80 GCond* dataCondition; … … 101 102 { 102 103 sink->priv = G_TYPE_INSTANCE_GET_PRIVATE(sink, WEBKIT_TYPE_VIDEO_SINK, WebKitVideoSinkPrivate); 104 new (sink->priv) WebKitVideoSinkPrivate(); 103 105 #if GLIB_CHECK_VERSION(2, 31, 0) 104 106 sink->priv->dataCondition = new GCond; … … 114 116 } 115 117 116 static gboolean webkitVideoSinkTimeoutCallback(gpointer data) 117 { 118 WebKitVideoSink* sink = reinterpret_cast<WebKitVideoSink*>(data); 118 static void webkitVideoSinkTimeoutCallback(WebKitVideoSink* sink) 119 { 119 120 WebKitVideoSinkPrivate* priv = sink->priv; 120 121 … … 122 123 GstBuffer* buffer = priv->buffer; 123 124 priv->buffer = 0; 124 priv->timeoutId = 0;125 125 126 126 if (!buffer || priv->unlocked || UNLIKELY(!GST_IS_BUFFER(buffer))) { 127 127 g_cond_signal(priv->dataCondition); 128 return FALSE;128 return; 129 129 } 130 130 … … 132 132 gst_buffer_unref(buffer); 133 133 g_cond_signal(priv->dataCondition); 134 135 return FALSE;136 134 } 137 135 … … 217 215 // lower priority sources. 218 216 // 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); }); 222 220 223 221 g_cond_wait(priv->dataCondition, priv->bufferMutex); … … 251 249 252 250 G_OBJECT_CLASS(parent_class)->dispose(object); 251 } 252 253 static void webkitVideoSinkFinalize(GObject* object) 254 { 255 WEBKIT_VIDEO_SINK(object)->priv->~WebKitVideoSinkPrivate(); 256 G_OBJECT_CLASS(parent_class)->finalize(object); 253 257 } 254 258 … … 377 381 378 382 gobjectClass->dispose = webkitVideoSinkDispose; 383 gobjectClass->finalize = webkitVideoSinkFinalize; 379 384 gobjectClass->get_property = webkitVideoSinkGetProperty; 380 385 -
trunk/Source/WebCore/platform/graphics/gstreamer/WebKitMediaSourceGStreamer.cpp
r165891 r166052 31 31 #include <gst/gst.h> 32 32 #include <gst/pbutils/missing-plugins.h> 33 #include <wtf/gobject/GMainLoopSource.h> 33 34 #include <wtf/gobject/GUniquePtr.h> 34 35 #include <wtf/text/CString.h> … … 44 45 gboolean paused; 45 46 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; 51 52 52 53 guint64 requestedOffset; … … 173 174 WebKitMediaSrcPrivate* priv = WEBKIT_MEDIA_SRC_GET_PRIVATE(src); 174 175 src->priv = priv; 176 new (priv) WebKitMediaSrcPrivate(); 175 177 176 178 priv->sourceVideo.appsrc = gst_element_factory_make("appsrc", "videoappsrc"); … … 189 191 190 192 g_free(priv->uri); 193 priv->~WebKitMediaSrcPrivate(); 191 194 192 195 GST_CALL_PARENT(G_OBJECT_CLASS, finalize, (object)); … … 224 227 225 228 // must be called on main thread and with object unlocked 226 static gbooleanwebKitMediaVideoSrcStop(WebKitMediaSrc* src)229 static void webKitMediaVideoSrcStop(WebKitMediaSrc* src) 227 230 { 228 231 WebKitMediaSrcPrivate* priv = src->priv; … … 231 234 GST_OBJECT_LOCK(src); 232 235 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(); 239 239 240 240 priv->player = 0; 241 241 priv->playbin = 0; 242 242 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(); 255 246 256 247 priv->sourceVideo.paused = FALSE; … … 260 251 priv->duration = 0; 261 252 priv->nbSource = 0; 262 263 priv->sourceVideo.stopId = 0;264 253 265 254 GST_OBJECT_UNLOCK(src); … … 272 261 273 262 GST_DEBUG_OBJECT(src, "Stopped request"); 274 275 return FALSE; 276 } 277 278 static gboolean webKitMediaAudioSrcStop(WebKitMediaSrc* src) 263 } 264 265 static void webKitMediaAudioSrcStop(WebKitMediaSrc* src) 279 266 { 280 267 WebKitMediaSrcPrivate* priv = src->priv; … … 283 270 GST_OBJECT_LOCK(src); 284 271 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(); 291 275 292 276 priv->player = 0; … … 294 278 priv->playbin = 0; 295 279 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(); 308 283 309 284 priv->sourceAudio.paused = FALSE; … … 315 290 priv->duration = 0; 316 291 priv->nbSource = 0; 317 318 priv->sourceAudio.stopId = 0;319 292 320 293 GST_OBJECT_UNLOCK(src); … … 327 300 328 301 GST_DEBUG_OBJECT(src, "Stopped request"); 329 330 return FALSE;331 302 } 332 303 333 304 // must be called on main thread and with object unlocked 334 static gbooleanwebKitMediaVideoSrcStart(WebKitMediaSrc* src)305 static void webKitMediaVideoSrcStart(WebKitMediaSrc* src) 335 306 { 336 307 WebKitMediaSrcPrivate* priv = src->priv; … … 341 312 GST_OBJECT_UNLOCK(src); 342 313 webKitMediaVideoSrcStop(src); 343 return FALSE; 344 } 345 346 priv->sourceVideo.startId = 0; 314 return; 315 } 347 316 348 317 GST_OBJECT_UNLOCK(src); 349 318 GST_DEBUG_OBJECT(src, "Started request"); 350 351 return FALSE;352 319 } 353 320 354 321 // must be called on main thread and with object unlocked 355 static gbooleanwebKitMediaAudioSrcStart(WebKitMediaSrc* src)322 static void webKitMediaAudioSrcStart(WebKitMediaSrc* src) 356 323 { 357 324 WebKitMediaSrcPrivate* priv = src->priv; … … 362 329 GST_OBJECT_UNLOCK(src); 363 330 webKitMediaAudioSrcStop(src); 364 return FALSE; 365 } 366 367 priv->sourceAudio.startId = 0; 331 return; 332 } 368 333 369 334 GST_OBJECT_UNLOCK(src); 370 335 GST_DEBUG_OBJECT(src, "Started request"); 371 372 return FALSE;373 336 } 374 337 … … 402 365 GST_DEBUG_OBJECT(src, "READY->PAUSED"); 403 366 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 408 376 GST_OBJECT_UNLOCK(src); 409 377 break; … … 411 379 GST_DEBUG_OBJECT(src, "PAUSED->READY"); 412 380 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 417 390 GST_OBJECT_UNLOCK(src); 418 391 break; … … 520 493 521 494 // 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 495 static void webKitMediaVideoSrcNeedDataMainCb(WebKitMediaSrc* src) 496 { 497 WebKitMediaSrcPrivate* priv = src->priv; 498 499 GST_OBJECT_LOCK(src); 533 500 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 504 static void webKitMediaAudioSrcNeedDataMainCb(WebKitMediaSrc* src) 505 { 506 WebKitMediaSrcPrivate* priv = src->priv; 507 508 GST_OBJECT_LOCK(src); 551 509 priv->sourceAudio.paused = FALSE; 552 priv->sourceAudio.needDataId = 0; 553 GST_OBJECT_UNLOCK(src); 554 555 return FALSE; 510 GST_OBJECT_UNLOCK(src); 556 511 } 557 512 … … 564 519 565 520 GST_OBJECT_LOCK(src); 566 if (priv->sourceVideo.needData Id|| !priv->sourceVideo.paused) {521 if (priv->sourceVideo.needData.isScheduled() || !priv->sourceVideo.paused) { 567 522 GST_OBJECT_UNLOCK(src); 568 523 return; 569 524 } 570 525 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); }); 573 529 GST_OBJECT_UNLOCK(src); 574 530 } … … 582 538 583 539 GST_OBJECT_LOCK(src); 584 if (priv->sourceAudio.needData Id|| !priv->sourceAudio.paused) {540 if (priv->sourceAudio.needData.isScheduled() || !priv->sourceAudio.paused) { 585 541 GST_OBJECT_UNLOCK(src); 586 542 return; 587 543 } 588 544 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 551 static void webKitMediaVideoSrcEnoughDataMainCb(WebKitMediaSrc* src) 552 { 553 WebKitMediaSrcPrivate* priv = src->priv; 554 555 GST_OBJECT_LOCK(src); 605 556 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 560 static void webKitMediaAudioSrcEnoughDataMainCb(WebKitMediaSrc* src) 561 { 562 WebKitMediaSrcPrivate* priv = src->priv; 563 564 GST_OBJECT_LOCK(src); 623 565 priv->sourceAudio.paused = TRUE; 624 priv->sourceAudio.enoughDataId = 0; 625 GST_OBJECT_UNLOCK(src); 626 627 return FALSE; 566 GST_OBJECT_UNLOCK(src); 628 567 } 629 568 … … 636 575 637 576 GST_OBJECT_LOCK(src); 638 if (priv->sourceVideo.enoughData Id|| priv->sourceVideo.paused) {577 if (priv->sourceVideo.enoughData.isScheduled() || priv->sourceVideo.paused) { 639 578 GST_OBJECT_UNLOCK(src); 640 579 return; 641 580 } 642 581 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 645 586 GST_OBJECT_UNLOCK(src); 646 587 } … … 654 595 655 596 GST_OBJECT_LOCK(src); 656 if (priv->sourceAudio.enoughData Id|| priv->sourceAudio.paused) {597 if (priv->sourceAudio.enoughData.isScheduled() || priv->sourceAudio.paused) { 657 598 GST_OBJECT_UNLOCK(src); 658 599 return; 659 600 } 660 601 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 609 static void webKitMediaVideoSrcSeekMainCb(WebKitMediaSrc*) 667 610 { 668 611 notImplemented(); 669 src->priv->sourceVideo.seekId = 0; 670 return FALSE; 671 } 672 673 static gboolean webKitMediaAudioSrcSeekMainCb(WebKitMediaSrc* src) 612 } 613 614 615 static void webKitMediaAudioSrcSeekMainCb(WebKitMediaSrc*) 674 616 { 675 617 notImplemented(); 676 src->priv->sourceAudio.seekId = 0;677 return FALSE;678 618 } 679 619 … … 702 642 priv->sourceVideo.requestedOffset = offset; 703 643 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 708 648 GST_OBJECT_UNLOCK(src); 709 649 … … 735 675 priv->sourceAudio.requestedOffset = offset; 736 676 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 741 681 GST_OBJECT_UNLOCK(src); 742 682 … … 823 763 824 764 GST_OBJECT_LOCK(m_src); 825 if (!priv->sourceVideo.seek Id) {765 if (!priv->sourceVideo.seek.isActive()) { 826 766 GST_OBJECT_UNLOCK(m_src); 827 767 gst_app_src_end_of_stream(GST_APP_SRC(priv->sourceVideo.appsrc)); … … 830 770 831 771 GST_OBJECT_LOCK(m_src); 832 if (!priv->sourceAudio.seek Id) {772 if (!priv->sourceAudio.seek.isActive()) { 833 773 GST_OBJECT_UNLOCK(m_src); 834 774 gst_app_src_end_of_stream(GST_APP_SRC(priv->sourceAudio.appsrc)); -
trunk/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp
r165688 r166052 41 41 #include <gst/pbutils/missing-plugins.h> 42 42 #include <wtf/Noncopyable.h> 43 #include <wtf/gobject/GMainLoopSource.h> 43 44 #include <wtf/gobject/GMutexLocker.h> 44 45 #include <wtf/gobject/GRefPtr.h> … … 127 128 guint64 requestedOffset; 128 129 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; 134 135 135 136 GRefPtr<GstBuffer> buffer; … … 254 255 255 256 src->priv = priv; 257 new (priv) WebKitWebSrcPrivate(); 256 258 257 259 priv->appsrc = GST_APP_SRC(gst_element_factory_make("appsrc", 0)); … … 315 317 316 318 g_free(priv->uri); 319 priv->~WebKitWebSrcPrivate(); 317 320 318 321 GST_CALL_PARENT(G_OBJECT_CLASS, finalize, (object)); … … 365 368 WebKitWebSrcPrivate* priv = src->priv; 366 369 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 376 static void webKitWebSrcStop(WebKitWebSrc* src) 385 377 { 386 378 WebKitWebSrcPrivate* priv = src->priv; … … 390 382 GMutexLocker locker(GST_OBJECT_GET_LOCK(src)); 391 383 392 bool seeking = priv->seek ID;384 bool seeking = priv->seekSource.isActive(); 393 385 394 386 removeTimeoutSources(src); 395 priv->stopID = 0;396 387 397 388 if (priv->client) { … … 437 428 438 429 GST_DEBUG_OBJECT(src, "Stopped request"); 439 440 return FALSE; 441 } 442 443 static gboolean webKitWebSrcStart(WebKitWebSrc* src) 430 } 431 432 static void webKitWebSrcStart(WebKitWebSrc* src) 444 433 { 445 434 WebKitWebSrcPrivate* priv = src->priv; … … 448 437 449 438 GMutexLocker locker(GST_OBJECT_GET_LOCK(src)); 450 451 priv->startID = 0;452 439 453 440 if (!priv->uri) { … … 455 442 locker.unlock(); 456 443 webKitWebSrcStop(src); 457 return FALSE;444 return; 458 445 } 459 446 … … 511 498 locker.unlock(); 512 499 webKitWebSrcStop(src); 513 return FALSE;500 return; 514 501 } 515 502 GST_DEBUG_OBJECT(src, "Started request"); 516 return FALSE;517 503 } 518 504 … … 546 532 case GST_STATE_CHANGE_READY_TO_PAUSED: 547 533 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); }); 549 537 break; 550 538 case GST_STATE_CHANGE_PAUSED_TO_READY: … … 552 540 // cancel pending sources 553 541 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); }); 555 545 break; 556 546 default: … … 667 657 // appsrc callbacks 668 658 669 static gbooleanwebKitWebSrcNeedDataMainCb(WebKitWebSrc* src)659 static void webKitWebSrcNeedDataMainCb(WebKitWebSrc* src) 670 660 { 671 661 WebKitWebSrcPrivate* priv = src->priv; … … 674 664 675 665 GMutexLocker locker(GST_OBJECT_GET_LOCK(src)); 676 // already stopped677 if (!priv->needDataID)678 return FALSE;679 680 666 priv->paused = FALSE; 681 priv->needDataID = 0;682 667 locker.unlock(); 683 668 684 669 if (priv->client) 685 670 priv->client->setDefersLoading(false); 686 return FALSE;687 671 } 688 672 … … 695 679 696 680 GMutexLocker locker(GST_OBJECT_GET_LOCK(src)); 697 if (priv->needData ID || !priv->paused) {681 if (priv->needDataSource.isScheduled() || !priv->paused) 698 682 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 689 static void webKitWebSrcEnoughDataMainCb(WebKitWebSrc* src) 705 690 { 706 691 WebKitWebSrcPrivate* priv = src->priv; … … 709 694 710 695 GMutexLocker locker(GST_OBJECT_GET_LOCK(src)); 711 // already stopped712 if (!priv->enoughDataID)713 return FALSE;714 715 696 priv->paused = TRUE; 716 priv->enoughDataID = 0;717 697 locker.unlock(); 718 698 719 699 if (priv->client) 720 700 priv->client->setDefersLoading(true); 721 return FALSE;722 701 } 723 702 … … 730 709 731 710 GMutexLocker locker(GST_OBJECT_GET_LOCK(src)); 732 if (priv->enoughData ID || priv->paused) {711 if (priv->enoughDataSource.isScheduled() || priv->paused) 733 712 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 719 static void webKitWebSrcSeekMainCb(WebKitWebSrc* src) 720 { 743 721 ASSERT(isMainThread()); 744 745 GMutexLocker locker(GST_OBJECT_GET_LOCK(src));746 // already stopped747 if (!priv->seekID)748 return FALSE;749 locker.unlock();750 722 751 723 webKitWebSrcStop(src); 752 724 webKitWebSrcStart(src); 753 754 return FALSE;755 725 } 756 726 … … 771 741 priv->requestedOffset = offset; 772 742 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); }); 776 746 return TRUE; 777 747 } … … 829 799 GMutexLocker locker(GST_OBJECT_GET_LOCK(src)); 830 800 831 if (priv->seek ID) {801 if (priv->seekSource.isActive()) { 832 802 GST_DEBUG_OBJECT(src, "Seek in progress, ignoring response"); 833 803 return; … … 933 903 unmapGstBuffer(priv->buffer.get()); 934 904 935 if (priv->seek ID) {905 if (priv->seekSource.isActive()) { 936 906 GST_DEBUG_OBJECT(src, "Seek in progress, ignoring data"); 937 907 priv->buffer.clear(); … … 994 964 995 965 GMutexLocker locker(GST_OBJECT_GET_LOCK(src)); 996 if (!priv->seek ID) {966 if (!priv->seekSource.isActive()) { 997 967 locker.unlock(); 998 968 gst_app_src_end_of_stream(priv->appsrc); -
trunk/Source/WebCore/platform/gtk/GtkDragAndDropHelper.cpp
r158103 r166052 26 26 #include "PasteboardHelper.h" 27 27 #include <gtk/gtk.h> 28 #include <wtf/gobject/GMainLoopSource.h> 28 29 29 30 namespace WebCore { … … 69 70 } 70 71 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 83 72 void GtkDragAndDropHelper::handleDragLeaveLater(DroppingContext* context) 84 73 { … … 110 99 // the drag-drop signal. We want the actions for drag-leave to happen after 111 100 // 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)); 117 103 } 118 104 -
trunk/Source/WebCore/platform/gtk/SharedTimerGtk.cpp
r165676 r166052 29 29 #include "SharedTimer.h" 30 30 31 #include <wtf/Assertions.h>32 #include <wtf/CurrentTime.h>33 31 #include <gdk/gdk.h> 34 #include < glib.h>32 #include <wtf/gobject/GMainLoopSource.h> 35 33 36 34 namespace WebCore { 37 35 38 static guint sharedTimer;36 static GMainLoopSource gSharedTimer; 39 37 static void (*sharedTimerFiredFunction)(); 40 38 … … 42 40 { 43 41 sharedTimerFiredFunction = f; 44 } 45 46 static gboolean sharedTimerTimeoutCallback(gpointer) 47 { 48 if (sharedTimerFiredFunction) 49 sharedTimerFiredFunction(); 50 return FALSE; 42 if (!sharedTimerFiredFunction) 43 gSharedTimer.cancel(); 51 44 } 52 45 … … 55 48 ASSERT(sharedTimerFiredFunction); 56 49 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); 62 52 } 63 53 64 54 void stopSharedTimer() 65 55 { 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(); 72 57 } 73 58
Note: See TracChangeset
for help on using the changeset viewer.