De-templatize Timer
authorjer.noble@apple.com <jer.noble@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 6 Nov 2014 23:06:03 +0000 (23:06 +0000)
committerjer.noble@apple.com <jer.noble@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 6 Nov 2014 23:06:03 +0000 (23:06 +0000)
https://bugs.webkit.org/show_bug.cgi?id=138450

Reviewed by Anders Carlsson.

Source/WebCore:

Timer does not need to be a templated class; only it's constructors need to be templated.
Remove the template specifier from Timer and add same to its two class method
constructors. Replace the function pointer typedefs with using statements. Add a
helper typedef which allows invalid combinations of TimerFiredClass and
TimerFiredFunction to be caught early by the compiler, while still allowing
valid combinations (such as when the caller specifies a function on a subclass of
TimerFiredClass).

* Modules/encryptedmedia/MediaKeySession.cpp:
(WebCore::MediaKeySession::keyRequestTimerFired):
(WebCore::MediaKeySession::addKeyTimerFired):
* Modules/encryptedmedia/MediaKeySession.h:
* Modules/geolocation/Geolocation.cpp:
(WebCore::Geolocation::GeoNotifier::timerFired):
(WebCore::Geolocation::resumeTimerFired):
* Modules/geolocation/Geolocation.h:
* Modules/indexeddb/IDBTransactionBackend.cpp:
(WebCore::IDBTransactionBackend::taskTimerFired):
* Modules/indexeddb/IDBTransactionBackend.h:
* Modules/mediasource/SourceBuffer.cpp:
(WebCore::SourceBuffer::appendBufferTimerFired):
(WebCore::SourceBuffer::removeTimerFired):
* Modules/mediasource/SourceBuffer.h:
* Modules/mediastream/MediaStream.cpp:
(WebCore::MediaStream::scheduledEventTimerFired):
* Modules/mediastream/MediaStream.h:
* Modules/mediastream/RTCDTMFSender.cpp:
(WebCore::RTCDTMFSender::scheduledEventTimerFired):
* Modules/mediastream/RTCDTMFSender.h:
* Modules/mediastream/RTCDataChannel.cpp:
(WebCore::RTCDataChannel::scheduledEventTimerFired):
* Modules/mediastream/RTCDataChannel.h:
* Modules/mediastream/RTCPeerConnection.cpp:
(WebCore::RTCPeerConnection::scheduledEventTimerFired):
* Modules/mediastream/RTCPeerConnection.h:
* Modules/notifications/Notification.cpp:
(WebCore::Notification::Notification):
(WebCore::Notification::taskTimerFired):
* Modules/notifications/Notification.h:
* Modules/notifications/NotificationCenter.cpp:
(WebCore::NotificationCenter::NotificationRequestCallback::timerFired):
* Modules/notifications/NotificationCenter.h:
* Modules/vibration/Vibration.cpp:
(WebCore::Vibration::timerFired):
* Modules/vibration/Vibration.h:
* Modules/websockets/WebSocketChannel.cpp:
(WebCore::WebSocketChannel::resumeTimerFired):
(WebCore::WebSocketChannel::closingTimerFired):
* Modules/websockets/WebSocketChannel.h:
* accessibility/AXObjectCache.cpp:
(WebCore::AXObjectCache::notificationPostTimerFired):
* accessibility/AXObjectCache.h:
(WebCore::AXObjectCache::AXObjectCache):
* bindings/js/GCController.cpp:
(WebCore::GCController::gcTimerFired):
* bindings/js/GCController.h:
* css/CSSFontFaceSource.h:
* css/CSSFontSelector.cpp:
(WebCore::CSSFontSelector::beginLoadTimerFired):
* css/CSSFontSelector.h:
* css/StyleResolver.cpp:
(WebCore::StyleResolver::sweepMatchedPropertiesCache):
* css/StyleResolver.h:
* dom/Document.cpp:
(WebCore::Document::visualUpdatesSuppressionTimerFired):
(WebCore::Document::styleRecalcTimerFired):
(WebCore::Document::optimizedStyleSheetUpdateTimerFired):
(WebCore::Document::sharedObjectPoolClearTimerFired):
(WebCore::Document::updateFocusAppearanceTimerFired):
(WebCore::Document::pendingTasksTimerFired):
(WebCore::Document::fullScreenChangeDelayTimerFired):
(WebCore::Document::loadEventDelayTimerFired):
(WebCore::Document::didAssociateFormControlsTimerFired):
(WebCore::Document::domCookieCacheExpiryTimerFired):
* dom/Document.h:
* dom/EventSender.h:
(WebCore::EventSender::timerFired):
* dom/GenericEventQueue.cpp:
(WebCore::GenericEventQueue::timerFired):
* dom/GenericEventQueue.h:
* dom/ScriptRunner.cpp:
(WebCore::ScriptRunner::timerFired):
* dom/ScriptRunner.h:
* dom/ScriptedAnimationController.cpp:
(WebCore::ScriptedAnimationController::animationTimerFired):
* dom/ScriptedAnimationController.h:
* dom/StyledElement.cpp:
(WebCore::PresentationAttributeCacheCleaner::cleanCache):
* editing/AlternativeTextController.cpp:
(WebCore::AlternativeTextController::timerFired):
* editing/AlternativeTextController.h:
* editing/Editor.cpp:
(WebCore::Editor::scanSelectionForTelephoneNumbers):
(WebCore::Editor::editorUIUpdateTimerFired):
* editing/Editor.h:
* editing/FrameSelection.cpp:
(WebCore::FrameSelection::caretBlinkTimerFired):
* editing/FrameSelection.h:
* editing/SpellChecker.cpp:
(WebCore::SpellChecker::timerFiredToProcessQueuedRequest):
* editing/SpellChecker.h:
* html/HTMLFormElement.cpp:
(WebCore::HTMLFormElement::requestAutocompleteTimerFired):
* html/HTMLFormElement.h:
* html/HTMLMediaElement.cpp:
(WebCore::HTMLMediaElement::parseAttribute):
* html/HTMLMediaElement.h:
* html/HTMLPlugInElement.cpp:
(WebCore::HTMLPlugInElement::swapRendererTimerFired):
* html/HTMLPlugInElement.h:
* html/HTMLPlugInImageElement.cpp:
(WebCore::HTMLPlugInImageElement::removeSnapshotTimerFired):
* html/HTMLPlugInImageElement.h:
* html/HTMLSourceElement.cpp:
(WebCore::HTMLSourceElement::errorEventTimerFired):
* html/HTMLSourceElement.h:
* html/HTMLTrackElement.cpp:
(WebCore::HTMLTrackElement::loadTimerFired):
* html/HTMLTrackElement.h:
* html/MediaController.cpp:
(MediaController::asyncEventTimerFired):
(MediaController::clearPositionTimerFired):
(MediaController::timeupdateTimerFired):
* html/MediaController.h:
* html/MediaDocument.cpp:
(WebCore::MediaDocument::replaceMediaElementTimerFired):
* html/MediaDocument.h:
* html/SearchInputType.cpp:
(WebCore::SearchInputType::searchEventTimerFired):
* html/SearchInputType.h:
* html/ValidationMessage.cpp:
(WebCore::ValidationMessage::setMessage):
(WebCore::ValidationMessage::setMessageDOMAndStartTimer):
(WebCore::ValidationMessage::buildBubbleTree):
(WebCore::ValidationMessage::requestToHideMessage):
(WebCore::ValidationMessage::deleteBubbleTree):
* html/ValidationMessage.h:
* html/canvas/WebGLRenderingContext.cpp:
(WebCore::WebGLRenderingContext::dispatchContextLostEvent):
(WebCore::WebGLRenderingContext::maybeRestoreContext):
* html/canvas/WebGLRenderingContext.h:
* html/parser/HTMLParserScheduler.cpp:
(WebCore::HTMLParserScheduler::continueNextChunkTimerFired):
* html/parser/HTMLParserScheduler.h:
* html/shadow/MediaControlElements.cpp:
(WebCore::MediaControlPanelElement::transitionTimerFired):
(WebCore::MediaControlTextTrackContainerElement::updateTimerFired):
* html/shadow/MediaControlElements.h:
* html/shadow/MediaControls.cpp:
(WebCore::MediaControls::hideFullscreenControlsTimerFired):
* html/shadow/MediaControls.h:
* html/shadow/SpinButtonElement.cpp:
(WebCore::SpinButtonElement::repeatingTimerFired):
* html/shadow/SpinButtonElement.h:
* html/track/LoadableTextTrack.cpp:
(WebCore::LoadableTextTrack::loadTimerFired):
* html/track/LoadableTextTrack.h:
* html/track/VTTRegion.cpp:
(WebCore::VTTRegion::scrollTimerFired):
* html/track/VTTRegion.h:
* inspector/InspectorCSSAgent.cpp:
(WebCore::ChangeRegionOversetTask::timerFired):
* inspector/InspectorDOMAgent.cpp:
(WebCore::RevalidateStyleAttributeTask::timerFired):
* inspector/InspectorFrontendClientLocal.cpp:
(WebCore::InspectorBackendDispatchTask::timerFired):
* inspector/InspectorOverlay.cpp:
(WebCore::InspectorOverlay::updatePaintRectsTimerFired):
* inspector/InspectorOverlay.h:
* loader/DocumentLoader.cpp:
(WebCore::DocumentLoader::substituteResourceDeliveryTimerFired):
* loader/DocumentLoader.h:
* loader/FrameLoader.cpp:
(WebCore::FrameLoader::checkTimerFired):
* loader/FrameLoader.h:
* loader/ImageLoader.cpp:
(WebCore::ImageLoader::timerFired):
* loader/ImageLoader.h:
* loader/LinkLoader.cpp:
(WebCore::LinkLoader::linkLoadTimerFired):
(WebCore::LinkLoader::linkLoadingErrorTimerFired):
* loader/LinkLoader.h:
* loader/NavigationScheduler.cpp:
(WebCore::ScheduledNavigation::didStartTimer):
(WebCore::NavigationScheduler::timerFired):
* loader/NavigationScheduler.h:
* loader/PingLoader.h:
(WebCore::PingLoader::timeoutTimerFired):
* loader/ProgressTracker.cpp:
(WebCore::ProgressTracker::progressHeartbeatTimerFired):
* loader/ProgressTracker.h:
* loader/ResourceLoadScheduler.cpp:
(WebCore::ResourceLoadScheduler::requestTimerFired):
* loader/ResourceLoadScheduler.h:
* loader/TextTrackLoader.cpp:
(WebCore::TextTrackLoader::cueLoadTimerFired):
* loader/TextTrackLoader.h:
* loader/cache/CachedResource.cpp:
(WebCore::CachedResource::Callback::timerFired):
* loader/cache/CachedResource.h:
* loader/cache/CachedResourceLoader.cpp:
(WebCore::CachedResourceLoader::garbageCollectDocumentResourcesTimerFired):
* loader/cache/CachedResourceLoader.h:
* loader/icon/IconDatabase.cpp:
(WebCore::IconDatabase::syncTimerFired):
* loader/icon/IconDatabase.h:
* page/AutoscrollController.cpp:
(WebCore::AutoscrollController::autoscrollTimerFired):
* page/AutoscrollController.h:
* page/CaptionUserPreferences.cpp:
(WebCore::CaptionUserPreferences::timerFired):
* page/CaptionUserPreferences.h:
* page/CaptionUserPreferencesMediaAF.cpp:
(WebCore::CaptionUserPreferencesMediaAF::updateTimerFired):
* page/CaptionUserPreferencesMediaAF.h:
* page/DeviceController.cpp:
(WebCore::DeviceController::fireDeviceEvent):
* page/DeviceController.h:
* page/EventHandler.cpp:
(WebCore::EventHandler::cursorUpdateTimerFired):
(WebCore::EventHandler::autoHideCursorTimerFired):
(WebCore::EventHandler::recognizeLongMousePress):
(WebCore::EventHandler::fakeMouseMoveEventTimerFired):
(WebCore::EventHandler::hoverTimerFired):
* page/EventHandler.h:
* page/EventSource.cpp:
(WebCore::EventSource::connectTimerFired):
* page/EventSource.h:
* page/FocusController.cpp:
(WebCore::FocusController::focusRepaintTimerFired):
* page/FocusController.h:
* page/Frame.cpp:
(WebCore::Frame::overflowAutoScrollTimerFired):
* page/Frame.h:
* page/FrameView.cpp:
(WebCore::FrameView::delayedScrollEventTimerFired):
(WebCore::FrameView::speculativeTilingEnableTimerFired):
(WebCore::FrameView::layoutTimerFired):
(WebCore::FrameView::updateEmbeddedObjectsTimerFired):
(WebCore::FrameView::postLayoutTimerFired):
* page/FrameView.h:
* page/PageOverlay.cpp:
(WebCore::PageOverlay::fadeAnimationTimerFired):
* page/PageOverlay.h:
* page/Settings.cpp:
(WebCore::Settings::imageLoadingSettingsTimerFired):
* page/Settings.h:
* page/animation/AnimationController.cpp:
(WebCore::AnimationControllerPrivate::updateStyleIfNeededDispatcherFired):
(WebCore::AnimationControllerPrivate::animationTimerFired):
* page/animation/AnimationControllerPrivate.h:
* page/mac/ServicesOverlayController.h:
* page/mac/ServicesOverlayController.mm:
(WebCore::ServicesOverlayController::determineActiveHighlightTimerFired):
* page/scrolling/AsyncScrollingCoordinator.cpp:
(WebCore::AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired):
* page/scrolling/AsyncScrollingCoordinator.h:
* page/scrolling/ios/ScrollingCoordinatorIOS.h:
* page/scrolling/ios/ScrollingCoordinatorIOS.mm:
(WebCore::ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired):
* page/scrolling/mac/ScrollingCoordinatorMac.h:
* page/scrolling/mac/ScrollingCoordinatorMac.mm:
(WebCore::ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired):
* platform/HysteresisActivity.h:
(WebCore::HysteresisActivity::hysteresisTimerFired):
* platform/ScrollAnimator.cpp:
(WebCore::ScrollAnimator::updateScrollAnimatorsAndTimers):
(WebCore::ScrollAnimator::startScrollSnapTimer):
(WebCore::ScrollAnimator::stopScrollSnapTimer):
(WebCore::ScrollAnimator::horizontalScrollSnapTimerFired):
(WebCore::ScrollAnimator::verticalScrollSnapTimerFired):
* platform/ScrollAnimator.h:
* platform/ScrollAnimatorNone.cpp:
(WebCore::ScrollAnimatorNone::animationTimerFired):
* platform/ScrollAnimatorNone.h:
* platform/Scrollbar.cpp:
(WebCore::Scrollbar::autoscrollTimerFired):
* platform/Scrollbar.h:
* platform/Timer.h:
(WebCore::Timer::Timer):
* platform/audio/MediaSession.cpp:
(WebCore::MediaSession::clientDataBufferingTimerFired):
* platform/audio/MediaSession.h:
* platform/efl/BatteryProviderEfl.cpp:
(WebCore::BatteryProviderEfl::timerFired):
* platform/efl/BatteryProviderEfl.h:
* platform/graphics/BitmapImage.cpp:
(WebCore::BitmapImage::startAnimation):
(WebCore::BitmapImage::advanceAnimation):
* platform/graphics/BitmapImage.h:
* platform/graphics/MediaPlayer.cpp:
(WebCore::MediaPlayer::reloadTimerFired):
* platform/graphics/MediaPlayer.h:
* platform/graphics/ShadowBlur.cpp:
(WebCore::ScratchBuffer::timerFired):
* platform/graphics/TiledBackingStore.cpp:
(WebCore::TiledBackingStore::tileBufferUpdateTimerFired):
(WebCore::TiledBackingStore::backingStoreUpdateTimerFired):
* platform/graphics/TiledBackingStore.h:
* platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h:
* platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm:
(WebCore::MediaSelectionGroupAVFObjC::selectionTimerFired):
* platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
* platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
(WebCore::MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired):
* platform/graphics/ca/LayerPool.cpp:
(WebCore::LayerPool::pruneTimerFired):
* platform/graphics/ca/LayerPool.h:
* platform/graphics/ca/TileController.cpp:
(WebCore::TileController::tileRevalidationTimerFired):
* platform/graphics/ca/TileController.h:
* platform/graphics/ca/TileGrid.cpp:
(WebCore::TileGrid::cohortRemovalTimerFired):
* platform/graphics/ca/TileGrid.h:
* platform/graphics/ca/win/LegacyCACFLayerTreeHost.cpp:
(WebCore::LegacyCACFLayerTreeHost::renderTimerFired):
* platform/graphics/ca/win/LegacyCACFLayerTreeHost.h:
* platform/graphics/cg/IOSurfacePool.cpp:
(WebCore::IOSurfacePool::collectionTimerFired):
* platform/graphics/cg/IOSurfacePool.h:
* platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
(WebCore::MediaPlayerPrivateGStreamer::fillTimerFired):
* platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
* platform/graphics/mac/MediaPlayerPrivateQTKit.h:
* platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
(WebCore::MediaPlayerPrivateQTKit::seekTimerFired):
* platform/graphics/texmap/TextureMapper.cpp:
(WebCore::BitmapTexturePool::releaseUnusedTexturesTimerFired):
* platform/graphics/texmap/coordinated/CompositingCoordinator.cpp:
(WebCore::CompositingCoordinator::releaseInactiveAtlasesTimerFired):
* platform/graphics/texmap/coordinated/CompositingCoordinator.h:
* platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp:
(WebCore::CoordinatedGraphicsLayer::animationStartedTimerFired):
* platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h:
* platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp:
(WebCore::CoordinatedImageBacking::clearContentsTimerFired):
* platform/graphics/texmap/coordinated/CoordinatedImageBacking.h:
* platform/ios/LegacyTileCache.h:
* platform/ios/LegacyTileCache.mm:
(WebCore::LegacyTileCache::tileCreationTimerFired):
* platform/mac/HIDGamepadProvider.cpp:
(WebCore::HIDGamepadProvider::connectionDelayTimerFired):
(WebCore::HIDGamepadProvider::inputNotificationTimerFired):
* platform/mac/HIDGamepadProvider.h:
* platform/mac/ScrollAnimatorMac.h:
* platform/mac/ScrollAnimatorMac.mm:
(WebCore::ScrollAnimatorMac::snapRubberBandTimerFired):
(WebCore::ScrollAnimatorMac::initialScrollbarPaintTimerFired):
(WebCore::ScrollAnimatorMac::sendContentAreaScrolledTimerFired):
* platform/mock/DeviceMotionClientMock.cpp:
(WebCore::DeviceMotionClientMock::timerFired):
* platform/mock/DeviceMotionClientMock.h:
* platform/mock/DeviceOrientationClientMock.cpp:
(WebCore::DeviceOrientationClientMock::timerFired):
* platform/mock/DeviceOrientationClientMock.h:
* platform/mock/GeolocationClientMock.cpp:
(WebCore::GeolocationClientMock::permissionTimerFired):
(WebCore::GeolocationClientMock::controllerTimerFired):
* platform/mock/GeolocationClientMock.h:
* platform/mock/PlatformSpeechSynthesizerMock.cpp:
(WebCore::PlatformSpeechSynthesizerMock::speakingFinished):
* platform/mock/PlatformSpeechSynthesizerMock.h:
* platform/mock/TimerEventBasedMock.h:
(WebCore::TimerEvent::timerFired):
* platform/network/DNSResolveQueue.cpp:
(WebCore::DNSResolveQueue::timerFired):
* platform/network/DNSResolveQueue.h:
* platform/network/NetworkStateNotifier.h:
* platform/network/ResourceHandle.cpp:
(WebCore::ResourceHandle::failureTimerFired):
* platform/network/ResourceHandle.h:
* platform/network/ResourceHandleInternal.h:
* platform/network/curl/ResourceHandleManager.cpp:
(WebCore::ResourceHandleManager::downloadTimerCallback):
* platform/network/curl/ResourceHandleManager.h:
* platform/network/mac/NetworkStateNotifierMac.cpp:
(WebCore::NetworkStateNotifier::networkStateChangeTimerFired):
* platform/network/win/ResourceHandleWin.cpp:
(WebCore::ResourceHandle::fileLoadTimer):
* plugins/PluginPackage.cpp:
(WebCore::PluginPackage::freeLibraryTimerFired):
* plugins/PluginPackage.h:
* plugins/PluginStream.cpp:
(WebCore::PluginStream::delayDeliveryTimerFired):
* plugins/PluginStream.h:
* plugins/PluginView.cpp:
(WebCore::PluginView::popPopupsStateTimerFired):
(WebCore::PluginView::requestTimerFired):
(WebCore::PluginView::invalidateTimerFired):
(WebCore::PluginView::lifeSupportTimerFired):
* plugins/PluginView.h:
* plugins/win/PluginMessageThrottlerWin.cpp:
(WebCore::PluginMessageThrottlerWin::messageThrottleTimerFired):
* plugins/win/PluginMessageThrottlerWin.h:
* rendering/ImageQualityController.cpp:
(WebCore::ImageQualityController::highQualityRepaintTimerFired):
* rendering/ImageQualityController.h:
* rendering/RenderButton.cpp:
(WebCore::RenderButton::styleDidChange):
(WebCore::RenderButton::timerFired):
* rendering/RenderButton.h:
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::updateCompositingLayersTimerFired):
(WebCore::RenderLayerCompositor::layerFlushTimerFired):
(WebCore::RenderLayerCompositor::paintRelatedMilestonesTimerFired):
* rendering/RenderLayerCompositor.h:
* rendering/RenderMarquee.cpp:
(WebCore::RenderMarquee::timerFired):
* rendering/RenderMarquee.h:
* rendering/RenderNamedFlowThread.cpp:
(WebCore::RenderNamedFlowThread::regionOversetChangeEventTimerFired):
* rendering/RenderNamedFlowThread.h:
* rendering/RenderProgress.cpp:
(WebCore::RenderProgress::animationTimerFired):
* rendering/RenderProgress.h:
* rendering/RenderView.cpp:
(WebCore::RenderView::lazyRepaintTimerFired):
* rendering/RenderView.h:
* replay/EventLoopInputDispatcher.cpp:
(WebCore::EventLoopInputDispatcher::timerFired):
* replay/EventLoopInputDispatcher.h:
* storage/StorageAreaImpl.cpp:
(WebCore::StorageAreaImpl::closeDatabaseTimerFired):
* storage/StorageAreaImpl.h:
* storage/StorageAreaSync.cpp:
(WebCore::StorageAreaSync::syncTimerFired):
* storage/StorageAreaSync.h:
* svg/SVGElement.cpp:
(WebCore::SVGElement::svgLoadEventTimerFired):
(WebCore::SVGElement::svgLoadEventTimer):
* svg/SVGElement.h:
* svg/SVGScriptElement.h:
* svg/SVGStyleElement.h:
* svg/SVGUseElement.h:
* svg/animation/SMILTimeContainer.cpp:
(WebCore::SMILTimeContainer::timerFired):
* svg/animation/SMILTimeContainer.h:
* xml/XMLHttpRequestProgressEventThrottle.cpp:
(WebCore::XMLHttpRequestProgressEventThrottle::dispatchDeferredEvents):
* xml/XMLHttpRequestProgressEventThrottle.h:

Source/WebKit/mac:

Remove template specifiers from Timer.

* Plugins/Hosted/NetscapePluginInstanceProxy.h:
* Plugins/Hosted/NetscapePluginInstanceProxy.mm:
(WebKit::NetscapePluginInstanceProxy::requestTimerFired):
* Plugins/WebNetscapePluginStream.h:
* Plugins/WebNetscapePluginStream.mm:
(WebNetscapePluginStream::deliverDataTimerFired):

Source/WebKit/win:

* FullscreenVideoController.cpp:
(FullscreenVideoController::timerFired):
* FullscreenVideoController.h:

Source/WebKit2:

Remove template specifiers from Timer.

* NetworkProcess/NetworkResourceLoader.cpp:
(WebKit::NetworkResourceLoader::bufferingTimerFired):
* NetworkProcess/NetworkResourceLoader.h:
* Shared/WebMemorySampler.cpp:
(WebKit::WebMemorySampler::sampleTimerFired):
(WebKit::WebMemorySampler::stopTimerFired):
* Shared/WebMemorySampler.h:
* Shared/mac/RemoteLayerBackingStoreCollection.h:
* Shared/mac/RemoteLayerBackingStoreCollection.mm:
(WebKit::RemoteLayerBackingStoreCollection::volatilityTimerFired):
* UIProcess/API/efl/EwkView.cpp:
(EwkView::displayTimerFired):
* UIProcess/API/efl/EwkView.h:
* UIProcess/efl/TextCheckerClientEfl.cpp:
(TextCheckerClientEfl::languagesUpdateTimerFired):
(TextCheckerClientEfl::spellCheckingSettingChangeTimerFired):
* UIProcess/efl/TextCheckerClientEfl.h:
* WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:
(WebKit::CoordinatedLayerTreeHost::layerFlushTimerFired):
* WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h:
* WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h:
* WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm:
(WebKit::RemoteLayerTreeDrawingArea::layerFlushTimerFired):
* WebProcess/WebProcess.cpp:
(WebKit::WebProcess::processSuspensionCleanupTimerFired):
(WebKit::WebProcess::nonVisibleProcessCleanupTimerFired):
* WebProcess/WebProcess.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@175719 268f45cc-cd09-0410-ab3c-d52691b4dbfc

277 files changed:
Source/WebCore/ChangeLog
Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp
Source/WebCore/Modules/encryptedmedia/MediaKeySession.h
Source/WebCore/Modules/geolocation/Geolocation.cpp
Source/WebCore/Modules/geolocation/Geolocation.h
Source/WebCore/Modules/indexeddb/IDBTransactionBackend.cpp
Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h
Source/WebCore/Modules/mediasource/SourceBuffer.cpp
Source/WebCore/Modules/mediasource/SourceBuffer.h
Source/WebCore/Modules/mediastream/MediaStream.cpp
Source/WebCore/Modules/mediastream/MediaStream.h
Source/WebCore/Modules/mediastream/RTCDTMFSender.cpp
Source/WebCore/Modules/mediastream/RTCDTMFSender.h
Source/WebCore/Modules/mediastream/RTCDataChannel.cpp
Source/WebCore/Modules/mediastream/RTCDataChannel.h
Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp
Source/WebCore/Modules/mediastream/RTCPeerConnection.h
Source/WebCore/Modules/notifications/Notification.cpp
Source/WebCore/Modules/notifications/Notification.h
Source/WebCore/Modules/notifications/NotificationCenter.cpp
Source/WebCore/Modules/notifications/NotificationCenter.h
Source/WebCore/Modules/vibration/Vibration.cpp
Source/WebCore/Modules/vibration/Vibration.h
Source/WebCore/Modules/websockets/WebSocketChannel.cpp
Source/WebCore/Modules/websockets/WebSocketChannel.h
Source/WebCore/accessibility/AXObjectCache.cpp
Source/WebCore/accessibility/AXObjectCache.h
Source/WebCore/bindings/js/GCController.cpp
Source/WebCore/bindings/js/GCController.h
Source/WebCore/css/CSSFontFaceSource.h
Source/WebCore/css/CSSFontSelector.cpp
Source/WebCore/css/CSSFontSelector.h
Source/WebCore/css/StyleResolver.cpp
Source/WebCore/css/StyleResolver.h
Source/WebCore/dom/Document.cpp
Source/WebCore/dom/Document.h
Source/WebCore/dom/EventSender.h
Source/WebCore/dom/GenericEventQueue.cpp
Source/WebCore/dom/GenericEventQueue.h
Source/WebCore/dom/ScriptRunner.cpp
Source/WebCore/dom/ScriptRunner.h
Source/WebCore/dom/ScriptedAnimationController.cpp
Source/WebCore/dom/ScriptedAnimationController.h
Source/WebCore/dom/StyledElement.cpp
Source/WebCore/editing/AlternativeTextController.cpp
Source/WebCore/editing/AlternativeTextController.h
Source/WebCore/editing/Editor.cpp
Source/WebCore/editing/Editor.h
Source/WebCore/editing/FrameSelection.cpp
Source/WebCore/editing/FrameSelection.h
Source/WebCore/editing/SpellChecker.cpp
Source/WebCore/editing/SpellChecker.h
Source/WebCore/html/HTMLFormElement.cpp
Source/WebCore/html/HTMLFormElement.h
Source/WebCore/html/HTMLMediaElement.cpp
Source/WebCore/html/HTMLMediaElement.h
Source/WebCore/html/HTMLPlugInElement.cpp
Source/WebCore/html/HTMLPlugInElement.h
Source/WebCore/html/HTMLPlugInImageElement.cpp
Source/WebCore/html/HTMLPlugInImageElement.h
Source/WebCore/html/HTMLSourceElement.cpp
Source/WebCore/html/HTMLSourceElement.h
Source/WebCore/html/HTMLTrackElement.cpp
Source/WebCore/html/HTMLTrackElement.h
Source/WebCore/html/MediaController.cpp
Source/WebCore/html/MediaController.h
Source/WebCore/html/MediaDocument.cpp
Source/WebCore/html/MediaDocument.h
Source/WebCore/html/SearchInputType.cpp
Source/WebCore/html/SearchInputType.h
Source/WebCore/html/ValidationMessage.cpp
Source/WebCore/html/ValidationMessage.h
Source/WebCore/html/canvas/WebGLRenderingContext.cpp
Source/WebCore/html/canvas/WebGLRenderingContext.h
Source/WebCore/html/parser/HTMLParserScheduler.cpp
Source/WebCore/html/parser/HTMLParserScheduler.h
Source/WebCore/html/shadow/MediaControlElements.cpp
Source/WebCore/html/shadow/MediaControlElements.h
Source/WebCore/html/shadow/MediaControls.cpp
Source/WebCore/html/shadow/MediaControls.h
Source/WebCore/html/shadow/SpinButtonElement.cpp
Source/WebCore/html/shadow/SpinButtonElement.h
Source/WebCore/html/track/LoadableTextTrack.cpp
Source/WebCore/html/track/LoadableTextTrack.h
Source/WebCore/html/track/VTTRegion.cpp
Source/WebCore/html/track/VTTRegion.h
Source/WebCore/inspector/InspectorCSSAgent.cpp
Source/WebCore/inspector/InspectorDOMAgent.cpp
Source/WebCore/inspector/InspectorFrontendClientLocal.cpp
Source/WebCore/inspector/InspectorOverlay.cpp
Source/WebCore/inspector/InspectorOverlay.h
Source/WebCore/loader/DocumentLoader.cpp
Source/WebCore/loader/DocumentLoader.h
Source/WebCore/loader/FrameLoader.cpp
Source/WebCore/loader/FrameLoader.h
Source/WebCore/loader/ImageLoader.cpp
Source/WebCore/loader/ImageLoader.h
Source/WebCore/loader/LinkLoader.cpp
Source/WebCore/loader/LinkLoader.h
Source/WebCore/loader/NavigationScheduler.cpp
Source/WebCore/loader/NavigationScheduler.h
Source/WebCore/loader/PingLoader.h
Source/WebCore/loader/ProgressTracker.cpp
Source/WebCore/loader/ProgressTracker.h
Source/WebCore/loader/ResourceLoadScheduler.cpp
Source/WebCore/loader/ResourceLoadScheduler.h
Source/WebCore/loader/TextTrackLoader.cpp
Source/WebCore/loader/TextTrackLoader.h
Source/WebCore/loader/cache/CachedResource.cpp
Source/WebCore/loader/cache/CachedResource.h
Source/WebCore/loader/cache/CachedResourceLoader.cpp
Source/WebCore/loader/cache/CachedResourceLoader.h
Source/WebCore/loader/icon/IconDatabase.cpp
Source/WebCore/loader/icon/IconDatabase.h
Source/WebCore/page/AutoscrollController.cpp
Source/WebCore/page/AutoscrollController.h
Source/WebCore/page/CaptionUserPreferences.cpp
Source/WebCore/page/CaptionUserPreferences.h
Source/WebCore/page/CaptionUserPreferencesMediaAF.cpp
Source/WebCore/page/CaptionUserPreferencesMediaAF.h
Source/WebCore/page/DeviceController.cpp
Source/WebCore/page/DeviceController.h
Source/WebCore/page/EventHandler.cpp
Source/WebCore/page/EventHandler.h
Source/WebCore/page/EventSource.cpp
Source/WebCore/page/EventSource.h
Source/WebCore/page/FocusController.cpp
Source/WebCore/page/FocusController.h
Source/WebCore/page/Frame.cpp
Source/WebCore/page/Frame.h
Source/WebCore/page/FrameView.cpp
Source/WebCore/page/FrameView.h
Source/WebCore/page/PageOverlay.cpp
Source/WebCore/page/PageOverlay.h
Source/WebCore/page/Settings.cpp
Source/WebCore/page/Settings.h
Source/WebCore/page/animation/AnimationController.cpp
Source/WebCore/page/animation/AnimationControllerPrivate.h
Source/WebCore/page/mac/ServicesOverlayController.h
Source/WebCore/page/mac/ServicesOverlayController.mm
Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.h
Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.mm
Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.h
Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.mm
Source/WebCore/platform/HysteresisActivity.h
Source/WebCore/platform/ScrollAnimator.cpp
Source/WebCore/platform/ScrollAnimator.h
Source/WebCore/platform/ScrollAnimatorNone.cpp
Source/WebCore/platform/ScrollAnimatorNone.h
Source/WebCore/platform/Scrollbar.cpp
Source/WebCore/platform/Scrollbar.h
Source/WebCore/platform/Timer.h
Source/WebCore/platform/audio/MediaSession.cpp
Source/WebCore/platform/audio/MediaSession.h
Source/WebCore/platform/efl/BatteryProviderEfl.cpp
Source/WebCore/platform/efl/BatteryProviderEfl.h
Source/WebCore/platform/graphics/BitmapImage.cpp
Source/WebCore/platform/graphics/BitmapImage.h
Source/WebCore/platform/graphics/MediaPlayer.cpp
Source/WebCore/platform/graphics/MediaPlayer.h
Source/WebCore/platform/graphics/ShadowBlur.cpp
Source/WebCore/platform/graphics/TiledBackingStore.cpp
Source/WebCore/platform/graphics/TiledBackingStore.h
Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h
Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm
Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h
Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm
Source/WebCore/platform/graphics/ca/LayerPool.cpp
Source/WebCore/platform/graphics/ca/LayerPool.h
Source/WebCore/platform/graphics/ca/TileController.cpp
Source/WebCore/platform/graphics/ca/TileController.h
Source/WebCore/platform/graphics/ca/TileGrid.cpp
Source/WebCore/platform/graphics/ca/TileGrid.h
Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.cpp
Source/WebCore/platform/graphics/ca/win/LegacyCACFLayerTreeHost.h
Source/WebCore/platform/graphics/cg/IOSurfacePool.cpp
Source/WebCore/platform/graphics/cg/IOSurfacePool.h
Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp
Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h
Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h
Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm
Source/WebCore/platform/graphics/texmap/TextureMapper.cpp
Source/WebCore/platform/graphics/texmap/coordinated/CompositingCoordinator.cpp
Source/WebCore/platform/graphics/texmap/coordinated/CompositingCoordinator.h
Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp
Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h
Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp
Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.h
Source/WebCore/platform/ios/LegacyTileCache.h
Source/WebCore/platform/ios/LegacyTileCache.mm
Source/WebCore/platform/mac/HIDGamepadProvider.cpp
Source/WebCore/platform/mac/HIDGamepadProvider.h
Source/WebCore/platform/mac/ScrollAnimatorMac.h
Source/WebCore/platform/mac/ScrollAnimatorMac.mm
Source/WebCore/platform/mock/DeviceMotionClientMock.cpp
Source/WebCore/platform/mock/DeviceMotionClientMock.h
Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp
Source/WebCore/platform/mock/DeviceOrientationClientMock.h
Source/WebCore/platform/mock/GeolocationClientMock.cpp
Source/WebCore/platform/mock/GeolocationClientMock.h
Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp
Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.h
Source/WebCore/platform/mock/TimerEventBasedMock.h
Source/WebCore/platform/network/DNSResolveQueue.cpp
Source/WebCore/platform/network/DNSResolveQueue.h
Source/WebCore/platform/network/NetworkStateNotifier.h
Source/WebCore/platform/network/ResourceHandle.cpp
Source/WebCore/platform/network/ResourceHandle.h
Source/WebCore/platform/network/ResourceHandleInternal.h
Source/WebCore/platform/network/curl/ResourceHandleManager.cpp
Source/WebCore/platform/network/curl/ResourceHandleManager.h
Source/WebCore/platform/network/mac/NetworkStateNotifierMac.cpp
Source/WebCore/platform/network/win/ResourceHandleWin.cpp
Source/WebCore/plugins/PluginPackage.cpp
Source/WebCore/plugins/PluginPackage.h
Source/WebCore/plugins/PluginStream.cpp
Source/WebCore/plugins/PluginStream.h
Source/WebCore/plugins/PluginView.cpp
Source/WebCore/plugins/PluginView.h
Source/WebCore/plugins/win/PluginMessageThrottlerWin.cpp
Source/WebCore/plugins/win/PluginMessageThrottlerWin.h
Source/WebCore/rendering/ImageQualityController.cpp
Source/WebCore/rendering/ImageQualityController.h
Source/WebCore/rendering/RenderButton.cpp
Source/WebCore/rendering/RenderButton.h
Source/WebCore/rendering/RenderLayerCompositor.cpp
Source/WebCore/rendering/RenderLayerCompositor.h
Source/WebCore/rendering/RenderMarquee.cpp
Source/WebCore/rendering/RenderMarquee.h
Source/WebCore/rendering/RenderNamedFlowThread.cpp
Source/WebCore/rendering/RenderNamedFlowThread.h
Source/WebCore/rendering/RenderProgress.cpp
Source/WebCore/rendering/RenderProgress.h
Source/WebCore/rendering/RenderView.cpp
Source/WebCore/rendering/RenderView.h
Source/WebCore/replay/EventLoopInputDispatcher.cpp
Source/WebCore/replay/EventLoopInputDispatcher.h
Source/WebCore/storage/StorageAreaImpl.cpp
Source/WebCore/storage/StorageAreaImpl.h
Source/WebCore/storage/StorageAreaSync.cpp
Source/WebCore/storage/StorageAreaSync.h
Source/WebCore/svg/SVGElement.cpp
Source/WebCore/svg/SVGElement.h
Source/WebCore/svg/SVGScriptElement.h
Source/WebCore/svg/SVGStyleElement.h
Source/WebCore/svg/SVGUseElement.h
Source/WebCore/svg/animation/SMILTimeContainer.cpp
Source/WebCore/svg/animation/SMILTimeContainer.h
Source/WebCore/xml/XMLHttpRequestProgressEventThrottle.cpp
Source/WebCore/xml/XMLHttpRequestProgressEventThrottle.h
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/Plugins/Hosted/NetscapePluginInstanceProxy.h
Source/WebKit/mac/Plugins/Hosted/NetscapePluginInstanceProxy.mm
Source/WebKit/mac/Plugins/WebNetscapePluginStream.h
Source/WebKit/mac/Plugins/WebNetscapePluginStream.mm
Source/WebKit/win/ChangeLog
Source/WebKit/win/FullscreenVideoController.cpp
Source/WebKit/win/FullscreenVideoController.h
Source/WebKit2/ChangeLog
Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp
Source/WebKit2/NetworkProcess/NetworkResourceLoader.h
Source/WebKit2/Shared/WebMemorySampler.cpp
Source/WebKit2/Shared/WebMemorySampler.h
Source/WebKit2/Shared/mac/RemoteLayerBackingStoreCollection.h
Source/WebKit2/Shared/mac/RemoteLayerBackingStoreCollection.mm
Source/WebKit2/UIProcess/API/efl/EwkView.cpp
Source/WebKit2/UIProcess/API/efl/EwkView.h
Source/WebKit2/UIProcess/efl/TextCheckerClientEfl.cpp
Source/WebKit2/UIProcess/efl/TextCheckerClientEfl.h
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h
Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h
Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm
Source/WebKit2/WebProcess/WebProcess.cpp
Source/WebKit2/WebProcess/WebProcess.h

index 8dc3fa5ac62b534f953aee941e436db146bf41b9..21a1454cc2931bf0db0a1907d6149d825ef1450e 100644 (file)
@@ -1,3 +1,451 @@
+2014-11-05  Jer Noble  <jer.noble@apple.com>
+
+        De-templatize Timer
+        https://bugs.webkit.org/show_bug.cgi?id=138450
+
+        Reviewed by Anders Carlsson.
+
+        Timer does not need to be a templated class; only it's constructors need to be templated.
+        Remove the template specifier from Timer and add same to its two class method
+        constructors. Replace the function pointer typedefs with using statements. Add a
+        helper typedef which allows invalid combinations of TimerFiredClass and
+        TimerFiredFunction to be caught early by the compiler, while still allowing
+        valid combinations (such as when the caller specifies a function on a subclass of
+        TimerFiredClass).
+
+        * Modules/encryptedmedia/MediaKeySession.cpp:
+        (WebCore::MediaKeySession::keyRequestTimerFired):
+        (WebCore::MediaKeySession::addKeyTimerFired):
+        * Modules/encryptedmedia/MediaKeySession.h:
+        * Modules/geolocation/Geolocation.cpp:
+        (WebCore::Geolocation::GeoNotifier::timerFired):
+        (WebCore::Geolocation::resumeTimerFired):
+        * Modules/geolocation/Geolocation.h:
+        * Modules/indexeddb/IDBTransactionBackend.cpp:
+        (WebCore::IDBTransactionBackend::taskTimerFired):
+        * Modules/indexeddb/IDBTransactionBackend.h:
+        * Modules/mediasource/SourceBuffer.cpp:
+        (WebCore::SourceBuffer::appendBufferTimerFired):
+        (WebCore::SourceBuffer::removeTimerFired):
+        * Modules/mediasource/SourceBuffer.h:
+        * Modules/mediastream/MediaStream.cpp:
+        (WebCore::MediaStream::scheduledEventTimerFired):
+        * Modules/mediastream/MediaStream.h:
+        * Modules/mediastream/RTCDTMFSender.cpp:
+        (WebCore::RTCDTMFSender::scheduledEventTimerFired):
+        * Modules/mediastream/RTCDTMFSender.h:
+        * Modules/mediastream/RTCDataChannel.cpp:
+        (WebCore::RTCDataChannel::scheduledEventTimerFired):
+        * Modules/mediastream/RTCDataChannel.h:
+        * Modules/mediastream/RTCPeerConnection.cpp:
+        (WebCore::RTCPeerConnection::scheduledEventTimerFired):
+        * Modules/mediastream/RTCPeerConnection.h:
+        * Modules/notifications/Notification.cpp:
+        (WebCore::Notification::Notification):
+        (WebCore::Notification::taskTimerFired):
+        * Modules/notifications/Notification.h:
+        * Modules/notifications/NotificationCenter.cpp:
+        (WebCore::NotificationCenter::NotificationRequestCallback::timerFired):
+        * Modules/notifications/NotificationCenter.h:
+        * Modules/vibration/Vibration.cpp:
+        (WebCore::Vibration::timerFired):
+        * Modules/vibration/Vibration.h:
+        * Modules/websockets/WebSocketChannel.cpp:
+        (WebCore::WebSocketChannel::resumeTimerFired):
+        (WebCore::WebSocketChannel::closingTimerFired):
+        * Modules/websockets/WebSocketChannel.h:
+        * accessibility/AXObjectCache.cpp:
+        (WebCore::AXObjectCache::notificationPostTimerFired):
+        * accessibility/AXObjectCache.h:
+        (WebCore::AXObjectCache::AXObjectCache):
+        * bindings/js/GCController.cpp:
+        (WebCore::GCController::gcTimerFired):
+        * bindings/js/GCController.h:
+        * css/CSSFontFaceSource.h:
+        * css/CSSFontSelector.cpp:
+        (WebCore::CSSFontSelector::beginLoadTimerFired):
+        * css/CSSFontSelector.h:
+        * css/StyleResolver.cpp:
+        (WebCore::StyleResolver::sweepMatchedPropertiesCache):
+        * css/StyleResolver.h:
+        * dom/Document.cpp:
+        (WebCore::Document::visualUpdatesSuppressionTimerFired):
+        (WebCore::Document::styleRecalcTimerFired):
+        (WebCore::Document::optimizedStyleSheetUpdateTimerFired):
+        (WebCore::Document::sharedObjectPoolClearTimerFired):
+        (WebCore::Document::updateFocusAppearanceTimerFired):
+        (WebCore::Document::pendingTasksTimerFired):
+        (WebCore::Document::fullScreenChangeDelayTimerFired):
+        (WebCore::Document::loadEventDelayTimerFired):
+        (WebCore::Document::didAssociateFormControlsTimerFired):
+        (WebCore::Document::domCookieCacheExpiryTimerFired):
+        * dom/Document.h:
+        * dom/EventSender.h:
+        (WebCore::EventSender::timerFired):
+        * dom/GenericEventQueue.cpp:
+        (WebCore::GenericEventQueue::timerFired):
+        * dom/GenericEventQueue.h:
+        * dom/ScriptRunner.cpp:
+        (WebCore::ScriptRunner::timerFired):
+        * dom/ScriptRunner.h:
+        * dom/ScriptedAnimationController.cpp:
+        (WebCore::ScriptedAnimationController::animationTimerFired):
+        * dom/ScriptedAnimationController.h:
+        * dom/StyledElement.cpp:
+        (WebCore::PresentationAttributeCacheCleaner::cleanCache):
+        * editing/AlternativeTextController.cpp:
+        (WebCore::AlternativeTextController::timerFired):
+        * editing/AlternativeTextController.h:
+        * editing/Editor.cpp:
+        (WebCore::Editor::scanSelectionForTelephoneNumbers):
+        (WebCore::Editor::editorUIUpdateTimerFired):
+        * editing/Editor.h:
+        * editing/FrameSelection.cpp:
+        (WebCore::FrameSelection::caretBlinkTimerFired):
+        * editing/FrameSelection.h:
+        * editing/SpellChecker.cpp:
+        (WebCore::SpellChecker::timerFiredToProcessQueuedRequest):
+        * editing/SpellChecker.h:
+        * html/HTMLFormElement.cpp:
+        (WebCore::HTMLFormElement::requestAutocompleteTimerFired):
+        * html/HTMLFormElement.h:
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::parseAttribute):
+        * html/HTMLMediaElement.h:
+        * html/HTMLPlugInElement.cpp:
+        (WebCore::HTMLPlugInElement::swapRendererTimerFired):
+        * html/HTMLPlugInElement.h:
+        * html/HTMLPlugInImageElement.cpp:
+        (WebCore::HTMLPlugInImageElement::removeSnapshotTimerFired):
+        * html/HTMLPlugInImageElement.h:
+        * html/HTMLSourceElement.cpp:
+        (WebCore::HTMLSourceElement::errorEventTimerFired):
+        * html/HTMLSourceElement.h:
+        * html/HTMLTrackElement.cpp:
+        (WebCore::HTMLTrackElement::loadTimerFired):
+        * html/HTMLTrackElement.h:
+        * html/MediaController.cpp:
+        (MediaController::asyncEventTimerFired):
+        (MediaController::clearPositionTimerFired):
+        (MediaController::timeupdateTimerFired):
+        * html/MediaController.h:
+        * html/MediaDocument.cpp:
+        (WebCore::MediaDocument::replaceMediaElementTimerFired):
+        * html/MediaDocument.h:
+        * html/SearchInputType.cpp:
+        (WebCore::SearchInputType::searchEventTimerFired):
+        * html/SearchInputType.h:
+        * html/ValidationMessage.cpp:
+        (WebCore::ValidationMessage::setMessage):
+        (WebCore::ValidationMessage::setMessageDOMAndStartTimer):
+        (WebCore::ValidationMessage::buildBubbleTree):
+        (WebCore::ValidationMessage::requestToHideMessage):
+        (WebCore::ValidationMessage::deleteBubbleTree):
+        * html/ValidationMessage.h:
+        * html/canvas/WebGLRenderingContext.cpp:
+        (WebCore::WebGLRenderingContext::dispatchContextLostEvent):
+        (WebCore::WebGLRenderingContext::maybeRestoreContext):
+        * html/canvas/WebGLRenderingContext.h:
+        * html/parser/HTMLParserScheduler.cpp:
+        (WebCore::HTMLParserScheduler::continueNextChunkTimerFired):
+        * html/parser/HTMLParserScheduler.h:
+        * html/shadow/MediaControlElements.cpp:
+        (WebCore::MediaControlPanelElement::transitionTimerFired):
+        (WebCore::MediaControlTextTrackContainerElement::updateTimerFired):
+        * html/shadow/MediaControlElements.h:
+        * html/shadow/MediaControls.cpp:
+        (WebCore::MediaControls::hideFullscreenControlsTimerFired):
+        * html/shadow/MediaControls.h:
+        * html/shadow/SpinButtonElement.cpp:
+        (WebCore::SpinButtonElement::repeatingTimerFired):
+        * html/shadow/SpinButtonElement.h:
+        * html/track/LoadableTextTrack.cpp:
+        (WebCore::LoadableTextTrack::loadTimerFired):
+        * html/track/LoadableTextTrack.h:
+        * html/track/VTTRegion.cpp:
+        (WebCore::VTTRegion::scrollTimerFired):
+        * html/track/VTTRegion.h:
+        * inspector/InspectorCSSAgent.cpp:
+        (WebCore::ChangeRegionOversetTask::timerFired):
+        * inspector/InspectorDOMAgent.cpp:
+        (WebCore::RevalidateStyleAttributeTask::timerFired):
+        * inspector/InspectorFrontendClientLocal.cpp:
+        (WebCore::InspectorBackendDispatchTask::timerFired):
+        * inspector/InspectorOverlay.cpp:
+        (WebCore::InspectorOverlay::updatePaintRectsTimerFired):
+        * inspector/InspectorOverlay.h:
+        * loader/DocumentLoader.cpp:
+        (WebCore::DocumentLoader::substituteResourceDeliveryTimerFired):
+        * loader/DocumentLoader.h:
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::checkTimerFired):
+        * loader/FrameLoader.h:
+        * loader/ImageLoader.cpp:
+        (WebCore::ImageLoader::timerFired):
+        * loader/ImageLoader.h:
+        * loader/LinkLoader.cpp:
+        (WebCore::LinkLoader::linkLoadTimerFired):
+        (WebCore::LinkLoader::linkLoadingErrorTimerFired):
+        * loader/LinkLoader.h:
+        * loader/NavigationScheduler.cpp:
+        (WebCore::ScheduledNavigation::didStartTimer):
+        (WebCore::NavigationScheduler::timerFired):
+        * loader/NavigationScheduler.h:
+        * loader/PingLoader.h:
+        (WebCore::PingLoader::timeoutTimerFired):
+        * loader/ProgressTracker.cpp:
+        (WebCore::ProgressTracker::progressHeartbeatTimerFired):
+        * loader/ProgressTracker.h:
+        * loader/ResourceLoadScheduler.cpp:
+        (WebCore::ResourceLoadScheduler::requestTimerFired):
+        * loader/ResourceLoadScheduler.h:
+        * loader/TextTrackLoader.cpp:
+        (WebCore::TextTrackLoader::cueLoadTimerFired):
+        * loader/TextTrackLoader.h:
+        * loader/cache/CachedResource.cpp:
+        (WebCore::CachedResource::Callback::timerFired):
+        * loader/cache/CachedResource.h:
+        * loader/cache/CachedResourceLoader.cpp:
+        (WebCore::CachedResourceLoader::garbageCollectDocumentResourcesTimerFired):
+        * loader/cache/CachedResourceLoader.h:
+        * loader/icon/IconDatabase.cpp:
+        (WebCore::IconDatabase::syncTimerFired):
+        * loader/icon/IconDatabase.h:
+        * page/AutoscrollController.cpp:
+        (WebCore::AutoscrollController::autoscrollTimerFired):
+        * page/AutoscrollController.h:
+        * page/CaptionUserPreferences.cpp:
+        (WebCore::CaptionUserPreferences::timerFired):
+        * page/CaptionUserPreferences.h:
+        * page/CaptionUserPreferencesMediaAF.cpp:
+        (WebCore::CaptionUserPreferencesMediaAF::updateTimerFired):
+        * page/CaptionUserPreferencesMediaAF.h:
+        * page/DeviceController.cpp:
+        (WebCore::DeviceController::fireDeviceEvent):
+        * page/DeviceController.h:
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::cursorUpdateTimerFired):
+        (WebCore::EventHandler::autoHideCursorTimerFired):
+        (WebCore::EventHandler::recognizeLongMousePress):
+        (WebCore::EventHandler::fakeMouseMoveEventTimerFired):
+        (WebCore::EventHandler::hoverTimerFired):
+        * page/EventHandler.h:
+        * page/EventSource.cpp:
+        (WebCore::EventSource::connectTimerFired):
+        * page/EventSource.h:
+        * page/FocusController.cpp:
+        (WebCore::FocusController::focusRepaintTimerFired):
+        * page/FocusController.h:
+        * page/Frame.cpp:
+        (WebCore::Frame::overflowAutoScrollTimerFired):
+        * page/Frame.h:
+        * page/FrameView.cpp:
+        (WebCore::FrameView::delayedScrollEventTimerFired):
+        (WebCore::FrameView::speculativeTilingEnableTimerFired):
+        (WebCore::FrameView::layoutTimerFired):
+        (WebCore::FrameView::updateEmbeddedObjectsTimerFired):
+        (WebCore::FrameView::postLayoutTimerFired):
+        * page/FrameView.h:
+        * page/PageOverlay.cpp:
+        (WebCore::PageOverlay::fadeAnimationTimerFired):
+        * page/PageOverlay.h:
+        * page/Settings.cpp:
+        (WebCore::Settings::imageLoadingSettingsTimerFired):
+        * page/Settings.h:
+        * page/animation/AnimationController.cpp:
+        (WebCore::AnimationControllerPrivate::updateStyleIfNeededDispatcherFired):
+        (WebCore::AnimationControllerPrivate::animationTimerFired):
+        * page/animation/AnimationControllerPrivate.h:
+        * page/mac/ServicesOverlayController.h:
+        * page/mac/ServicesOverlayController.mm:
+        (WebCore::ServicesOverlayController::determineActiveHighlightTimerFired):
+        * page/scrolling/AsyncScrollingCoordinator.cpp:
+        (WebCore::AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired):
+        * page/scrolling/AsyncScrollingCoordinator.h:
+        * page/scrolling/ios/ScrollingCoordinatorIOS.h:
+        * page/scrolling/ios/ScrollingCoordinatorIOS.mm:
+        (WebCore::ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired):
+        * page/scrolling/mac/ScrollingCoordinatorMac.h:
+        * page/scrolling/mac/ScrollingCoordinatorMac.mm:
+        (WebCore::ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired):
+        * platform/HysteresisActivity.h:
+        (WebCore::HysteresisActivity::hysteresisTimerFired):
+        * platform/ScrollAnimator.cpp:
+        (WebCore::ScrollAnimator::updateScrollAnimatorsAndTimers):
+        (WebCore::ScrollAnimator::startScrollSnapTimer):
+        (WebCore::ScrollAnimator::stopScrollSnapTimer):
+        (WebCore::ScrollAnimator::horizontalScrollSnapTimerFired):
+        (WebCore::ScrollAnimator::verticalScrollSnapTimerFired):
+        * platform/ScrollAnimator.h:
+        * platform/ScrollAnimatorNone.cpp:
+        (WebCore::ScrollAnimatorNone::animationTimerFired):
+        * platform/ScrollAnimatorNone.h:
+        * platform/Scrollbar.cpp:
+        (WebCore::Scrollbar::autoscrollTimerFired):
+        * platform/Scrollbar.h:
+        * platform/Timer.h:
+        (WebCore::Timer::Timer):
+        * platform/audio/MediaSession.cpp:
+        (WebCore::MediaSession::clientDataBufferingTimerFired):
+        * platform/audio/MediaSession.h:
+        * platform/efl/BatteryProviderEfl.cpp:
+        (WebCore::BatteryProviderEfl::timerFired):
+        * platform/efl/BatteryProviderEfl.h:
+        * platform/graphics/BitmapImage.cpp:
+        (WebCore::BitmapImage::startAnimation):
+        (WebCore::BitmapImage::advanceAnimation):
+        * platform/graphics/BitmapImage.h:
+        * platform/graphics/MediaPlayer.cpp:
+        (WebCore::MediaPlayer::reloadTimerFired):
+        * platform/graphics/MediaPlayer.h:
+        * platform/graphics/ShadowBlur.cpp:
+        (WebCore::ScratchBuffer::timerFired):
+        * platform/graphics/TiledBackingStore.cpp:
+        (WebCore::TiledBackingStore::tileBufferUpdateTimerFired):
+        (WebCore::TiledBackingStore::backingStoreUpdateTimerFired):
+        * platform/graphics/TiledBackingStore.h:
+        * platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h:
+        * platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm:
+        (WebCore::MediaSelectionGroupAVFObjC::selectionTimerFired):
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
+        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired):
+        * platform/graphics/ca/LayerPool.cpp:
+        (WebCore::LayerPool::pruneTimerFired):
+        * platform/graphics/ca/LayerPool.h:
+        * platform/graphics/ca/TileController.cpp:
+        (WebCore::TileController::tileRevalidationTimerFired):
+        * platform/graphics/ca/TileController.h:
+        * platform/graphics/ca/TileGrid.cpp:
+        (WebCore::TileGrid::cohortRemovalTimerFired):
+        * platform/graphics/ca/TileGrid.h:
+        * platform/graphics/ca/win/LegacyCACFLayerTreeHost.cpp:
+        (WebCore::LegacyCACFLayerTreeHost::renderTimerFired):
+        * platform/graphics/ca/win/LegacyCACFLayerTreeHost.h:
+        * platform/graphics/cg/IOSurfacePool.cpp:
+        (WebCore::IOSurfacePool::collectionTimerFired):
+        * platform/graphics/cg/IOSurfacePool.h:
+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
+        (WebCore::MediaPlayerPrivateGStreamer::fillTimerFired):
+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.h:
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
+        (WebCore::MediaPlayerPrivateQTKit::seekTimerFired):
+        * platform/graphics/texmap/TextureMapper.cpp:
+        (WebCore::BitmapTexturePool::releaseUnusedTexturesTimerFired):
+        * platform/graphics/texmap/coordinated/CompositingCoordinator.cpp:
+        (WebCore::CompositingCoordinator::releaseInactiveAtlasesTimerFired):
+        * platform/graphics/texmap/coordinated/CompositingCoordinator.h:
+        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp:
+        (WebCore::CoordinatedGraphicsLayer::animationStartedTimerFired):
+        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h:
+        * platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp:
+        (WebCore::CoordinatedImageBacking::clearContentsTimerFired):
+        * platform/graphics/texmap/coordinated/CoordinatedImageBacking.h:
+        * platform/ios/LegacyTileCache.h:
+        * platform/ios/LegacyTileCache.mm:
+        (WebCore::LegacyTileCache::tileCreationTimerFired):
+        * platform/mac/HIDGamepadProvider.cpp:
+        (WebCore::HIDGamepadProvider::connectionDelayTimerFired):
+        (WebCore::HIDGamepadProvider::inputNotificationTimerFired):
+        * platform/mac/HIDGamepadProvider.h:
+        * platform/mac/ScrollAnimatorMac.h:
+        * platform/mac/ScrollAnimatorMac.mm:
+        (WebCore::ScrollAnimatorMac::snapRubberBandTimerFired):
+        (WebCore::ScrollAnimatorMac::initialScrollbarPaintTimerFired):
+        (WebCore::ScrollAnimatorMac::sendContentAreaScrolledTimerFired):
+        * platform/mock/DeviceMotionClientMock.cpp:
+        (WebCore::DeviceMotionClientMock::timerFired):
+        * platform/mock/DeviceMotionClientMock.h:
+        * platform/mock/DeviceOrientationClientMock.cpp:
+        (WebCore::DeviceOrientationClientMock::timerFired):
+        * platform/mock/DeviceOrientationClientMock.h:
+        * platform/mock/GeolocationClientMock.cpp:
+        (WebCore::GeolocationClientMock::permissionTimerFired):
+        (WebCore::GeolocationClientMock::controllerTimerFired):
+        * platform/mock/GeolocationClientMock.h:
+        * platform/mock/PlatformSpeechSynthesizerMock.cpp:
+        (WebCore::PlatformSpeechSynthesizerMock::speakingFinished):
+        * platform/mock/PlatformSpeechSynthesizerMock.h:
+        * platform/mock/TimerEventBasedMock.h:
+        (WebCore::TimerEvent::timerFired):
+        * platform/network/DNSResolveQueue.cpp:
+        (WebCore::DNSResolveQueue::timerFired):
+        * platform/network/DNSResolveQueue.h:
+        * platform/network/NetworkStateNotifier.h:
+        * platform/network/ResourceHandle.cpp:
+        (WebCore::ResourceHandle::failureTimerFired):
+        * platform/network/ResourceHandle.h:
+        * platform/network/ResourceHandleInternal.h:
+        * platform/network/curl/ResourceHandleManager.cpp:
+        (WebCore::ResourceHandleManager::downloadTimerCallback):
+        * platform/network/curl/ResourceHandleManager.h:
+        * platform/network/mac/NetworkStateNotifierMac.cpp:
+        (WebCore::NetworkStateNotifier::networkStateChangeTimerFired):
+        * platform/network/win/ResourceHandleWin.cpp:
+        (WebCore::ResourceHandle::fileLoadTimer):
+        * plugins/PluginPackage.cpp:
+        (WebCore::PluginPackage::freeLibraryTimerFired):
+        * plugins/PluginPackage.h:
+        * plugins/PluginStream.cpp:
+        (WebCore::PluginStream::delayDeliveryTimerFired):
+        * plugins/PluginStream.h:
+        * plugins/PluginView.cpp:
+        (WebCore::PluginView::popPopupsStateTimerFired):
+        (WebCore::PluginView::requestTimerFired):
+        (WebCore::PluginView::invalidateTimerFired):
+        (WebCore::PluginView::lifeSupportTimerFired):
+        * plugins/PluginView.h:
+        * plugins/win/PluginMessageThrottlerWin.cpp:
+        (WebCore::PluginMessageThrottlerWin::messageThrottleTimerFired):
+        * plugins/win/PluginMessageThrottlerWin.h:
+        * rendering/ImageQualityController.cpp:
+        (WebCore::ImageQualityController::highQualityRepaintTimerFired):
+        * rendering/ImageQualityController.h:
+        * rendering/RenderButton.cpp:
+        (WebCore::RenderButton::styleDidChange):
+        (WebCore::RenderButton::timerFired):
+        * rendering/RenderButton.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::updateCompositingLayersTimerFired):
+        (WebCore::RenderLayerCompositor::layerFlushTimerFired):
+        (WebCore::RenderLayerCompositor::paintRelatedMilestonesTimerFired):
+        * rendering/RenderLayerCompositor.h:
+        * rendering/RenderMarquee.cpp:
+        (WebCore::RenderMarquee::timerFired):
+        * rendering/RenderMarquee.h:
+        * rendering/RenderNamedFlowThread.cpp:
+        (WebCore::RenderNamedFlowThread::regionOversetChangeEventTimerFired):
+        * rendering/RenderNamedFlowThread.h:
+        * rendering/RenderProgress.cpp:
+        (WebCore::RenderProgress::animationTimerFired):
+        * rendering/RenderProgress.h:
+        * rendering/RenderView.cpp:
+        (WebCore::RenderView::lazyRepaintTimerFired):
+        * rendering/RenderView.h:
+        * replay/EventLoopInputDispatcher.cpp:
+        (WebCore::EventLoopInputDispatcher::timerFired):
+        * replay/EventLoopInputDispatcher.h:
+        * storage/StorageAreaImpl.cpp:
+        (WebCore::StorageAreaImpl::closeDatabaseTimerFired):
+        * storage/StorageAreaImpl.h:
+        * storage/StorageAreaSync.cpp:
+        (WebCore::StorageAreaSync::syncTimerFired):
+        * storage/StorageAreaSync.h:
+        * svg/SVGElement.cpp:
+        (WebCore::SVGElement::svgLoadEventTimerFired):
+        (WebCore::SVGElement::svgLoadEventTimer):
+        * svg/SVGElement.h:
+        * svg/SVGScriptElement.h:
+        * svg/SVGStyleElement.h:
+        * svg/SVGUseElement.h:
+        * svg/animation/SMILTimeContainer.cpp:
+        (WebCore::SMILTimeContainer::timerFired):
+        * svg/animation/SMILTimeContainer.h:
+        * xml/XMLHttpRequestProgressEventThrottle.cpp:
+        (WebCore::XMLHttpRequestProgressEventThrottle::dispatchDeferredEvents):
+        * xml/XMLHttpRequestProgressEventThrottle.h:
+
 2014-11-06  Yongjun Zhang  <yongjun_zhang@apple.com>
 
         Don't send identifierForInitialRequest callback method for request with DoNotSendCallbacks option.
index f5376cf070f8c54ba28ce3c7ff91cbfe1932d204..060d77e53c4790ab1a1745adc2a5aa7d2cda1fe1 100644 (file)
@@ -89,7 +89,7 @@ void MediaKeySession::generateKeyRequest(const String& mimeType, Uint8Array* ini
     m_keyRequestTimer.startOneShot(0);
 }
 
-void MediaKeySession::keyRequestTimerFired(Timer<MediaKeySession>&)
+void MediaKeySession::keyRequestTimerFired(Timer&)
 {
     ASSERT(m_pendingKeyRequests.size());
     if (!m_session)
@@ -147,7 +147,7 @@ void MediaKeySession::update(Uint8Array* key, ExceptionCode& ec)
     m_addKeyTimer.startOneShot(0);
 }
 
-void MediaKeySession::addKeyTimerFired(Timer<MediaKeySession>&)
+void MediaKeySession::addKeyTimerFired(Timer&)
 {
     ASSERT(m_pendingKeys.size());
     if (!m_session)
index f0269d4234461885332524b60df91e34ab3a051d..9c311ad2f641d10d30a95a4a312a97443cb80e0c 100644 (file)
@@ -84,8 +84,8 @@ public:
 
 protected:
     MediaKeySession(ScriptExecutionContext*, MediaKeys*, const String& keySystem);
-    void keyRequestTimerFired(Timer<MediaKeySession>&);
-    void addKeyTimerFired(Timer<MediaKeySession>&);
+    void keyRequestTimerFired(Timer&);
+    void addKeyTimerFired(Timer&);
 
     // CDMSessionClient
     virtual void sendMessage(Uint8Array*, String destinationURL);
@@ -104,10 +104,10 @@ protected:
         RefPtr<Uint8Array> initData;
     };
     Deque<PendingKeyRequest> m_pendingKeyRequests;
-    Timer<MediaKeySession> m_keyRequestTimer;
+    Timer m_keyRequestTimer;
 
     Deque<RefPtr<Uint8Array>> m_pendingKeys;
-    Timer<MediaKeySession> m_addKeyTimer;
+    Timer m_addKeyTimer;
 
 private:
     virtual void refEventTarget() override { ref(); }
index 7d8481186c76406577e5a2001fd7d5b3e7ad01da..81d6136e143c5937b547d8a212217c63abb5e558 100644 (file)
@@ -142,7 +142,7 @@ void Geolocation::GeoNotifier::stopTimer()
     m_timer.stop();
 }
 
-void Geolocation::GeoNotifier::timerFired(Timer<GeoNotifier>&)
+void Geolocation::GeoNotifier::timerFired(Timer&)
 {
     m_timer.stop();
 
@@ -297,7 +297,7 @@ void Geolocation::resume()
         m_resumeTimer.startOneShot(0);
 }
 
-void Geolocation::resumeTimerFired(Timer<Geolocation>&)
+void Geolocation::resumeTimerFired(Timer&)
 {
     m_isSuspended = false;
 
index 644dbfb24aefdb29640282a6d601d0d6b4596a60..55623d0e11d72080b0306d90c798b51aedc39854 100644 (file)
@@ -100,7 +100,7 @@ private:
 
         void startTimerIfNeeded();
         void stopTimer();
-        void timerFired(Timer<GeoNotifier>&);
+        void timerFired(Timer&);
         bool hasZeroTimeout() const;
 
     private:
@@ -110,7 +110,7 @@ private:
         RefPtr<PositionCallback> m_successCallback;
         RefPtr<PositionErrorCallback> m_errorCallback;
         RefPtr<PositionOptions> m_options;
-        Timer<GeoNotifier> m_timer;
+        Timer m_timer;
         RefPtr<PositionError> m_fatalError;
         bool m_useCachedPosition;
     };
@@ -186,8 +186,8 @@ private:
     bool m_hasChangedPosition;
     RefPtr<PositionError> m_errorWaitingForResume;
 
-    void resumeTimerFired(Timer<Geolocation>&);
-    Timer<Geolocation> m_resumeTimer;
+    void resumeTimerFired(Timer&);
+    Timer m_resumeTimer;
 #endif // PLATFORM(IOS)
 
     GeoNotifierSet m_requestsAwaitingCachedPosition;
index 379886cbe0c11eeddb8879e7f78b338a9f456fa0..a869e1308eb443573b32e0017bed4b7e934e237b 100644 (file)
@@ -270,7 +270,7 @@ void IDBTransactionBackend::commit()
     });
 }
 
-void IDBTransactionBackend::taskTimerFired(Timer<IDBTransactionBackend>&)
+void IDBTransactionBackend::taskTimerFired(Timer&)
 {
     LOG(StorageAPI, "IDBTransactionBackend::taskTimerFired");
 
index bb200dde32fdd33ba62b86d730f194bacd2ea654..ba5ea4f8a8160430de36e80b01b378ff52f0b5fa 100644 (file)
@@ -96,7 +96,7 @@ private:
     bool isTaskQueueEmpty() const;
     bool hasPendingTasks() const;
 
-    void taskTimerFired(Timer<IDBTransactionBackend>&);
+    void taskTimerFired(Timer&);
     void closeOpenCursors();
 
     const HashSet<int64_t> m_objectStoreIds;
@@ -113,7 +113,7 @@ private:
     Deque<RefPtr<IDBSynchronousOperation>> m_abortTaskQueue;
 
     // FIXME: delete the timer once we have threads instead.
-    Timer<IDBTransactionBackend> m_taskTimer;
+    Timer m_taskTimer;
     int m_pendingPreemptiveEvents;
 
     HashSet<IDBCursorBackend*> m_openCursors;
index 67921e3b32dd193b4c370a7f077c9bf655cb4c64..7659577d36d331d0d6a614ff345c70d9888b8acb 100644 (file)
@@ -447,7 +447,7 @@ void SourceBuffer::appendBufferInternal(unsigned char* data, unsigned size, Exce
     reportExtraMemoryCost();
 }
 
-void SourceBuffer::appendBufferTimerFired(Timer<SourceBuffer>&)
+void SourceBuffer::appendBufferTimerFired(Timer&)
 {
     if (isRemoved())
         return;
@@ -672,7 +672,7 @@ void SourceBuffer::removeCodedFrames(const MediaTime& start, const MediaTime& en
     LOG(Media, "SourceBuffer::removeCodedFrames(%p) - buffered = %s", this, toString(m_buffered->ranges()).utf8().data());
 }
 
-void SourceBuffer::removeTimerFired(Timer<SourceBuffer>*)
+void SourceBuffer::removeTimerFired(Timer*)
 {
     ASSERT(m_updating);
     ASSERT(m_pendingRemoveStart.isValid());
index ab48f937e64941c6cc291e507e5ff954bdd53202..d36802cec9f06a972c8d39d6815ee7c31c192158 100644 (file)
@@ -152,7 +152,7 @@ private:
     void scheduleEvent(const AtomicString& eventName);
 
     void appendBufferInternal(unsigned char*, unsigned, ExceptionCode&);
-    void appendBufferTimerFired(Timer<SourceBuffer>&);
+    void appendBufferTimerFired(Timer&);
 
     void setActive(bool);
 
@@ -166,7 +166,7 @@ private:
 
     void monitorBufferingRate();
 
-    void removeTimerFired(Timer<SourceBuffer>*);
+    void removeTimerFired(Timer*);
     void removeCodedFrames(const MediaTime& start, const MediaTime& end);
 
     size_t extraMemoryCost() const;
@@ -183,7 +183,7 @@ private:
     GenericEventQueue m_asyncEventQueue;
 
     Vector<unsigned char> m_pendingAppendData;
-    Timer<SourceBuffer> m_appendBufferTimer;
+    Timer m_appendBufferTimer;
 
     RefPtr<VideoTrackList> m_videoTracks;
     RefPtr<AudioTrackList> m_audioTracks;
@@ -210,7 +210,7 @@ private:
 
     MediaTime m_pendingRemoveStart;
     MediaTime m_pendingRemoveEnd;
-    Timer<SourceBuffer> m_removeTimer;
+    Timer m_removeTimer;
 
     bool m_updating;
     bool m_receivedFirstInitializationSegment;
index 559895f6079bedaf0c4f5a0ca4d239f2a506eea6..5ac5176edecfb7588932b081af592031cab14189 100644 (file)
@@ -361,7 +361,7 @@ void MediaStream::scheduleDispatchEvent(PassRefPtr<Event> event)
         m_scheduledEventTimer.startOneShot(0);
 }
 
-void MediaStream::scheduledEventTimerFired(Timer<MediaStream>*)
+void MediaStream::scheduledEventTimerFired(Timer*)
 {
     Vector<RefPtr<Event>> events;
     events.swap(m_scheduledEvents);
index 2681d2643cc5e05e90c44a7da8dc8a1c63ba214b..806fdcca5c85cff7fa779d91d51e0fbfbcd6cf06 100644 (file)
@@ -120,7 +120,7 @@ private:
     bool haveTrackWithSource(PassRefPtr<MediaStreamSource>);
 
     void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer<MediaStream>*);
+    void scheduledEventTimerFired(Timer*);
 
     void cloneMediaStreamTrackVector(Vector<RefPtr<MediaStreamTrack>>&, const Vector<RefPtr<MediaStreamTrack>>&);
 
@@ -130,7 +130,7 @@ private:
     Vector<RefPtr<MediaStreamTrack>> m_audioTracks;
     Vector<RefPtr<MediaStreamTrack>> m_videoTracks;
 
-    Timer<MediaStream> m_scheduledEventTimer;
+    Timer m_scheduledEventTimer;
     Vector<RefPtr<Event>> m_scheduledEvents;
 
     Vector<Observer*> m_observers;
index e5adcd667392139b6431323a7768e7c61287e48f..e242c40d25c6ef08ec28f4717eb93c2f0a439db4 100644 (file)
@@ -142,7 +142,7 @@ void RTCDTMFSender::scheduleDispatchEvent(PassRefPtr<Event> event)
         m_scheduledEventTimer.startOneShot(0);
 }
 
-void RTCDTMFSender::scheduledEventTimerFired(Timer<RTCDTMFSender>*)
+void RTCDTMFSender::scheduledEventTimerFired(Timer*)
 {
     if (m_stopped)
         return;
index 0e6b49d3211050dcd30a0355cadd2f01d1fe32ec..bed2a621295e4ca4691ed94c414f79943ed9c8fd 100644 (file)
@@ -72,7 +72,7 @@ private:
     RTCDTMFSender(ScriptExecutionContext*, PassRefPtr<MediaStreamTrack>, std::unique_ptr<RTCDTMFSenderHandler>);
 
     void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer<RTCDTMFSender>*);
+    void scheduledEventTimerFired(Timer*);
 
     // EventTarget
     virtual void refEventTarget() override { ref(); }
@@ -89,7 +89,7 @@ private:
 
     bool m_stopped;
 
-    Timer<RTCDTMFSender> m_scheduledEventTimer;
+    Timer m_scheduledEventTimer;
     Vector<RefPtr<Event>> m_scheduledEvents;
 };
 
index de784741c92ae86dca1d2ce3d77c1902bb5bc296..4233fd49caf658181badaf78566127187a39c30d 100644 (file)
@@ -312,7 +312,7 @@ void RTCDataChannel::scheduleDispatchEvent(PassRefPtr<Event> event)
         m_scheduledEventTimer.startOneShot(0);
 }
 
-void RTCDataChannel::scheduledEventTimerFired(Timer<RTCDataChannel>*)
+void RTCDataChannel::scheduledEventTimerFired(Timer*)
 {
     if (m_stopped)
         return;
index 54a21d441de9982b1c3f44b96a9dcc78100bae3c..6f8038e28b648e1729cdc03ffd549af244c0d4e7 100644 (file)
@@ -89,7 +89,7 @@ private:
     RTCDataChannel(ScriptExecutionContext*, std::unique_ptr<RTCDataChannelHandler>);
 
     void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer<RTCDataChannel>*);
+    void scheduledEventTimerFired(Timer*);
 
     // EventTarget
     virtual void refEventTarget() override { ref(); }
@@ -114,7 +114,7 @@ private:
     };
     BinaryType m_binaryType;
 
-    Timer<RTCDataChannel> m_scheduledEventTimer;
+    Timer m_scheduledEventTimer;
     Vector<RefPtr<Event>> m_scheduledEvents;
 };
 
index 3519c3d2dd13d63849966a4333ebe6a7c96ecd12..247b62f3af976995f54f0d44b1f87963758500fb 100644 (file)
@@ -724,7 +724,7 @@ void RTCPeerConnection::scheduleDispatchEvent(PassRefPtr<Event> event)
         m_scheduledEventTimer.startOneShot(0);
 }
 
-void RTCPeerConnection::scheduledEventTimerFired(Timer<RTCPeerConnection>*)
+void RTCPeerConnection::scheduledEventTimerFired(Timer*)
 {
     if (m_stopped)
         return;
index ba8e7ae752403df726debea28ba75aac41cfb06a..aabfcdc2c2180230a1ae6ee2faec51d067d627d2 100644 (file)
@@ -139,7 +139,7 @@ private:
 
     static PassRefPtr<RTCConfiguration> parseConfiguration(const Dictionary& configuration, ExceptionCode&);
     void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer<RTCPeerConnection>*);
+    void scheduledEventTimerFired(Timer*);
     bool hasLocalStreamWithTrackId(const String& trackId);
 
     // EventTarget implementation.
@@ -164,7 +164,7 @@ private:
 
     std::unique_ptr<RTCPeerConnectionHandler> m_peerHandler;
 
-    Timer<RTCPeerConnection> m_scheduledEventTimer;
+    Timer m_scheduledEventTimer;
     Vector<RefPtr<Event>> m_scheduledEvents;
 
     RefPtr<RTCConfiguration> m_configuration;
index 36ae61fe47ddeba1426424513fced3d95c662ec6..4e838300672022a3691f0444fb4b5f21f12d817d 100644 (file)
@@ -84,7 +84,7 @@ Notification::Notification(ScriptExecutionContext& context, const String& title)
     : ActiveDOMObject(&context)
     , m_title(title)
     , m_state(Idle)
-    , m_taskTimer(std::make_unique<Timer<Notification>>(this, &Notification::taskTimerFired))
+    , m_taskTimer(std::make_unique<Timer>(this, &Notification::taskTimerFired))
 {
     m_notificationCenter = DOMWindowNotifications::webkitNotifications(downcast<Document>(context).domWindow());
     
@@ -201,7 +201,7 @@ void Notification::dispatchErrorEvent()
 }
 
 #if ENABLE(NOTIFICATIONS)
-void Notification::taskTimerFired(Timer<Notification>& timer)
+void Notification::taskTimerFired(Timer& timer)
 {
     ASSERT(scriptExecutionContext()->isDocument());
     ASSERT_UNUSED(timer, &timer == m_taskTimer.get());
index a9801008393c5721930cded1d93c3d586c54e23f..38baa68821112e6c5cbd2866ece674e4bc86f538 100644 (file)
@@ -157,7 +157,7 @@ private:
     void finishLoadingIcon();
 
 #if ENABLE(NOTIFICATIONS)
-    void taskTimerFired(Timer<Notification>&);
+    void taskTimerFired(Timer&);
 #endif
 
     // Text notifications.
@@ -179,7 +179,7 @@ private:
     RefPtr<NotificationCenter> m_notificationCenter;
 
 #if ENABLE(NOTIFICATIONS)
-    std::unique_ptr<Timer<Notification>> m_taskTimer;
+    std::unique_ptr<Timer> m_taskTimer;
 #endif
 };
 
index 2a83553e89edc2a34c61660eeb2185be73b73f1b..bafb5ca3597d3a50a3bc0273170a9fe25d378d3f 100644 (file)
@@ -129,7 +129,7 @@ void NotificationCenter::NotificationRequestCallback::startTimer()
     m_timer.startOneShot(0);
 }
 
-void NotificationCenter::NotificationRequestCallback::timerFired(Timer<NotificationCenter::NotificationRequestCallback>&)
+void NotificationCenter::NotificationRequestCallback::timerFired(Timer&)
 {
     if (m_callback)
         m_callback->handleEvent();
index 70acc4ff487f914505e1492816d0e85bf8c8997e..edabb62adf305402d626aceacf32918e65c12af6 100644 (file)
@@ -80,12 +80,12 @@ private:
     public:
         static PassRefPtr<NotificationRequestCallback> createAndStartTimer(NotificationCenter*, PassRefPtr<VoidCallback>);
         void startTimer();
-        void timerFired(Timer<NotificationRequestCallback>&);
+        void timerFired(Timer&);
     private:
         NotificationRequestCallback(NotificationCenter*, PassRefPtr<VoidCallback>);
 
         RefPtr<NotificationCenter> m_notificationCenter;
-        Timer<NotificationRequestCallback> m_timer;
+        Timer m_timer;
         RefPtr<VoidCallback> m_callback;
     };
 
index e09cb30bbefc2de68f4f6cd6df7aae9c944c30f9..50b452a1a6b22ad872095b7899f2a34c123014bf 100644 (file)
@@ -91,7 +91,7 @@ void Vibration::cancelVibration()
     }
 }
 
-void Vibration::timerFired(Timer<Vibration>* timer)
+void Vibration::timerFired(Timer* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_timer);
 
index cc529a07affb451b30006a1d1ee366d022085d25..20673af81c0ece79c5384e5e7667365083cc7993 100644 (file)
@@ -40,7 +40,7 @@ public:
     // FIXME: When a visibilitychange event is dispatched while vibrating, the vibration should be canceled.
     void cancelVibration();
 
-    void timerFired(Timer<Vibration>*);
+    void timerFired(Timer*);
 
     static const char* supplementName();
     static Vibration* from(Page* page) { return static_cast<Vibration*>(Supplement<Page>::from(page, supplementName())); }
@@ -51,7 +51,7 @@ private:
     enum class State { Idle, Vibrating, Waiting };
 
     VibrationClient* m_vibrationClient;
-    Timer<Vibration> m_timer;
+    Timer m_timer;
     State m_state;
     VibrationPattern m_pattern;
 };
index 932c840e465d897eedefa71187024d4548a3a4a9..7fd621e2b3588b819749e27993a0049e29f341f6 100644 (file)
@@ -449,7 +449,7 @@ bool WebSocketChannel::processBuffer()
     return processFrame();
 }
 
-void WebSocketChannel::resumeTimerFired(Timer<WebSocketChannel>* timer)
+void WebSocketChannel::resumeTimerFired(Timer* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_resumeTimer);
 
@@ -491,7 +491,7 @@ void WebSocketChannel::startClosingHandshake(int code, const String& reason)
         m_client->didStartClosingHandshake();
 }
 
-void WebSocketChannel::closingTimerFired(Timer<WebSocketChannel>* timer)
+void WebSocketChannel::closingTimerFired(Timer* timer)
 {
     LOG(Network, "WebSocketChannel %p closingTimerFired()", this);
     ASSERT_UNUSED(timer, &m_closingTimer == timer);
index 715946cae62c264b05a2bb4108b48ab7f827603b..e4fac2b9bc4d7531df604e96df6365a1b6d8107f 100644 (file)
@@ -127,9 +127,9 @@ private:
     bool appendToBuffer(const char* data, size_t len);
     void skipBuffer(size_t len);
     bool processBuffer();
-    void resumeTimerFired(Timer<WebSocketChannel>*);
+    void resumeTimerFired(Timer*);
     void startClosingHandshake(int code, const String& reason);
-    void closingTimerFired(Timer<WebSocketChannel>*);
+    void closingTimerFired(Timer*);
 
     bool processFrame();
 
@@ -190,11 +190,11 @@ private:
     RefPtr<SocketStreamHandle> m_handle;
     Vector<char> m_buffer;
 
-    Timer<WebSocketChannel> m_resumeTimer;
+    Timer m_resumeTimer;
     bool m_suspended;
     bool m_closing;
     bool m_receivedClosingHandshake;
-    Timer<WebSocketChannel> m_closingTimer;
+    Timer m_closingTimer;
     bool m_closed;
     bool m_shouldDiscardReceivedData;
     unsigned long m_unhandledBufferedAmount;
index 02452d590775c182798bc9c1eab493abbf27699f..d8afb257fab8f9989b414f3a9a93416ee9d05348 100644 (file)
@@ -700,7 +700,7 @@ void AXObjectCache::childrenChanged(AccessibilityObject* obj)
     obj->childrenChanged();
 }
     
-void AXObjectCache::notificationPostTimerFired(Timer<AXObjectCache>&)
+void AXObjectCache::notificationPostTimerFired(Timer&)
 {
     Ref<Document> protectorForCacheOwner(m_document);
     m_notificationPostTimer.stop();
index 6f8e6852961c06152fab0386b0c23e5f17f4236c..b4b5c37f6a12b55b6cde564fc9cbae6cdb11f685 100644 (file)
@@ -242,9 +242,9 @@ private:
     
     HashSet<AXID> m_idsInUse;
     
-    Timer<AXObjectCache> m_notificationPostTimer;
+    Timer m_notificationPostTimer;
     Vector<std::pair<RefPtr<AccessibilityObject>, AXNotification>> m_notificationsToPost;
-    void notificationPostTimerFired(Timer<AXObjectCache>&);
+    void notificationPostTimerFired(Timer&);
     void handleMenuOpened(Node*);
     void handleLiveRegionCreated(Node*);
     void handleMenuItemSelected(Node*);
@@ -271,7 +271,7 @@ bool isNodeAriaVisible(Node*);
 #if !HAVE(ACCESSIBILITY)
 inline AccessibilityObjectInclusion AXComputedObjectAttributeCache::getIgnored(AXID) const { return DefaultBehavior; }
 inline void AXComputedObjectAttributeCache::setIgnored(AXID, AccessibilityObjectInclusion) { }
-inline AXObjectCache::AXObjectCache(Document& document) : m_document(document), m_notificationPostTimer(this, (Timer<AXObjectCache>::TimerFiredFunction) nullptr) { }
+inline AXObjectCache::AXObjectCache(Document& document) : m_document(document), m_notificationPostTimer(this, (Timer::TimerFiredFunction) nullptr) { }
 inline AXObjectCache::~AXObjectCache() { }
 inline AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page*) { return nullptr; }
 inline AccessibilityObject* AXObjectCache::get(RenderObject*) { return nullptr; }
index eb8bc0c19789a388186d7565ce1b5ab972eecd3a..c69156cc43b040bc47bf7da50237746cff9caa36 100644 (file)
@@ -73,7 +73,7 @@ void GCController::garbageCollectSoon()
 }
 
 #if !USE(CF)
-void GCController::gcTimerFired(Timer<GCController>*)
+void GCController::gcTimerFired(Timer*)
 {
     collect(nullptr);
 }
index 1c2d9141c90c647a037b8c0c4fdd901e8e406165..a371510a4d2dec00591840c695d863f734ce6f58 100644 (file)
@@ -52,8 +52,8 @@ namespace WebCore {
         GCController(); // Use gcController() instead
 
 #if !USE(CF)
-        void gcTimerFired(Timer<GCController>*);
-        Timer<GCController> m_GCTimer;
+        void gcTimerFired(Timer*);
+        Timer m_GCTimer;
 #endif
     };
 
index 4e3d41e613a9dc5a42d10d4e4abf485b62b3be80..e80fc29db72e42e6ed4d2443bbf95748c929d038 100644 (file)
@@ -75,7 +75,7 @@ public:
 #endif
 
 private:
-    void startLoadingTimerFired(Timer<CSSFontFaceSource>*);
+    void startLoadingTimerFired(Timer*);
 
     AtomicString m_string; // URI for remote, built-in font name for local.
     CachedResourceHandle<CachedFont> m_font; // For remote fonts, a pointer to our cached resource.
index 3925aee24eba1c3f75cc500e0540024f46bc1cb0..1150889e8722c3953bfd9ad7ad0acab34684d93a 100644 (file)
@@ -587,7 +587,7 @@ void CSSFontSelector::beginLoadingFontSoon(CachedFont* font)
     m_beginLoadingTimer.startOneShot(0);
 }
 
-void CSSFontSelector::beginLoadTimerFired(Timer<WebCore::CSSFontSelector>&)
+void CSSFontSelector::beginLoadTimerFired(Timer&)
 {
     Vector<CachedResourceHandle<CachedFont>> fontsToBeginLoading;
     fontsToBeginLoading.swap(m_fontsToBeginLoading);
index e1e5a05e0548cc7a1f565b71c5b21b6da08948f7..18bf1896b803a5a0eba3eaf8cf09cf32d35701b9 100644 (file)
@@ -86,7 +86,7 @@ private:
 
     void dispatchInvalidationCallbacks();
 
-    void beginLoadTimerFired(Timer<CSSFontSelector>&);
+    void beginLoadTimerFired(Timer&);
 
     Document* m_document;
     HashMap<String, std::unique_ptr<Vector<RefPtr<CSSFontFace>>>, CaseFoldingHash> m_fontFaces;
@@ -95,7 +95,7 @@ private:
     HashSet<FontSelectorClient*> m_clients;
 
     Vector<CachedResourceHandle<CachedFont>> m_fontsToBeginLoading;
-    Timer<CSSFontSelector> m_beginLoadingTimer;
+    Timer m_beginLoadingTimer;
 
     unsigned m_uniqueId;
     unsigned m_version;
index 2cd7ce5e00d18febf896dcd4cdf86af916199263..1778771cc945af5fe55a269605b00c320b6b4793 100644 (file)
@@ -349,7 +349,7 @@ StyleResolver::~StyleResolver()
 #endif
 }
 
-void StyleResolver::sweepMatchedPropertiesCache(Timer<StyleResolver>*)
+void StyleResolver::sweepMatchedPropertiesCache(Timer*)
 {
     // Look for cache entries containing a style declaration with a single ref and remove them.
     // This may happen when an element attribute mutation causes it to generate a new inlineStyle()
index 0ea1023d2e9527ce0df943ea641465a1125e7247..e3bf36303790e166438315f7bc0cfc3e6c79a389 100644 (file)
@@ -498,7 +498,7 @@ private:
 
     // Every N additions to the matched declaration cache trigger a sweep where entries holding
     // the last reference to a style declaration are garbage collected.
-    void sweepMatchedPropertiesCache(Timer<StyleResolver>*);
+    void sweepMatchedPropertiesCache(Timer*);
 
     bool classNamesAffectedByRules(const SpaceSplitString&) const;
     bool sharingCandidateHasIdenticalStyleAffectingAttributes(StyledElement*) const;
@@ -513,7 +513,7 @@ private:
     typedef HashMap<unsigned, MatchedPropertiesCacheItem> MatchedPropertiesCache;
     MatchedPropertiesCache m_matchedPropertiesCache;
 
-    Timer<StyleResolver> m_matchedPropertiesCacheSweepTimer;
+    Timer m_matchedPropertiesCacheSweepTimer;
 
     std::unique_ptr<MediaQueryEvaluator> m_medium;
     RefPtr<RenderStyle> m_rootDefaultStyle;
index ffa02664110f42b6a5fe5025f7f648da608a9c58..d75f75554a3524d707989022ef55e58396668a1d 100644 (file)
@@ -1265,7 +1265,7 @@ void Document::setVisualUpdatesAllowed(bool visualUpdatesAllowed)
         frame->loader().forcePageTransitionIfNeeded();
 }
 
-void Document::visualUpdatesSuppressionTimerFired(Timer<Document>&)
+void Document::visualUpdatesSuppressionTimerFired(Timer&)
 {
     ASSERT(!m_visualUpdatesAllowed);
 
@@ -1746,7 +1746,7 @@ bool Document::hasPendingForcedStyleRecalc() const
     return m_styleRecalcTimer.isActive() && m_pendingStyleRecalcShouldForce;
 }
 
-void Document::styleRecalcTimerFired(Timer<Document>&)
+void Document::styleRecalcTimerFired(Timer&)
 {
     updateStyleIfNeeded();
 }
@@ -3245,7 +3245,7 @@ void Document::evaluateMediaQueryList()
         m_mediaQueryMatcher->styleResolverChanged();
 }
 
-void Document::optimizedStyleSheetUpdateTimerFired(Timer<Document>&)
+void Document::optimizedStyleSheetUpdateTimerFired(Timer&)
 {
     styleResolverChanged(RecalcStyleIfNeeded);
 }
@@ -4630,7 +4630,7 @@ void Document::finishedParsing()
     m_cachedResourceLoader->clearPreloads();
 }
 
-void Document::sharedObjectPoolClearTimerFired(Timer<Document>&)
+void Document::sharedObjectPoolClearTimerFired(Timer&)
 {
     m_sharedObjectPool = nullptr;
 }
@@ -4869,7 +4869,7 @@ void Document::cancelFocusAppearanceUpdate()
     m_updateFocusAppearanceTimer.stop();
 }
 
-void Document::updateFocusAppearanceTimerFired(Timer<Document>&)
+void Document::updateFocusAppearanceTimerFired(Timer&)
 {
     Element* element = focusedElement();
     if (!element)
@@ -5024,7 +5024,7 @@ void Document::postTask(Task task)
     });
 }
 
-void Document::pendingTasksTimerFired(Timer<Document>&)
+void Document::pendingTasksTimerFired(Timer&)
 {
     Vector<Task> pendingTasks = WTF::move(m_pendingTasks);
     for (auto& task : pendingTasks)
@@ -5559,7 +5559,7 @@ void Document::fullScreenRendererDestroyed()
     m_fullScreenRenderer = nullptr;
 }
 
-void Document::fullScreenChangeDelayTimerFired(Timer<Document>&)
+void Document::fullScreenChangeDelayTimerFired(Timer&)
 {
     // Since we dispatch events in this function, it's possible that the
     // document will be detached and GC'd. We protect it here to make sure we
@@ -5697,7 +5697,7 @@ void Document::decrementLoadEventDelayCount()
         m_loadEventDelayTimer.startOneShot(0);
 }
 
-void Document::loadEventDelayTimerFired(Timer<Document>&)
+void Document::loadEventDelayTimerFired(Timer&)
 {
     if (frame())
         frame()->loader().checkCompleted();
@@ -6213,7 +6213,7 @@ void Document::didAssociateFormControl(Element* element)
         m_didAssociateFormControlsTimer.startOneShot(0);
 }
 
-void Document::didAssociateFormControlsTimerFired(Timer<Document>& timer)
+void Document::didAssociateFormControlsTimerFired(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_didAssociateFormControlsTimer);
 
@@ -6241,7 +6241,7 @@ void Document::invalidateDOMCookieCache()
     m_cachedDOMCookies = String();
 }
 
-void Document::domCookieCacheExpiryTimerFired(Timer<Document>&)
+void Document::domCookieCacheExpiryTimerFired(Timer&)
 {
     invalidateDOMCookieCache();
 }
index c00e54400782e0c71addbd83303bee501fbe06ba..719d6ccc65eeb3ba80b875a5cf1495d058c542c8 100644 (file)
@@ -773,8 +773,8 @@ public:
     void unscheduleStyleRecalc();
     bool hasPendingStyleRecalc() const;
     bool hasPendingForcedStyleRecalc() const;
-    void styleRecalcTimerFired(Timer<Document>&);
-    void optimizedStyleSheetUpdateTimerFired(Timer<Document>&);
+    void styleRecalcTimerFired(Timer&);
+    void optimizedStyleSheetUpdateTimerFired(Timer&);
 
     void registerNodeListForInvalidation(LiveNodeList&);
     void unregisterNodeListForInvalidation(LiveNodeList&);
@@ -1145,7 +1145,7 @@ public:
     RenderFullScreen* fullScreenRenderer() const { return m_fullScreenRenderer; }
     void fullScreenRendererDestroyed();
     
-    void fullScreenChangeDelayTimerFired(Timer<Document>&);
+    void fullScreenChangeDelayTimerFired(Timer&);
     bool fullScreenIsAllowedForElement(Element*) const;
     void fullScreenElementRemoved();
     void removeFullScreenElementOfSubtree(Node*, bool amongChildrenOnly = false);
@@ -1337,16 +1337,16 @@ private:
     virtual double timerAlignmentInterval() const override final;
 
     void updateTitle(const StringWithDirection&);
-    void updateFocusAppearanceTimerFired(Timer<Document>&);
+    void updateFocusAppearanceTimerFired(Timer&);
     void updateBaseURL();
 
     void buildAccessKeyMap(TreeScope* root);
 
     void createStyleResolver();
 
-    void loadEventDelayTimerFired(Timer<Document>&);
+    void loadEventDelayTimerFired(Timer&);
 
-    void pendingTasksTimerFired(Timer<Document>&);
+    void pendingTasksTimerFired(Timer&);
 
     template <typename CharacterType>
     void displayBufferModifiedByEncodingInternal(CharacterType*, unsigned) const;
@@ -1367,18 +1367,18 @@ private:
 
     void setVisualUpdatesAllowed(ReadyState);
     void setVisualUpdatesAllowed(bool);
-    void visualUpdatesSuppressionTimerFired(Timer<Document>&);
+    void visualUpdatesSuppressionTimerFired(Timer&);
 
     void addListenerType(ListenerType listenerType) { m_listenerTypes |= listenerType; }
 
-    void didAssociateFormControlsTimerFired(Timer<Document>&);
+    void didAssociateFormControlsTimerFired(Timer&);
 
     // DOM Cookies caching.
     const String& cachedDOMCookies() const { return m_cachedDOMCookies; }
     void setCachedDOMCookies(const String&);
     bool isDOMCookieCacheValid() const { return m_cookieCacheExpiryTimer.isActive(); }
     void invalidateDOMCookieCache();
-    void domCookieCacheExpiryTimerFired(Timer<Document>&);
+    void domCookieCacheExpiryTimerFired(Timer&);
     virtual void didLoadResourceSynchronously(const ResourceRequest&) override final;
 
     unsigned m_referencingNodeCount;
@@ -1468,8 +1468,8 @@ private:
     ReadyState m_readyState;
     bool m_bParsing;
 
-    Timer<Document> m_optimizedStyleSheetUpdateTimer;
-    Timer<Document> m_styleRecalcTimer;
+    Timer m_optimizedStyleSheetUpdateTimer;
+    Timer m_styleRecalcTimer;
     bool m_pendingStyleRecalcShouldForce;
     bool m_inStyleRecalc;
     bool m_closeAfterStyleRecalc;
@@ -1492,7 +1492,7 @@ private:
     std::unique_ptr<AXObjectCache> m_axObjectCache;
     const std::unique_ptr<DocumentMarkerController> m_markers;
     
-    Timer<Document> m_updateFocusAppearanceTimer;
+    Timer m_updateFocusAppearanceTimer;
 
     Element* m_cssTarget;
 
@@ -1591,7 +1591,7 @@ private:
     RefPtr<Element> m_fullScreenElement;
     Vector<RefPtr<Element>> m_fullScreenElementStack;
     RenderFullScreen* m_fullScreenRenderer;
-    Timer<Document> m_fullScreenChangeDelayTimer;
+    Timer m_fullScreenChangeDelayTimer;
     Deque<RefPtr<Node>> m_fullScreenChangeEventTargetQueue;
     Deque<RefPtr<Node>> m_fullScreenErrorEventTargetQueue;
     bool m_isAnimatingFullScreen;
@@ -1600,7 +1600,7 @@ private:
 #endif
 
     int m_loadEventDelayCount;
-    Timer<Document> m_loadEventDelayTimer;
+    Timer m_loadEventDelayTimer;
 
     ViewportArguments m_viewportArguments;
 
@@ -1656,7 +1656,7 @@ private:
     bool m_isTelephoneNumberParsingAllowed;
 #endif
 
-    Timer<Document> m_pendingTasksTimer;
+    Timer m_pendingTasksTimer;
     Vector<Task> m_pendingTasks;
 
 #if ENABLE(IOS_TEXT_AUTOSIZING)
@@ -1679,7 +1679,7 @@ private:
     bool m_scheduledTasksAreSuspended;
     
     bool m_visualUpdatesAllowed;
-    Timer<Document> m_visualUpdatesSuppressionTimer;
+    Timer m_visualUpdatesSuppressionTimer;
 
     RefPtr<NamedFlowCollection> m_namedFlows;
 
@@ -1687,8 +1687,8 @@ private:
     RefPtr<DOMSecurityPolicy> m_domSecurityPolicy;
 #endif
 
-    void sharedObjectPoolClearTimerFired(Timer<Document>&);
-    Timer<Document> m_sharedObjectPoolClearTimer;
+    void sharedObjectPoolClearTimerFired(Timer&);
+    Timer m_sharedObjectPoolClearTimer;
 
     std::unique_ptr<DocumentSharedObjectPool> m_sharedObjectPool;
 
@@ -1712,8 +1712,8 @@ private:
     RefPtr<JSC::InputCursor> m_inputCursor;
 #endif
 
-    Timer<Document> m_didAssociateFormControlsTimer;
-    Timer<Document> m_cookieCacheExpiryTimer;
+    Timer m_didAssociateFormControlsTimer;
+    Timer m_cookieCacheExpiryTimer;
     String m_cachedDOMCookies;
     HashSet<RefPtr<Element>> m_associatedFormControls;
     unsigned m_disabledFieldsetElementsCount;
index 04fe258f722e28ad4f6ce1a3e46a813b1c4d5129..550021ab1986e2036fcd44c029acc43fa89a773a 100644 (file)
@@ -49,10 +49,10 @@ public:
 #endif
 
 private:
-    void timerFired(Timer<EventSender<T>>&) { dispatchPendingEvents(); }
+    void timerFired(Timer&) { dispatchPendingEvents(); }
 
     AtomicString m_eventType;
-    Timer<EventSender<T>> m_timer;
+    Timer m_timer;
     Vector<T*> m_dispatchSoonList;
     Vector<T*> m_dispatchingList;
 };
index cf6781d6ae3f936c4d3dc2da871ae4adae6761de..b72f7e7a1ce6e831c61e3595125ad1a2bfe12bc5 100644 (file)
@@ -58,7 +58,7 @@ bool GenericEventQueue::enqueueEvent(PassRefPtr<Event> event)
     return true;
 }
 
-void GenericEventQueue::timerFired(Timer<GenericEventQueue>&)
+void GenericEventQueue::timerFired(Timer&)
 {
     ASSERT(!m_timer.isActive());
     ASSERT(!m_pendingEvents.isEmpty());
index 9fc2066d37a2e42354045e5cbad3817a90ee5120..36558902ab30ede27cfe9e4c0f7d83fd68817ea8 100644 (file)
@@ -48,11 +48,11 @@ public:
     bool hasPendingEvents() const;
 
 private:
-    void timerFired(Timer<GenericEventQueue>&);
+    void timerFired(Timer&);
 
     EventTarget& m_owner;
     Vector<RefPtr<Event>> m_pendingEvents;
-    Timer<GenericEventQueue> m_timer;
+    Timer m_timer;
     bool m_isClosed;
 };
 
index 99489636bde95b7784e84bd5578b935711949875..096e3c517c9f0ff80bc4c78bb28191293145b7aa 100644 (file)
@@ -96,7 +96,7 @@ void ScriptRunner::notifyScriptReady(ScriptElement* scriptElement, ExecutionType
     m_timer.startOneShot(0);
 }
 
-void ScriptRunner::timerFired(Timer<ScriptRunner>& timer)
+void ScriptRunner::timerFired(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_timer);
 
index d7e692c909f786435211b854ea9a7ae15803221e..e13df8e07c311a5ac7a03e88848bf417dfbcb516 100644 (file)
@@ -54,13 +54,13 @@ public:
     void notifyScriptReady(ScriptElement*, ExecutionType);
 
 private:
-    void timerFired(Timer<ScriptRunner>&);
+    void timerFired(Timer&);
 
     Document& m_document;
     Vector<PendingScript> m_scriptsToExecuteInOrder;
     Vector<PendingScript> m_scriptsToExecuteSoon; // http://www.whatwg.org/specs/web-apps/current-work/#set-of-scripts-that-will-execute-as-soon-as-possible
     HashMap<ScriptElement*, PendingScript> m_pendingAsyncScripts;
-    Timer<ScriptRunner> m_timer;
+    Timer m_timer;
 };
 
 }
index 626bd4fbbe0ca8aec2f8fd443aa112d898129a50..78562e70cb1079381ace0f85ad7cbb19e73852e5 100644 (file)
@@ -211,7 +211,7 @@ void ScriptedAnimationController::scheduleAnimation()
 }
 
 #if USE(REQUEST_ANIMATION_FRAME_TIMER)
-void ScriptedAnimationController::animationTimerFired(Timer<ScriptedAnimationController>&)
+void ScriptedAnimationController::animationTimerFired(Timer&)
 {
     m_lastAnimationFrameTimeMonotonic = monotonicallyIncreasingTime();
     serviceScriptedAnimations(m_lastAnimationFrameTimeMonotonic);
index 73296e98655d888e831bed5897916bb20d71721a..002c71efbdfba340277cb621ca7164b6dd608e42 100644 (file)
@@ -84,8 +84,8 @@ private:
     void scheduleAnimation();
 
 #if USE(REQUEST_ANIMATION_FRAME_TIMER)
-    void animationTimerFired(Timer<ScriptedAnimationController>&);
-    Timer<ScriptedAnimationController> m_animationTimer;
+    void animationTimerFired(Timer&);
+    Timer m_animationTimer;
     double m_lastAnimationFrameTimeMonotonic;
 
 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
index d681106c977b5e913005831fdb4a86815e37e640..3a246b426c04f88771d69e4a8eb793ea20247df3 100644 (file)
@@ -99,7 +99,7 @@ private:
     static const int minimumPresentationAttributeCacheSizeForCleaning = 100;
     static const unsigned minimumPresentationAttributeCacheHitCountPerMinute = (100 * presentationAttributeCacheCleanTimeInSeconds) / 60;
 
-    void cleanCache(Timer<PresentationAttributeCacheCleaner>* timer)
+    void cleanCache(Timer* timer)
     {
         ASSERT_UNUSED(timer, timer == &m_cleanTimer);
         unsigned hitCount = m_hitCount;
@@ -110,7 +110,7 @@ private:
     }
 
     unsigned m_hitCount;
-    Timer<PresentationAttributeCacheCleaner> m_cleanTimer;
+    Timer m_cleanTimer;
 };
 
 static PresentationAttributeCacheCleaner& presentationAttributeCacheCleaner()
index 1a6e54e6c4cd877cebb39f130379c2ef2111b620..973613d4af56c3275debb256fe0f32e7ca407726 100644 (file)
@@ -327,7 +327,7 @@ void AlternativeTextController::respondToUnappliedSpellCorrection(const VisibleS
     markers.addMarker(range.get(), DocumentMarker::SpellCheckingExemption);
 }
 
-void AlternativeTextController::timerFired(Timer<AlternativeTextController>&)
+void AlternativeTextController::timerFired(Timer&)
 {
     m_isDismissedByEditing = false;
     switch (m_alternativeTextInfo.type) {
index e8463ab0c66c8bff2e404ab0b6202a1cb6d8ea56..f12f81a807b836e87b328322c96fc5d35df30688 100644 (file)
@@ -138,7 +138,7 @@ private:
 #if USE(AUTOCORRECTION_PANEL)
     String dismissSoon(ReasonForDismissingAlternativeText);
     void applyAlternativeTextToRange(const Range*, const String& alternative, AlternativeTextType, const Vector<DocumentMarker::MarkerType>&);
-    void timerFired(Timer<AlternativeTextController>&);
+    void timerFired(Timer&);
     void recordAutocorrectionResponseReversed(const String& replacedString, const String& replacementString);
     void recordSpellcheckerResponseForModifiedCorrection(Range* rangeOfCorrection, const String& corrected, const String& correction);
     String markerDescriptionForAppliedAlternativeText(AlternativeTextType, DocumentMarker::MarkerType);
@@ -153,7 +153,7 @@ private:
     FloatRect rootViewRectForRange(const Range*) const;
     void markPrecedingWhitespaceForDeletedAutocorrectionAfterCommand(EditCommand*);
 
-    Timer<AlternativeTextController> m_timer;
+    Timer m_timer;
     AlternativeTextInfo m_alternativeTextInfo;
     bool m_isDismissedByEditing;
 
index 0dab96e4d2b03f3650acff72e6326271b8f9499f..b82e2cc119c54856d185dbf80b514ff441408617 100644 (file)
@@ -3270,7 +3270,7 @@ bool Editor::shouldDetectTelephoneNumbers()
     return document().isTelephoneNumberParsingEnabled() && TelephoneNumberDetector::isSupported();
 }
 
-void Editor::scanSelectionForTelephoneNumbers(Timer<Editor>&)
+void Editor::scanSelectionForTelephoneNumbers(Timer&)
 {
     scanSelectionForTelephoneNumbers();
 }
@@ -3377,7 +3377,7 @@ void Editor::updateEditorUINowIfScheduled()
     editorUIUpdateTimerFired(m_editorUIUpdateTimer);
 }
 
-void Editor::editorUIUpdateTimerFired(Timer<Editor>&)
+void Editor::editorUIUpdateTimerFired(Timer&)
 {
     VisibleSelection oldSelection = m_oldSelectionForEditorUIUpdate;
 
index f08efe7588c275dfb16526857c80c0658d72af14..8be1f73b9a043d8dcd4816b809d81e558c0cf707 100644 (file)
@@ -472,7 +472,7 @@ private:
     enum EditorActionSpecifier { CutAction, CopyAction };
     void performCutOrCopy(EditorActionSpecifier);
 
-    void editorUIUpdateTimerFired(Timer<Editor>&);
+    void editorUIUpdateTimerFired(Timer&);
 
     Node* findEventTargetFromSelection() const;
 
@@ -504,16 +504,16 @@ private:
     bool m_overwriteModeEnabled;
 
     VisibleSelection m_oldSelectionForEditorUIUpdate;
-    Timer<Editor> m_editorUIUpdateTimer;
+    Timer m_editorUIUpdateTimer;
     bool m_editorUIUpdateTimerShouldCheckSpellingAndGrammar;
     bool m_editorUIUpdateTimerWasTriggeredByDictation;
 
 #if ENABLE(TELEPHONE_NUMBER_DETECTION) && !PLATFORM(IOS)
     bool shouldDetectTelephoneNumbers();
-    void scanSelectionForTelephoneNumbers(Timer<Editor>&);
+    void scanSelectionForTelephoneNumbers(Timer&);
     void scanRangeForTelephoneNumbers(Range&, const StringView&, Vector<RefPtr<Range>>& markedRanges);
 
-    Timer<Editor> m_telephoneNumberDetectionUpdateTimer;
+    Timer m_telephoneNumberDetectionUpdateTimer;
     Vector<RefPtr<Range>> m_detectedTelephoneNumberRanges;
 #endif
 };
index 13223dd751cf7f58319d62267ccb72c5d1a65589..df4b843146ae4af0e165b84871bac6bd85045176 100644 (file)
@@ -1901,7 +1901,7 @@ void FrameSelection::setCaretVisibility(CaretVisibility visibility)
     updateAppearance();
 }
 
-void FrameSelection::caretBlinkTimerFired(Timer<FrameSelection>&)
+void FrameSelection::caretBlinkTimerFired(Timer&)
 {
 #if ENABLE(TEXT_CARET)
     ASSERT(caretIsVisible());
index 3606012c53a81447c26d8c8b7c86232a97ac8d21..a9dc92c3e17232150ba1149ecea44338af758e17 100644 (file)
@@ -309,7 +309,7 @@ private:
     void setFocusedElementIfNeeded();
     void focusedOrActiveStateChanged();
 
-    void caretBlinkTimerFired(Timer<FrameSelection>&);
+    void caretBlinkTimerFired(Timer&);
 
     void setCaretVisibility(CaretVisibility);
     bool recomputeCaretRect();
@@ -329,7 +329,7 @@ private:
 
     RefPtr<EditingStyle> m_typingStyle;
 
-    Timer<FrameSelection> m_caretBlinkTimer;
+    Timer m_caretBlinkTimer;
     // The painted bounds of the caret in absolute coordinates
     IntRect m_absCaretBounds;
     bool m_absCaretBoundsDirty : 1;
index 07a23af04a390f9b00fb5cc54519f305f152e10f..ae83212139767066e01b29cf059d894f66e26ec7 100644 (file)
@@ -127,7 +127,7 @@ TextCheckerClient* SpellChecker::client() const
     return page->editorClient()->textChecker();
 }
 
-void SpellChecker::timerFiredToProcessQueuedRequest(Timer<SpellChecker>*)
+void SpellChecker::timerFiredToProcessQueuedRequest(Timer*)
 {
     ASSERT(!m_requestQueue.isEmpty());
     if (m_requestQueue.isEmpty())
index 9ca35083f3e73a701acc6e769a3be6c17a5c089a..008e328f6448020e2b69de6abd4820778ceebf19 100644 (file)
@@ -98,7 +98,7 @@ private:
 
     bool canCheckAsynchronously(Range*) const;
     TextCheckerClient* client() const;
-    void timerFiredToProcessQueuedRequest(Timer<SpellChecker>*);
+    void timerFiredToProcessQueuedRequest(Timer*);
     void invokeRequest(PassRefPtr<SpellCheckRequest>);
     void enqueueRequest(PassRefPtr<SpellCheckRequest>);
     void didCheckSucceed(int sequence, const Vector<TextCheckingResult>&);
@@ -109,7 +109,7 @@ private:
     int m_lastRequestSequence;
     int m_lastProcessedSequence;
 
-    Timer<SpellChecker> m_timerToProcessQueuedRequest;
+    Timer m_timerToProcessQueuedRequest;
 
     RefPtr<SpellCheckRequest> m_processingRequest;
     RequestQueue m_requestQueue;
index ac90b36287246bf6e6a232f41deb10af195cb335..92600767fa20e11241a138c4f7286d9877c75e0b 100644 (file)
@@ -472,7 +472,7 @@ void HTMLFormElement::finishRequestAutocomplete(AutocompleteResult result)
         m_requestAutocompleteTimer.startOneShot(0);
 }
 
-void HTMLFormElement::requestAutocompleteTimerFired(Timer<HTMLFormElement>*)
+void HTMLFormElement::requestAutocompleteTimerFired(Timer*)
 {
     Vector<RefPtr<Event>> pendingEvents;
     m_pendingAutocompleteEvents.swap(pendingEvents);
index fc3db9d948d2ad4b0471f6dba35bf446c470197f..b4d686648ffc4cd7b37fddaecbbfcf2e7479ea0e 100644 (file)
@@ -194,10 +194,10 @@ private:
     bool m_wasDemoted;
 
 #if ENABLE(REQUEST_AUTOCOMPLETE)
-    void requestAutocompleteTimerFired(Timer<HTMLFormElement>*);
+    void requestAutocompleteTimerFired(Timer*);
 
     Vector<RefPtr<Event>> m_pendingAutocompleteEvents;
-    Timer<HTMLFormElement> m_requestAutocompleteTimer;
+    Timer m_requestAutocompleteTimer;
 #endif
 };
 
index 3b10e43e0617bbb8313e0e138236a45f4fa9b6b8..7f32c818761b81e4906df41ead0e96a2888802bc 100644 (file)
@@ -757,7 +757,7 @@ void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)
     m_asyncEventQueue.enqueueEvent(event.release());
 }
 
-void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>&)
+void HTMLMediaElement::loadTimerFired(Timer&)
 {
     Ref<HTMLMediaElement> protect(*this); // loadNextSourceChild may fire 'beforeload', which can make arbitrary DOM mutations.
 
@@ -2225,7 +2225,7 @@ void HTMLMediaElement::setMediaKeys(MediaKeys* mediaKeys)
 }
 #endif
 
-void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>&)
+void HTMLMediaElement::progressEventTimerFired(Timer&)
 {
     ASSERT(m_player);
     if (m_networkState != NETWORK_LOADING)
@@ -2368,7 +2368,7 @@ void HTMLMediaElement::seekWithTolerance(const MediaTime& inTime, const MediaTim
         seekTimerFired(m_seekTimer);
 }
 
-void HTMLMediaElement::seekTimerFired(Timer<HTMLMediaElement>&)
+void HTMLMediaElement::seekTimerFired(Timer&)
 {
     if (!m_player) {
         m_seeking = false;
@@ -3112,7 +3112,7 @@ double HTMLMediaElement::nextScanRate()
     return rate;
 }
 
-void HTMLMediaElement::scanTimerFired(Timer<HTMLMediaElement>&)
+void HTMLMediaElement::scanTimerFired(Timer&)
 {
     if (m_scanType == Seek) {
         double seekTime = m_scanDirection == Forward ? SeekTime : -SeekTime;
@@ -3134,7 +3134,7 @@ void HTMLMediaElement::startPlaybackProgressTimer()
     m_playbackProgressTimer.startRepeating(maxTimeupdateEventFrequency);
 }
 
-void HTMLMediaElement::playbackProgressTimerFired(Timer<HTMLMediaElement>&)
+void HTMLMediaElement::playbackProgressTimerFired(Timer&)
 {
     ASSERT(m_player);
 
index 086c3590425f2fab3283cf956e818f981836a21e..116fdf2f0c430c5153de3d32ca1e4c59e991d9fb 100644 (file)
@@ -591,11 +591,11 @@ private:
 
     virtual bool mediaPlayerIsInMediaDocument() const override final;
 
-    void loadTimerFired(Timer<HTMLMediaElement>&);
-    void progressEventTimerFired(Timer<HTMLMediaElement>&);
-    void playbackProgressTimerFired(Timer<HTMLMediaElement>&);
-    void scanTimerFired(Timer<HTMLMediaElement>&);
-    void seekTimerFired(Timer<HTMLMediaElement>&);
+    void loadTimerFired(Timer&);
+    void progressEventTimerFired(Timer&);
+    void playbackProgressTimerFired(Timer&);
+    void scanTimerFired(Timer&);
+    void seekTimerFired(Timer&);
     void startPlaybackProgressTimer();
     void startProgressEventTimer();
     void stopPeriodicTimers();
@@ -722,11 +722,11 @@ private:
 
     void updateCaptionContainer();
 
-    Timer<HTMLMediaElement> m_loadTimer;
-    Timer<HTMLMediaElement> m_progressEventTimer;
-    Timer<HTMLMediaElement> m_playbackProgressTimer;
-    Timer<HTMLMediaElement> m_scanTimer;
-    Timer<HTMLMediaElement> m_seekTimer;
+    Timer m_loadTimer;
+    Timer m_progressEventTimer;
+    Timer m_playbackProgressTimer;
+    Timer m_scanTimer;
+    Timer m_seekTimer;
     RefPtr<TimeRanges> m_playedTimeRanges;
     GenericEventQueue m_asyncEventQueue;
 
index 2d17e7b98228494bd9cb9953f0dcbedbb9ea538b..5240e9f3267af419603fe942af19a11651ace275 100644 (file)
@@ -300,7 +300,7 @@ RenderPtr<RenderElement> HTMLPlugInElement::createElementRenderer(PassRef<Render
     return createRenderer<RenderEmbeddedObject>(*this, WTF::move(style));
 }
 
-void HTMLPlugInElement::swapRendererTimerFired(Timer<HTMLPlugInElement>&)
+void HTMLPlugInElement::swapRendererTimerFired(Timer&)
 {
     ASSERT(displayState() == PreparingPluginReplacement || displayState() == DisplayingSnapshot);
     if (userAgentShadowRoot())
index f8bc7f9c63066a34cbd5b4968c916fb6245f6657..d7e367574f41442a5131e288819a030e1ebed291 100644 (file)
@@ -112,7 +112,7 @@ protected:
     bool m_inBeforeLoadEventHandler;
 
 private:
-    void swapRendererTimerFired(Timer<HTMLPlugInElement>&);
+    void swapRendererTimerFired(Timer&);
     bool shouldOverridePlugin(const String& url, const String& mimeType);
 
     bool dispatchBeforeLoadEvent(const String& sourceURL); // Not implemented, generates a compile error if subclasses call this by mistake.
@@ -126,7 +126,7 @@ private:
     virtual bool isPluginElement() const override final;
 
     RefPtr<JSC::Bindings::Instance> m_instance;
-    Timer<HTMLPlugInElement> m_swapRendererTimer;
+    Timer m_swapRendererTimer;
     RefPtr<PluginReplacement> m_pluginReplacement;
 #if ENABLE(NETSCAPE_PLUGIN_API)
     NPObject* m_NPObject;
index b60085df9e522def231e9cccb0956eae6a472747..67208855948035981abbe8608d8b91a5ff234c2d 100644 (file)
@@ -399,7 +399,7 @@ bool HTMLPlugInImageElement::partOfSnapshotOverlay(Node* node)
     return node && snapshotLabel && (node == snapshotLabel.get() || node->isDescendantOf(snapshotLabel.get()));
 }
 
-void HTMLPlugInImageElement::removeSnapshotTimerFired(Timer<HTMLPlugInImageElement>&)
+void HTMLPlugInImageElement::removeSnapshotTimerFired(Timer&)
 {
     m_snapshotImage = nullptr;
     m_isRestartedPlugin = false;
index 3eef4c60bd3855fd45859fe9435d319486abee61..f17ef6e88ed0054b5ae2e75eac15402438aee8bb 100644 (file)
@@ -136,7 +136,7 @@ private:
     void simulatedMouseClickTimerFired();
 
     void restartSimilarPlugIns();
-    void removeSnapshotTimerFired(Timer<HTMLPlugInImageElement>&);
+    void removeSnapshotTimerFired(Timer&);
     bool isTopLevelFullPagePlugin(const RenderEmbeddedObject&) const;
 
     URL m_loadedUrl;
@@ -145,7 +145,7 @@ private:
     bool m_needsDocumentActivationCallbacks;
     RefPtr<MouseEvent> m_pendingClickEventFromSnapshot;
     DeferrableOneShotTimer m_simulatedMouseClickTimer;
-    Timer<HTMLPlugInImageElement> m_removeSnapshotTimer;
+    Timer m_removeSnapshotTimer;
     RefPtr<Image> m_snapshotImage;
     bool m_createdDuringUserGesture;
     bool m_isRestartedPlugin;
index a488ae8853d6b3048a8600181701cf75c545be42..fd196399270fd6b1affa844978ca82ce16e62c73 100644 (file)
@@ -110,7 +110,7 @@ void HTMLSourceElement::cancelPendingErrorEvent()
     m_errorEventTimer.stop();
 }
 
-void HTMLSourceElement::errorEventTimerFired(Timer<HTMLSourceElement>&)
+void HTMLSourceElement::errorEventTimerFired(Timer&)
 {
     LOG(Media, "HTMLSourceElement::errorEventTimerFired - %p", this);
     dispatchEvent(Event::create(eventNames().errorEvent, false, true));
index 522d743682dda96fc977d61199cc71f5439c9f4a..11c55a0f894d80fd12100dca008b9926bfcd8d3b 100644 (file)
@@ -52,9 +52,9 @@ private:
     virtual void removedFrom(ContainerNode&) override;
     virtual bool isURLAttribute(const Attribute&) const override;
 
-    void errorEventTimerFired(Timer<HTMLSourceElement>&);
+    void errorEventTimerFired(Timer&);
 
-    Timer<HTMLSourceElement> m_errorEventTimer;
+    Timer m_errorEventTimer;
 };
 
 } //namespace
index 2c6e97ba76cf62d105cfe98d94789617cd6f30f0..7491388aabbf95426eaa1b33bf141e74548246ab 100644 (file)
@@ -200,7 +200,7 @@ void HTMLTrackElement::scheduleLoad()
     m_loadTimer.startOneShot(0);
 }
 
-void HTMLTrackElement::loadTimerFired(Timer<HTMLTrackElement>&)
+void HTMLTrackElement::loadTimerFired(Timer&)
 {
     if (!fastHasAttribute(srcAttr))
         return;
index 526dc03cc185bf7e287b50fd0daa8192c1817c45..121b9c3605fffcebf4c0571ff3a786ecb4bcc909 100644 (file)
@@ -75,7 +75,7 @@ private:
 
     virtual bool isURLAttribute(const Attribute&) const override;
 
-    void loadTimerFired(Timer<HTMLTrackElement>&);
+    void loadTimerFired(Timer&);
 
     HTMLMediaElement* mediaElement() const;
 
@@ -91,7 +91,7 @@ private:
     bool canLoadURL(const URL&);
 
     RefPtr<LoadableTextTrack> m_track;
-    Timer<HTMLTrackElement> m_loadTimer;
+    Timer m_loadTimer;
 };
 
 }
index 3a77682432d84328e72e4c53072bfacb2c863499..413167448fdffb015919eca275cd0e6ef70e8a76 100644 (file)
@@ -538,7 +538,7 @@ void MediaController::scheduleEvent(const AtomicString& eventName)
         m_asyncEventTimer.startOneShot(0);
 }
 
-void MediaController::asyncEventTimerFired(Timer<MediaController>&)
+void MediaController::asyncEventTimerFired(Timer&)
 {
     Vector<RefPtr<Event>> pendingEvents;
 
@@ -548,7 +548,7 @@ void MediaController::asyncEventTimerFired(Timer<MediaController>&)
         dispatchEvent(pendingEvents[index].release(), IGNORE_EXCEPTION);
 }
 
-void MediaController::clearPositionTimerFired(Timer<MediaController>&)
+void MediaController::clearPositionTimerFired(Timer&)
 {
     m_position = MediaPlayer::invalidTime();
 }
@@ -672,7 +672,7 @@ void MediaController::startTimeupdateTimer()
     m_timeupdateTimer.startRepeating(maxTimeupdateEventFrequency);
 }
 
-void MediaController::timeupdateTimerFired(Timer<MediaController>&)
+void MediaController::timeupdateTimerFired(Timer&)
 {
     scheduleTimeupdateEvent();
 }
index 3e36c9b14649a21b62b8652154d8eeb6848680b8..25419cbb83844ba444215374a553f6fecce758e1 100644 (file)
@@ -123,11 +123,11 @@ private:
     void updateMediaElements();
     void bringElementUpToSpeed(HTMLMediaElement*);
     void scheduleEvent(const AtomicString& eventName);
-    void asyncEventTimerFired(Timer<MediaController>&);
-    void clearPositionTimerFired(Timer<MediaController>&);
+    void asyncEventTimerFired(Timer&);
+    void clearPositionTimerFired(Timer&);
     bool hasEnded() const;
     void scheduleTimeupdateEvent();
-    void timeupdateTimerFired(Timer<MediaController>&);
+    void timeupdateTimerFired(Timer&);
     void startTimeupdateTimer();
 
     // EventTarget
@@ -147,13 +147,13 @@ private:
     ReadyState m_readyState;
     PlaybackState m_playbackState;
     Vector<RefPtr<Event>> m_pendingEvents;
-    Timer<MediaController> m_asyncEventTimer;
-    mutable Timer<MediaController> m_clearPositionTimer;
+    Timer m_asyncEventTimer;
+    mutable Timer m_clearPositionTimer;
     String m_mediaGroup;
     bool m_closedCaptionsVisible;
     std::unique_ptr<Clock> m_clock;
     ScriptExecutionContext& m_scriptExecutionContext;
-    Timer<MediaController> m_timeupdateTimer;
+    Timer m_timeupdateTimer;
     double m_previousTimeupdateTime;
 };
 
index fac958ef533788c3f4eb06b9f9d8bab5603d722b..d6569a43baecd3036871211b5f9eaa43953e5db3 100644 (file)
@@ -231,7 +231,7 @@ void MediaDocument::mediaElementSawUnsupportedTracks()
     m_replaceMediaElementTimer.startOneShot(0);
 }
 
-void MediaDocument::replaceMediaElementTimerFired(Timer<MediaDocument>&)
+void MediaDocument::replaceMediaElementTimerFired(Timer&)
 {
     HTMLElement* htmlBody = body();
     if (!htmlBody)
index 03ed81b508ee106b939dbe934c5b6781506b80ec..43b5f46c62dd0f1c9f387336c48e376c2bc24199 100644 (file)
@@ -50,9 +50,9 @@ private:
 
     virtual void defaultEventHandler(Event*) override;
 
-    void replaceMediaElementTimerFired(Timer<MediaDocument>&);
+    void replaceMediaElementTimerFired(Timer&);
 
-    Timer<MediaDocument> m_replaceMediaElementTimer;
+    Timer m_replaceMediaElementTimer;
     String m_outgoingReferrer;
 };
 
index b2c45928c29e65fd2f707f09e49115381e82cdc7..0bf9dfc34ab5afd263098032b9c0fdc163137d13 100644 (file)
@@ -173,7 +173,7 @@ void SearchInputType::stopSearchEventTimer()
     m_searchEventTimer.stop();
 }
 
-void SearchInputType::searchEventTimerFired(Timer<SearchInputType>*)
+void SearchInputType::searchEventTimerFired(Timer*)
 {
     element().onSearch();
 }
index 12326bc888406bad6cb975b9c3e80b5c18dc00eb..883a12b1760bd6ae96ca6896bab2e19b059d9238 100644 (file)
@@ -61,13 +61,13 @@ private:
     virtual bool sizeShouldIncludeDecoration(int defaultSize, int& preferredSize) const override;
     virtual float decorationWidth() const override;
 
-    void searchEventTimerFired(Timer<SearchInputType>*);
+    void searchEventTimerFired(Timer*);
     bool searchEventsShouldBeDispatched() const;
     void startSearchEventTimer();
 
     SearchFieldResultsButtonElement* m_resultsButton;
     HTMLElement* m_cancelButton;
-    Timer<SearchInputType> m_searchEventTimer;
+    Timer m_searchEventTimer;
 };
 
 } // namespace WebCore
index 9b8fb397065c9ab61de49b766607c0944c09acdd..ab9618d9d898202baa8b7a131dc7ce5efc177076 100644 (file)
@@ -107,13 +107,13 @@ void ValidationMessage::setMessage(const String& message)
     ASSERT(!message.isEmpty());
     m_message = message;
     if (!m_bubble)
-        m_timer = std::make_unique<Timer<ValidationMessage>>(this, &ValidationMessage::buildBubbleTree);
+        m_timer = std::make_unique<Timer>(this, &ValidationMessage::buildBubbleTree);
     else
-        m_timer = std::make_unique<Timer<ValidationMessage>>(this, &ValidationMessage::setMessageDOMAndStartTimer);
+        m_timer = std::make_unique<Timer>(this, &ValidationMessage::setMessageDOMAndStartTimer);
     m_timer->startOneShot(0);
 }
 
-void ValidationMessage::setMessageDOMAndStartTimer(Timer<ValidationMessage>*)
+void ValidationMessage::setMessageDOMAndStartTimer(Timer*)
 {
     ASSERT(!validationMessageClient());
     ASSERT(m_messageHeading);
@@ -136,7 +136,7 @@ void ValidationMessage::setMessageDOMAndStartTimer(Timer<ValidationMessage>*)
     if (magnification <= 0)
         m_timer = nullptr;
     else {
-        m_timer = std::make_unique<Timer<ValidationMessage>>(this, &ValidationMessage::deleteBubbleTree);
+        m_timer = std::make_unique<Timer>(this, &ValidationMessage::deleteBubbleTree);
         m_timer->startOneShot(std::max(5.0, static_cast<double>(m_message.length()) * magnification / 1000));
     }
 }
@@ -165,7 +165,7 @@ static void adjustBubblePosition(const LayoutRect& hostRect, HTMLElement* bubble
     bubble->setInlineStyleProperty(CSSPropertyLeft, bubbleX, CSSPrimitiveValue::CSS_PX);
 }
 
-void ValidationMessage::buildBubbleTree(Timer<ValidationMessage>*)
+void ValidationMessage::buildBubbleTree(Timer*)
 {
     ASSERT(!validationMessageClient());
     ShadowRoot& shadowRoot = m_element->ensureUserAgentShadowRoot();
@@ -216,7 +216,7 @@ void ValidationMessage::requestToHideMessage()
     }
 
     // We must not modify the DOM tree in this context by the same reason as setMessage().
-    m_timer = std::make_unique<Timer<ValidationMessage>>(this, &ValidationMessage::deleteBubbleTree);
+    m_timer = std::make_unique<Timer>(this, &ValidationMessage::deleteBubbleTree);
     m_timer->startOneShot(0);
 }
 
@@ -227,7 +227,7 @@ bool ValidationMessage::shadowTreeContains(const Node& node) const
     return &m_bubble->treeScope() == &node.treeScope();
 }
 
-void ValidationMessage::deleteBubbleTree(Timer<ValidationMessage>*)
+void ValidationMessage::deleteBubbleTree(Timer*)
 {
     ASSERT(!validationMessageClient());
     if (m_bubble) {
index 751684316503a4eb13fc45648d87b19cf9c7709e..9d61857c7f469ceb3fea2ddc0d8585844879af92 100644 (file)
@@ -60,13 +60,13 @@ public:
 private:
     ValidationMessageClient* validationMessageClient() const;
     void setMessage(const String&);
-    void setMessageDOMAndStartTimer(Timer<ValidationMessage>* = 0);
-    void buildBubbleTree(Timer<ValidationMessage>*);
-    void deleteBubbleTree(Timer<ValidationMessage>* = 0);
+    void setMessageDOMAndStartTimer(Timer* = 0);
+    void buildBubbleTree(Timer*);
+    void deleteBubbleTree(Timer* = 0);
 
     HTMLFormControlElement* m_element;
     String m_message;
-    std::unique_ptr<Timer<ValidationMessage>> m_timer;
+    std::unique_ptr<Timer> m_timer;
     RefPtr<HTMLElement> m_bubble;
     RefPtr<HTMLElement> m_messageHeading;
     RefPtr<HTMLElement> m_messageBody;
index b682a7e04263003dc523281190adcccf042f1344..0be1d40271f5e1f41806c06412d74b78481367d9 100644 (file)
@@ -5923,7 +5923,7 @@ void WebGLRenderingContext::restoreStatesAfterVertexAttrib0Simulation()
     m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(m_boundArrayBuffer.get()));
 }
 
-void WebGLRenderingContext::dispatchContextLostEvent(Timer<WebGLRenderingContext>*)
+void WebGLRenderingContext::dispatchContextLostEvent(Timer*)
 {
     RefPtr<WebGLContextEvent> event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, "");
     canvas()->dispatchEvent(event);
@@ -5932,7 +5932,7 @@ void WebGLRenderingContext::dispatchContextLostEvent(Timer<WebGLRenderingContext
         m_restoreTimer.startOneShot(0);
 }
 
-void WebGLRenderingContext::maybeRestoreContext(Timer<WebGLRenderingContext>*)
+void WebGLRenderingContext::maybeRestoreContext(Timer*)
 {
     ASSERT(m_contextLost);
     if (!m_contextLost)
index 50ae42cfacd6815022f01b46ab8d979b4412ac75..348befb44e3114da6e5b40e0953265f311a3ef70 100644 (file)
@@ -411,9 +411,9 @@ private:
     // likely that there's no JavaScript on the stack, but that might be dependent
     // on how exactly the platform discovers that the context was lost. For better
     // portability we always defer the dispatch of the event.
-    Timer<WebGLRenderingContext> m_dispatchContextLostEventTimer;
+    Timer m_dispatchContextLostEventTimer;
     bool m_restoreAllowed;
-    Timer<WebGLRenderingContext> m_restoreTimer;
+    Timer m_restoreTimer;
 
     bool m_needsUpdate;
     bool m_markedCanvasDirty;
@@ -761,9 +761,9 @@ private:
     bool simulateVertexAttrib0(GC3Dsizei numVertex);
     void restoreStatesAfterVertexAttrib0Simulation();
 
-    void dispatchContextLostEvent(Timer<WebGLRenderingContext>*);
+    void dispatchContextLostEvent(Timer*);
     // Helper for restoration after context lost.
-    void maybeRestoreContext(Timer<WebGLRenderingContext>*);
+    void maybeRestoreContext(Timer*);
 
     // Determine if we are running privileged code in the browser, for example,
     // a Safari or Chrome extension.
index b931da2d80f69cfee95818113ca561d9f123da13..82781100905ca041454a29b8aa82d08c5a40d05d 100644 (file)
@@ -101,7 +101,7 @@ HTMLParserScheduler::~HTMLParserScheduler()
     m_continueNextChunkTimer.stop();
 }
 
-void HTMLParserScheduler::continueNextChunkTimerFired(Timer<HTMLParserScheduler>& timer)
+void HTMLParserScheduler::continueNextChunkTimerFired(Timer& timer)
 {
     ASSERT(!m_suspended);
     ASSERT_UNUSED(timer, &timer == &m_continueNextChunkTimer);
index b404ae9c24d374cf60316117784e017e299753b2..ab7e2ed81d1d90d720e77a534f1d8b3b20b67f6d 100644 (file)
@@ -97,13 +97,13 @@ public:
     void resume();
 
 private:
-    void continueNextChunkTimerFired(Timer<HTMLParserScheduler>&);
+    void continueNextChunkTimerFired(Timer&);
 
     HTMLDocumentParser& m_parser;
 
     double m_parserTimeLimit;
     int m_parserChunkSize;
-    Timer<HTMLParserScheduler> m_continueNextChunkTimer;
+    Timer m_continueNextChunkTimer;
     bool m_isSuspendedWithActiveTimer;
 #if !ASSERT_DISABLED
     bool m_suspended;
index 4c7bd75a33df7f95fbc9718bde5672488e00d348..fc35832359bd9b8c61f84e7d12c4e007936f0d4c 100644 (file)
@@ -149,7 +149,7 @@ void MediaControlPanelElement::stopTimer()
         m_transitionTimer.stop();
 }
 
-void MediaControlPanelElement::transitionTimerFired(Timer<MediaControlPanelElement>&)
+void MediaControlPanelElement::transitionTimerFired(Timer&)
 {
     if (!m_opaque)
         hide();
@@ -1243,7 +1243,7 @@ void MediaControlTextTrackContainerElement::updateActiveCuesFontSize()
 
 }
 
-void MediaControlTextTrackContainerElement::updateTimerFired(Timer<MediaControlTextTrackContainerElement>&)
+void MediaControlTextTrackContainerElement::updateTimerFired(Timer&)
 {
     if (!document().page())
         return;
index 1474aa47d1be4f802fdb3e0be5658b396b8a50e6..ccb499683bfc7549a5650ccae15f243c9b66a3bd 100644 (file)
@@ -65,7 +65,7 @@ private:
 
     void startTimer();
     void stopTimer();
-    void transitionTimerFired(Timer<MediaControlPanelElement>&);
+    void transitionTimerFired(Timer&);
 
     void setPosition(const LayoutPoint&);
 
@@ -76,7 +76,7 @@ private:
     LayoutPoint m_lastDragEventLocation;
     LayoutPoint m_cumulativeDragOffset;
 
-    Timer<MediaControlPanelElement> m_transitionTimer;
+    Timer m_transitionTimer;
 };
 
 // ----------------------------
@@ -451,7 +451,7 @@ public:
     void exitedFullscreen();
 
 private:
-    void updateTimerFired(Timer<MediaControlTextTrackContainerElement>&);
+    void updateTimerFired(Timer&);
     void updateActiveCuesFontSize();
 
     explicit MediaControlTextTrackContainerElement(Document&);
@@ -465,7 +465,7 @@ private:
     void updateStyleForTextTrackRepresentation();
     OwnPtr<TextTrackRepresentation> m_textTrackRepresentation;
 
-    Timer<MediaControlTextTrackContainerElement> m_updateTimer;
+    Timer m_updateTimer;
     IntRect m_videoDisplaySize;
     int m_fontSize;
     bool m_fontSizeIsImportant;
index 7129fe66173aff7e411f745e43959a222779dfdc..787220fee0bcff71087a2b3ac0d5543c182815c5 100644 (file)
@@ -330,7 +330,7 @@ void MediaControls::defaultEventHandler(Event* event)
     }
 }
 
-void MediaControls::hideFullscreenControlsTimerFired(Timer<MediaControls>&)
+void MediaControls::hideFullscreenControlsTimerFired(Timer&)
 {
     if (m_mediaController->paused())
         return;
index 6e17e35b4365fb0da4adfb92f3b72ef8a57f0c3e..a644c8ea927a37139062436e13f394c4590b169b 100644 (file)
@@ -97,7 +97,7 @@ class MediaControls : public HTMLDivElement {
     virtual bool willRespondToMouseMoveEvents() override { return true; }
 #endif
 
-    virtual void hideFullscreenControlsTimerFired(Timer<MediaControls>&);
+    virtual void hideFullscreenControlsTimerFired(Timer&);
     virtual void startHideFullscreenControlsTimer();
     virtual void stopHideFullscreenControlsTimer();
 
@@ -137,7 +137,7 @@ protected:
     MediaControlToggleClosedCaptionsButtonElement* m_toggleClosedCaptionsButton;
     MediaControlFullscreenButtonElement* m_fullScreenButton;
 
-    Timer<MediaControls> m_hideFullscreenControlsTimer;
+    Timer m_hideFullscreenControlsTimer;
     bool m_isFullscreen;
     bool m_isMouseOverControls;
 
index bbdd01b9a0965c965056c9cc893c3fadcf3b5d08..9836965f71d45e8142f5106c0652b7c2525934c3 100644 (file)
@@ -230,7 +230,7 @@ void SpinButtonElement::step(int amount)
     doStepAction(amount);
 }
     
-void SpinButtonElement::repeatingTimerFired(Timer<SpinButtonElement>*)
+void SpinButtonElement::repeatingTimerFired(Timer*)
 {
     if (m_upDownState != Indeterminate)
         step(m_upDownState == Up ? 1 : -1);
index 1139601e2e0297a16cea6ccaa3cd13f211f05bde..18cfa2d5ecb40b66e1dcb2bca3a6bac1f1828343 100644 (file)
@@ -78,7 +78,7 @@ private:
     void doStepAction(int);
     void startRepeatingTimer();
     void stopRepeatingTimer();
-    void repeatingTimerFired(Timer<SpinButtonElement>*);
+    void repeatingTimerFired(Timer*);
     virtual void setHovered(bool = true) override;
     bool shouldRespondToMouseEvents();
     virtual bool isMouseFocusable() const override { return false; }
@@ -87,7 +87,7 @@ private:
     bool m_capturing;
     UpDownState m_upDownState;
     UpDownState m_pressStartingState;
-    Timer<SpinButtonElement> m_repeatingTimer;
+    Timer m_repeatingTimer;
 };
 
 } // namespace WebCore
index bf9523d728334d9e9a602ddbbce3819c78575e63..bdc4dfa0d1ef75fe6a0509c328fc5488b3c189ff 100644 (file)
@@ -85,7 +85,7 @@ void LoadableTextTrack::setTrackElement(HTMLTrackElement* element)
     m_trackElement = element;
 }
 
-void LoadableTextTrack::loadTimerFired(Timer<LoadableTextTrack>&)
+void LoadableTextTrack::loadTimerFired(Timer&)
 {
     if (m_loader)
         m_loader->cancelLoad();
index 06e3feaf96a098b8a0de15092dd8aed11efb6230..aad2a0826fea6b0434bf9f65ea846361112d0bec 100644 (file)
@@ -70,10 +70,10 @@ private:
 
     LoadableTextTrack(HTMLTrackElement*, const String& kind, const String& label, const String& language);
 
-    void loadTimerFired(Timer<LoadableTextTrack>&);
+    void loadTimerFired(Timer&);
 
     HTMLTrackElement* m_trackElement;
-    Timer<LoadableTextTrack> m_loadTimer;
+    Timer m_loadTimer;
     std::unique_ptr<TextTrackLoader> m_loader;
     URL m_url;
     bool m_isDefault;
index 6fb5aadb07483203b92d8310dcc7867de1301251..38a1c6ae1ad23f0aa14d7773d99cf25d6d264089 100644 (file)
@@ -478,7 +478,7 @@ void VTTRegion::stopTimer()
         m_scrollTimer.stop();
 }
 
-void VTTRegion::scrollTimerFired(Timer<VTTRegion>*)
+void VTTRegion::scrollTimerFired(Timer*)
 {
     LOG(Media, "VTTRegion::scrollTimerFired");
 
index e162f52b572649884d962cba51dd77231429ee56..04133851d6c89bcd2671585d43a4ccd59adeae40 100644 (file)
@@ -105,7 +105,7 @@ private:
     // The timer is needed to continue processing when cue scrolling ended.
     void startTimer();
     void stopTimer();
-    void scrollTimerFired(Timer<VTTRegion>*);
+    void scrollTimerFired(Timer*);
 
     enum RegionSetting {
         None,
@@ -155,7 +155,7 @@ private:
     // soon as the animation for rolling out one line has finished, but
     // currently it is used also for non-scrolling regions to use a single
     // code path.
-    Timer<VTTRegion> m_scrollTimer;
+    Timer m_scrollTimer;
 };
 
 } // namespace WebCore
index 71c8c58039628d2bbe4e952672ab7d1c4841e828..f57ea339d413ee4da242174dcdc1204803774e19 100644 (file)
@@ -109,11 +109,11 @@ public:
     void scheduleFor(WebKitNamedFlow*, int documentNodeId);
     void unschedule(WebKitNamedFlow*);
     void reset();
-    void timerFired(Timer<ChangeRegionOversetTask>&);
+    void timerFired(Timer&);
 
 private:
     InspectorCSSAgent* m_cssAgent;
-    Timer<ChangeRegionOversetTask> m_timer;
+    Timer m_timer;
     HashMap<WebKitNamedFlow*, int> m_namedFlows;
 };
 
@@ -142,7 +142,7 @@ void ChangeRegionOversetTask::reset()
     m_namedFlows.clear();
 }
 
-void ChangeRegionOversetTask::timerFired(Timer<ChangeRegionOversetTask>&)
+void ChangeRegionOversetTask::timerFired(Timer&)
 {
     // The timer is stopped on m_cssAgent destruction, so this method will never be called after m_cssAgent has been destroyed.
     for (HashMap<WebKitNamedFlow*, int>::iterator it = m_namedFlows.begin(), end = m_namedFlows.end(); it != end; ++it)
index 496ebb4aa5ab892073671bc27e2fb4af485c9c92..3375473c9b4389c750939692008ad45ea2a0dc0c 100644 (file)
@@ -162,11 +162,11 @@ public:
     RevalidateStyleAttributeTask(InspectorDOMAgent*);
     void scheduleFor(Element*);
     void reset() { m_timer.stop(); }
-    void timerFired(Timer<RevalidateStyleAttributeTask>&);
+    void timerFired(Timer&);
 
 private:
     InspectorDOMAgent* m_domAgent;
-    Timer<RevalidateStyleAttributeTask> m_timer;
+    Timer m_timer;
     HashSet<RefPtr<Element>> m_elements;
 };
 
@@ -183,7 +183,7 @@ void RevalidateStyleAttributeTask::scheduleFor(Element* element)
         m_timer.startOneShot(0);
 }
 
-void RevalidateStyleAttributeTask::timerFired(Timer<RevalidateStyleAttributeTask>&)
+void RevalidateStyleAttributeTask::timerFired(Timer&)
 {
     // The timer is stopped on m_domAgent destruction, so this method will never be called after m_domAgent has been destroyed.
     Vector<Element*> elements;
index 9aca7b83b1e5a950e08881f45a78106d3e7083ab..6b97823cbdcce6499715ee234aa5fcfab2df73f9 100644 (file)
@@ -91,7 +91,7 @@ public:
         m_timer.stop();
     }
 
-    void timerFired(Timer<InspectorBackendDispatchTask>&)
+    void timerFired(Timer&)
     {
         if (!m_messages.isEmpty()) {
             // Dispatch can lead to the timer destruction -> schedule the next shot first.
@@ -102,7 +102,7 @@ public:
 
 private:
     InspectorController* m_inspectorController;
-    Timer<InspectorBackendDispatchTask> m_timer;
+    Timer m_timer;
     Deque<String> m_messages;
 };
 
index e14d1fa701fa11b510c44cede2a04d50aedf526e..1ed1e974749ba2d9a3b0424e140ea51f67e2d82b 100644 (file)
@@ -505,7 +505,7 @@ void InspectorOverlay::showPaintRect(const FloatRect& rect)
     forcePaint();
 }
 
-void InspectorOverlay::updatePaintRectsTimerFired(Timer<InspectorOverlay>&)
+void InspectorOverlay::updatePaintRectsTimerFired(Timer&)
 {
     std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
     bool rectsChanged = false;
index 4b813f3698b62f6b960def8b2ab30d737d5da79a..8908292c8f660b7c912cd8853814fa986462725b 100644 (file)
@@ -139,7 +139,7 @@ private:
     void drawQuadHighlight();
     void drawPausedInDebuggerMessage();
     void drawPaintRects();
-    void updatePaintRectsTimerFired(Timer<InspectorOverlay>&);
+    void updatePaintRectsTimerFired(Timer&);
 
     Page* overlayPage();
 
@@ -160,7 +160,7 @@ private:
     
     typedef std::pair<std::chrono::steady_clock::time_point, FloatRect> TimeRectPair;
     Deque<TimeRectPair> m_paintRects;
-    Timer<InspectorOverlay> m_paintRectUpdateTimer;
+    Timer m_paintRectUpdateTimer;
     bool m_indicating;
     bool m_showingPaintRects;
 };
index 977ed14b0e216368b110b25c3264d125013b6c76..1f175c7202e3185d1fcc090dd70892a3c23570d5 100644 (file)
@@ -1125,7 +1125,7 @@ void DocumentLoader::deliverSubstituteResourcesAfterDelay()
         m_substituteResourceDeliveryTimer.startOneShot(0);
 }
 
-void DocumentLoader::substituteResourceDeliveryTimerFired(Timer<DocumentLoader>&)
+void DocumentLoader::substituteResourceDeliveryTimerFired(Timer&)
 {
     if (m_pendingSubstituteResources.isEmpty())
         return;
index 6d0810e71cddaa75572bd0d5e01ead53340cbc6b..50f04a1ce822ba63f03116736c30508910b0a1fa 100644 (file)
@@ -313,14 +313,14 @@ namespace WebCore {
 #if HAVE(RUNLOOP_TIMER)
         typedef RunLoopTimer<DocumentLoader> DocumentLoaderTimer;
 #else
-        typedef Timer<DocumentLoader> DocumentLoaderTimer;
+        typedef Timer DocumentLoaderTimer;
 #endif
         void handleSubstituteDataLoadSoon();
         void handleSubstituteDataLoadNow(DocumentLoaderTimer*);
         void startDataLoadTimer();
 
         void deliverSubstituteResourcesAfterDelay();
-        void substituteResourceDeliveryTimerFired(Timer<DocumentLoader>&);
+        void substituteResourceDeliveryTimerFired(Timer&);
 
         void clearMainResource();
 
@@ -386,7 +386,7 @@ namespace WebCore {
         
         typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource>> SubstituteResourceMap;
         SubstituteResourceMap m_pendingSubstituteResources;
-        Timer<DocumentLoader> m_substituteResourceDeliveryTimer;
+        Timer m_substituteResourceDeliveryTimer;
 
         OwnPtr<ArchiveResourceCollection> m_archiveResourceCollection;
 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
index b57e67e6582df01884cd63d1f3bb8413ed8161c3..ddbce0dcc5773174fcca471af7195d06796c380f 100644 (file)
@@ -850,7 +850,7 @@ void FrameLoader::checkCompleted()
         checkLoadComplete();
 }
 
-void FrameLoader::checkTimerFired(Timer<FrameLoader>&)
+void FrameLoader::checkTimerFired(Timer&)
 {
     Ref<Frame> protect(m_frame);
 
index 7925e4dba6fc530e0823877d40352ba95f1380d9..1560ca187ad24d455a84f85d01e9706e45827123 100644 (file)
@@ -299,7 +299,7 @@ private:
 
     bool allChildrenAreComplete() const; // immediate children, not all descendants
 
-    void checkTimerFired(Timer<FrameLoader>&);
+    void checkTimerFired(Timer&);
     
     void loadSameDocumentItem(HistoryItem*);
     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType, FormSubmissionCacheLoadPolicy);
@@ -423,7 +423,7 @@ private:
 
     URL m_submittedFormURL;
 
-    Timer<FrameLoader> m_checkTimer;
+    Timer m_checkTimer;
     bool m_shouldCallCheckCompleted;
     bool m_shouldCallCheckLoadComplete;
 
index 0f067742e4fc6927c679b4896e300b58637aeb39..602fb9db1c6c19f2937804531f0b6d69e8003cdf 100644 (file)
@@ -374,7 +374,7 @@ void ImageLoader::updatedHasPendingEvent()
     }   
 }
 
-void ImageLoader::timerFired(Timer<ImageLoader>&)
+void ImageLoader::timerFired(Timer&)
 {
     element().deref();
 }
index 5f3724ccabb65efa78bfdf867da1f278d4ddd73d..83ad8dcf0531add8f0b093b44d3aa3e841aa4a2e 100644 (file)
@@ -91,11 +91,11 @@ private:
     void setImageWithoutConsideringPendingLoadEvent(CachedImage*);
     void clearFailedLoadURL();
 
-    void timerFired(Timer<ImageLoader>&);
+    void timerFired(Timer&);
 
     Element& m_element;
     CachedResourceHandle<CachedImage> m_image;
-    Timer<ImageLoader> m_derefElementTimer;
+    Timer m_derefElementTimer;
     AtomicString m_failedLoadURL;
     bool m_hasPendingBeforeLoadEvent : 1;
     bool m_hasPendingLoadEvent : 1;
index e63bbf0c22e56d6cea15af31fe7d8e39a497b724..995fc705500e525cdea48a055f0ee45e4d72920f 100644 (file)
@@ -60,13 +60,13 @@ LinkLoader::~LinkLoader()
         m_cachedLinkResource->removeClient(this);
 }
 
-void LinkLoader::linkLoadTimerFired(Timer<LinkLoader>& timer)
+void LinkLoader::linkLoadTimerFired(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_linkLoadTimer);
     m_client->linkLoaded();
 }
 
-void LinkLoader::linkLoadingErrorTimerFired(Timer<LinkLoader>& timer)
+void LinkLoader::linkLoadingErrorTimerFired(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_linkLoadingErrorTimer);
     m_client->linkLoadingErrored();
index 42b756c4324a2aef156a2666f1c4474539abc1ac..ad4d579f08cce33753cae705cc9fa9cc36b319b2 100644 (file)
@@ -59,14 +59,14 @@ public:
     bool loadLink(const LinkRelAttribute&, const String& type, const String& sizes, const URL&, Document*);
 
 private:
-    void linkLoadTimerFired(Timer<LinkLoader>&);
-    void linkLoadingErrorTimerFired(Timer<LinkLoader>&);
+    void linkLoadTimerFired(Timer&);
+    void linkLoadingErrorTimerFired(Timer&);
 
     LinkLoaderClient* m_client;
 
     CachedResourceHandle<CachedResource> m_cachedLinkResource;
-    Timer<LinkLoader> m_linkLoadTimer;
-    Timer<LinkLoader> m_linkLoadingErrorTimer;
+    Timer m_linkLoadTimer;
+    Timer m_linkLoadingErrorTimer;
 };
     
 }
index 21c3804cdc7bf777b3190cbc320a9c20271f02df..ac6e08a87255ad91977c790334e559ee961ec8f2 100644 (file)
@@ -74,7 +74,7 @@ public:
     virtual void fire(Frame&) = 0;
 
     virtual bool shouldStartTimer(Frame&) { return true; }
-    virtual void didStartTimer(Frame&, Timer<NavigationScheduler>&) { }
+    virtual void didStartTimer(Frame&, Timer&) { }
     virtual void didStopTimer(Frame&, bool /* newLoadInProgress */) { }
 
     double delay() const { return m_delay; }
@@ -113,7 +113,7 @@ protected:
         frame.loader().changeLocation(m_securityOrigin.get(), m_url, m_referrer, lockHistory(), lockBackForwardList(), false);
     }
 
-    virtual void didStartTimer(Frame& frame, Timer<NavigationScheduler>& timer) override
+    virtual void didStartTimer(Frame& frame, Timer& timer) override
     {
         if (m_haveToldClient)
             return;
@@ -249,7 +249,7 @@ public:
         frame.loader().loadFrameRequest(frameRequest, lockHistory(), lockBackForwardList(), m_submission->event(), m_submission->state(), MaybeSendReferrer, AllowNavigationToInvalidURL::Yes);
     }
     
-    virtual void didStartTimer(Frame& frame, Timer<NavigationScheduler>& timer) override
+    virtual void didStartTimer(Frame& frame, Timer& timer) override
     {
         if (m_haveToldClient)
             return;
@@ -430,7 +430,7 @@ void NavigationScheduler::scheduleHistoryNavigation(int steps)
     schedule(std::make_unique<ScheduledHistoryNavigation>(steps));
 }
 
-void NavigationScheduler::timerFired(Timer<NavigationScheduler>&)
+void NavigationScheduler::timerFired(Timer&)
 {
     if (!m_frame.page())
         return;
index 7db21a72c1d6287d50ff57379079ef83c3d9c37c..356f188fb203b50838e1017a011844856c9eb62b 100644 (file)
@@ -83,13 +83,13 @@ private:
     bool shouldScheduleNavigation() const;
     bool shouldScheduleNavigation(const URL&) const;
 
-    void timerFired(Timer<NavigationScheduler>&);
+    void timerFired(Timer&);
     void schedule(std::unique_ptr<ScheduledNavigation>);
 
     static LockBackForwardList mustLockBackForwardList(Frame& targetFrame);
 
     Frame& m_frame;
-    Timer<NavigationScheduler> m_timer;
+    Timer m_timer;
     std::unique_ptr<ScheduledNavigation> m_redirect;
 };
 
index b3bec06cbbba11fe72dc6d07e95df566d4efd8bf..b7b85efb3b2ff0fffe70a382f33e5ea78c329d65 100644 (file)
@@ -69,10 +69,10 @@ private:
     virtual void didFinishLoading(ResourceHandle*, double) override { delete this; }
     virtual void didFail(ResourceHandle*, const ResourceError&) override { delete this; }
     virtual bool shouldUseCredentialStorage(ResourceHandle*)  override { return m_shouldUseCredentialStorage; }
-    void timeoutTimerFired(Timer<PingLoader>&) { delete this; }
+    void timeoutTimerFired(Timer&) { delete this; }
 
     RefPtr<ResourceHandle> m_handle;
-    Timer<PingLoader> m_timeout;
+    Timer m_timeout;
     bool m_shouldUseCredentialStorage;
 };
 
index 20d446109010e555832b3bb2b616840337e2dd40..e9e950400ceb6549ec68e3adcd68d1cc7d67a610 100644 (file)
@@ -305,7 +305,7 @@ bool ProgressTracker::isMainLoadProgressing() const
     return m_progressValue && m_progressValue < finalProgressValue && m_heartbeatsWithNoProgress < loadStalledHeartbeatCount;
 }
 
-void ProgressTracker::progressHeartbeatTimerFired(Timer<ProgressTracker>&)
+void ProgressTracker::progressHeartbeatTimerFired(Timer&)
 {
     if (m_totalBytesReceived < m_totalBytesReceivedBeforePreviousHeartbeat + minumumBytesPerHeartbeatForProgress)
         ++m_heartbeatsWithNoProgress;
index 4403b4d69ca9030a96a9c4aa336ed89b2cf4247d..8a39a11517def548a6b44ee9613eddb01c28b732 100644 (file)
@@ -66,7 +66,7 @@ private:
     void reset();
     void finalProgressComplete();
 
-    void progressHeartbeatTimerFired(Timer<ProgressTracker>&);
+    void progressHeartbeatTimerFired(Timer&);
     
     static unsigned long s_uniqueIdentifier;
     
@@ -82,7 +82,7 @@ private:
     int m_numProgressTrackedFrames;
     HashMap<unsigned long, std::unique_ptr<ProgressItem>> m_progressItems;
 
-    Timer<ProgressTracker> m_progressHeartbeatTimer;
+    Timer m_progressHeartbeatTimer;
     unsigned m_heartbeatsWithNoProgress;
     long long m_totalBytesReceivedBeforePreviousHeartbeat;
     std::chrono::steady_clock::time_point m_mainLoadCompletionTime;
index 8a41b8755b0d13c92c22976d0d715243305946ca..6d8b9e7fe496ba955a18887fe9b605d706c28e94 100644 (file)
@@ -332,7 +332,7 @@ void ResourceLoadScheduler::scheduleServePendingRequests()
         m_requestTimer.startOneShot(0);
 }
 
-void ResourceLoadScheduler::requestTimerFired(Timer<ResourceLoadScheduler>&)
+void ResourceLoadScheduler::requestTimerFired(Timer&)
 {
     LOG(ResourceLoading, "ResourceLoadScheduler::requestTimerFired\n");
     servePendingRequests();
index 4111e7909227d268d619df7561d3a9be5629a9d0..5b3742f3931f09fc35a916b651b2619941ae334d 100644 (file)
@@ -84,7 +84,7 @@ protected:
 private:
     void scheduleLoad(ResourceLoader*);
     void scheduleServePendingRequests();
-    void requestTimerFired(Timer<ResourceLoadScheduler>&);
+    void requestTimerFired(Timer&);
 
     bool isSuspendingPendingRequests() const { return !!m_suspendPendingRequestsCount; }
 
@@ -124,7 +124,7 @@ private:
     HostMap m_hosts;
     HostInformation* m_nonHTTPProtocolHost;
         
-    Timer<ResourceLoadScheduler> m_requestTimer;
+    Timer m_requestTimer;
 
     unsigned m_suspendPendingRequestsCount;
     bool m_isSerialLoadingEnabled;
index 0f27b92807f391cf40ef8febe38915737f035c2b..ed0cb75b7b1682e3bd5e8de144e3fe216b539cae 100644 (file)
@@ -59,7 +59,7 @@ TextTrackLoader::~TextTrackLoader()
         m_resource->removeClient(this);
 }
 
-void TextTrackLoader::cueLoadTimerFired(Timer<TextTrackLoader>* timer)
+void TextTrackLoader::cueLoadTimerFired(Timer* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_cueLoadTimer);
     
index c9886c8f4763c8a77a0bafa47c286d16b84788ee..187ffbefb28e4bcc3f830ce09393c28e539d4a49 100644 (file)
@@ -80,7 +80,7 @@ private:
     virtual void fileFailedToParse() override;
     
     void processNewCueData(CachedResource*);
-    void cueLoadTimerFired(Timer<TextTrackLoader>*);
+    void cueLoadTimerFired(Timer*);
     void corsPolicyPreventedLoad();
 
     enum State { Idle, Loading, Finished, Failed };
@@ -89,7 +89,7 @@ private:
     std::unique_ptr<WebVTTParser> m_cueParser;
     CachedResourceHandle<CachedTextTrack> m_resource;
     ScriptExecutionContext* m_scriptExecutionContext;
-    Timer<TextTrackLoader> m_cueLoadTimer;
+    Timer m_cueLoadTimer;
     String m_crossOriginMode;
     State m_state;
     unsigned m_parseOffset;
index ceee58c03246f8c8adefdf151376f2b1ce9c38bb..1e85f5a1b2d1d43482379ba2b7fb20e3ebbe3a4c 100644 (file)
@@ -742,7 +742,7 @@ inline void CachedResource::Callback::cancel()
         m_timer.stop();
 }
 
-void CachedResource::Callback::timerFired(Timer<Callback>&)
+void CachedResource::Callback::timerFired(Timer&)
 {
     m_resource.didAddClient(&m_client);
 }
index bf6e997410ec23701869228ad0c58db40da296cc..bcce27435c350ebaaf62efbc0f9aa58ec18be532 100644 (file)
@@ -347,11 +347,11 @@ public:
     void cancel();
 
 private:
-    void timerFired(Timer<Callback>&);
+    void timerFired(Timer&);
 
     CachedResource& m_resource;
     CachedResourceClient& m_client;
-    Timer<Callback> m_timer;
+    Timer m_timer;
 };
 
 } // namespace WebCore
index d16084904e12e0cd12efc26105c89484f80b1b72..a70c8625203048c740547d0dd87e05f9fabce23c 100644 (file)
@@ -778,7 +778,7 @@ void CachedResourceLoader::loadDone(CachedResource* resource, bool shouldPerform
 // bookkeeping on CachedResources, so instead pseudo-GC them -- when the
 // reference count reaches 1, m_documentResources is the only reference, so
 // remove it from the map.
-void CachedResourceLoader::garbageCollectDocumentResourcesTimerFired(Timer<CachedResourceLoader>& timer)
+void CachedResourceLoader::garbageCollectDocumentResourcesTimerFired(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_garbageCollectDocumentResourcesTimer);
     garbageCollectDocumentResources();
index 7076c860cc94ad044ab60ff416b4a316fe91f5cb..66a812dd029f62f0872d641b0316a66a5faf3c5c 100644 (file)
@@ -152,7 +152,7 @@ private:
     bool shouldContinueAfterNotifyingLoadedFromMemoryCache(const CachedResourceRequest&, CachedResource*);
     bool checkInsecureContent(CachedResource::Type, const URL&) const;
 
-    void garbageCollectDocumentResourcesTimerFired(Timer<CachedResourceLoader>&);
+    void garbageCollectDocumentResourcesTimerFired(Timer&);
     void performPostLoadActions();
 
     bool clientDefersImage(const URL&) const;
@@ -173,7 +173,7 @@ private:
     };
     Deque<PendingPreload> m_pendingPreloads;
 
-    Timer<CachedResourceLoader> m_garbageCollectDocumentResourcesTimer;
+    Timer m_garbageCollectDocumentResourcesTimer;
 
 #if ENABLE(RESOURCE_TIMING)
     struct InitiatorInfo {
index 67dc0d9b4b234182171461877fed70bb2a9d5dc2..abcb0cb345afe6096d0f408148b3f925afbedc8c 100644 (file)
@@ -855,7 +855,7 @@ void IconDatabase::scheduleOrDeferSyncTimer()
     });
 }
 
-void IconDatabase::syncTimerFired(Timer<IconDatabase>&)
+void IconDatabase::syncTimerFired(Timer&)
 {
     ASSERT_NOT_SYNC_THREAD();
     wakeSyncThread();
index 91070c80b22860f4a384eff5697533479bbbaa3f..4e0490431eeb9991d5e5fc0a31b81a94882382bd 100644 (file)
@@ -115,9 +115,9 @@ private:
 
     void wakeSyncThread();
     void scheduleOrDeferSyncTimer();
-    void syncTimerFired(Timer<IconDatabase>&);
+    void syncTimerFired(Timer&);
     
-    Timer<IconDatabase> m_syncTimer;
+    Timer m_syncTimer;
     ThreadIdentifier m_syncThread;
     bool m_syncThreadRunning;
     
index 29971e9721033dfb1f70d7ef9979d4d56cff57df..b1dcff25bdc301013d729bf9e861c5aa858569ca 100644 (file)
@@ -231,7 +231,7 @@ bool AutoscrollController::panScrollInProgress() const
 }
 #endif
 
-void AutoscrollController::autoscrollTimerFired(Timer<AutoscrollController>&)
+void AutoscrollController::autoscrollTimerFired(Timer&)
 {
     if (!m_autoscrollRenderer) {
         stopAutoscrollTimer();
index a009ea56d2d7b5adeddaac05a9f8af52c9e95422..a060f9a4d4eeeffd6a2a104f28074628ada7c2fe 100644 (file)
@@ -69,13 +69,13 @@ public:
 #endif
 
 private:
-    void autoscrollTimerFired(Timer<AutoscrollController>&);
+    void autoscrollTimerFired(Timer&);
     void startAutoscrollTimer();
 #if ENABLE(PAN_SCROLLING)
     void updatePanScrollState(FrameView*, const IntPoint&);
 #endif
 
-    Timer<AutoscrollController> m_autoscrollTimer;
+    Timer m_autoscrollTimer;
     RenderBox* m_autoscrollRenderer;
     AutoscrollType m_autoscrollType;
     IntPoint m_dragAndDropAutoscrollReferencePosition;
index 7e9a0ce58ca6da2875a550c93961b47b3b9c93ab..9ec05d7451e88adb420b343a25193cd861ad9e35 100644 (file)
@@ -52,7 +52,7 @@ CaptionUserPreferences::~CaptionUserPreferences()
 {
 }
 
-void CaptionUserPreferences::timerFired(Timer<CaptionUserPreferences>&)
+void CaptionUserPreferences::timerFired(Timer&)
 {
     captionPreferencesChanged();
 }
index 0d045eb2cd88e33222af581e42a8544d5be8b427..6f02b57d03ceee51ab28fccb3f42d7a117269ec2 100644 (file)
@@ -97,12 +97,12 @@ protected:
     void updateCaptionStyleSheetOveride();
 
 private:
-    void timerFired(Timer<CaptionUserPreferences>&);
+    void timerFired(Timer&);
     void notify();
 
     PageGroup& m_pageGroup;
     CaptionDisplayMode m_displayMode;
-    Timer<CaptionUserPreferences> m_timer;
+    Timer m_timer;
     String m_userPreferredLanguage;
     String m_captionsStyleSheetOverride;
     String m_primaryAudioTrackLanguageOverride;
index 9c5a91994c7dd686cf07dfc5db728d198685f447..3bb7628abaf2c078543ea349245710aeaf31567a 100644 (file)
@@ -224,7 +224,7 @@ bool CaptionUserPreferencesMediaAF::userPrefersSubtitles() const
     return !(captioningMediaCharacteristics && CFArrayGetCount(captioningMediaCharacteristics.get()));
 }
 
-void CaptionUserPreferencesMediaAF::updateTimerFired(Timer<CaptionUserPreferencesMediaAF>&)
+void CaptionUserPreferencesMediaAF::updateTimerFired(Timer&)
 {
     updateCaptionStyleSheetOveride();
 }
index 71690d57376d5a30c9108cd9b52e7bbc022ef0c1..8b0bbc734c4ae7dd944288cb2b4cdd669a78c76b 100644 (file)
@@ -68,7 +68,7 @@ public:
 
 private:
 #if HAVE(MEDIA_ACCESSIBILITY_FRAMEWORK)
-    void updateTimerFired(Timer<CaptionUserPreferencesMediaAF>&);
+    void updateTimerFired(Timer&);
 
     String captionsWindowCSS() const;
     String captionsBackgroundCSS() const;
@@ -80,7 +80,7 @@ private:
     String captionsTextEdgeCSS() const;
     String cssPropertyWithTextEdgeColor(CSSPropertyID, const String&, const Color&, bool) const;
     String colorPropertyCSS(CSSPropertyID, const Color&, bool) const;
-    Timer<CaptionUserPreferencesMediaAF> m_updateStyleSheetTimer;
+    Timer m_updateStyleSheetTimer;
 
     bool m_listeningForPreferenceChanges;
 #endif
index a2baa23c0bd2718caba7c6dc692ff71d7dcf85b1..6a0e0117bb6c7c916795cad5f5d4109a121b0092 100644 (file)
@@ -84,7 +84,7 @@ void DeviceController::dispatchDeviceEvent(PassRefPtr<Event> prpEvent)
     }
 }
 
-void DeviceController::fireDeviceEvent(Timer<DeviceController>& timer)
+void DeviceController::fireDeviceEvent(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_timer);
     ASSERT(hasLastData());
index 2abfb798f3c191c03b5c603bcb53f9f674cc97e3..c46403d4f427a75fe9828edaae76d6cfc78dce34 100644 (file)
@@ -56,12 +56,12 @@ public:
     virtual PassRefPtr<Event> getLastEvent() { return 0; }
 
 protected:
-    void fireDeviceEvent(Timer<DeviceController>&);
+    void fireDeviceEvent(Timer&);
 
     HashCountedSet<RefPtr<DOMWindow>> m_listeners;
     HashCountedSet<RefPtr<DOMWindow>> m_lastEventListeners;
     DeviceClient* m_client;
-    Timer<DeviceController> m_timer;
+    Timer m_timer;
 };
 
 } // namespace WebCore
index e5cad6baffbdec3777cd87bfc0df920e5ec2097c..92fe65ca25a12d3c55edcbb62d53dbb84db15be7 100644 (file)
@@ -1310,7 +1310,7 @@ bool EventHandler::useHandCursor(Node* node, bool isOverLink, bool shiftKey)
     return ((isOverLink || isSubmitImage(node)) && (!editable || editableLinkEnabled));
 }
 
-void EventHandler::cursorUpdateTimerFired(Timer<EventHandler>&)
+void EventHandler::cursorUpdateTimerFired(Timer&)
 {
     ASSERT(m_frame.document());
     updateCursor();
@@ -1553,7 +1553,7 @@ void EventHandler::cancelAutoHideCursorTimer()
         m_autoHideCursorTimer.stop();
 }
 
-void EventHandler::autoHideCursorTimerFired(Timer<EventHandler>& timer)
+void EventHandler::autoHideCursorTimerFired(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_autoHideCursorTimer);
     m_currentMouseCursor = noneCursor();
@@ -1576,7 +1576,7 @@ void EventHandler::beginTrackingPotentialLongMousePress(const HitTestResult& hit
     page->chrome().didBeginTrackingPotentialLongMousePress(m_mouseDownPos, hitTestResult);
 }
     
-void EventHandler::recognizeLongMousePress(Timer<EventHandler>& timer)
+void EventHandler::recognizeLongMousePress(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_longMousePressTimer);
 
@@ -2944,7 +2944,7 @@ void EventHandler::cancelFakeMouseMoveEvent()
     m_fakeMouseMoveEventTimer.stop();
 }
 
-void EventHandler::fakeMouseMoveEventTimerFired(Timer<EventHandler>& timer)
+void EventHandler::fakeMouseMoveEventTimerFired(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_fakeMouseMoveEventTimer);
     ASSERT(!m_mousePressed);
@@ -2980,7 +2980,7 @@ void EventHandler::resizeLayerDestroyed()
     m_resizeLayer = 0;
 }
 
-void EventHandler::hoverTimerFired(Timer<EventHandler>&)
+void EventHandler::hoverTimerFired(Timer&)
 {
     m_hoverTimer.stop();
 
index 37ea75da8df3a1345b883532194c686dd57990ea..9cd857ac690fc2f59e22998a39d26ca923a911b3 100644 (file)
@@ -326,9 +326,9 @@ private:
 
     OptionalCursor selectCursor(const HitTestResult&, bool shiftKey);
 
-    void hoverTimerFired(Timer<EventHandler>&);
+    void hoverTimerFired(Timer&);
 #if ENABLE(CURSOR_SUPPORT)
-    void cursorUpdateTimerFired(Timer<EventHandler>&);
+    void cursorUpdateTimerFired(Timer&);
 #endif
 
     bool logicalScrollOverflow(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = 0);
@@ -341,7 +341,7 @@ private:
     static bool eventInvertsTabsToLinksClientCallResult(KeyboardEvent*);
 
 #if !ENABLE(IOS_TOUCH_EVENTS)
-    void fakeMouseMoveEventTimerFired(Timer<EventHandler>&);
+    void fakeMouseMoveEventTimerFired(Timer&);
     void cancelFakeMouseMoveEvent();
 #endif
 
@@ -437,11 +437,11 @@ private:
 #if ENABLE(CURSOR_VISIBILITY)
     void startAutoHideCursorTimer();
     void cancelAutoHideCursorTimer();
-    void autoHideCursorTimerFired(Timer<EventHandler>&);
+    void autoHideCursorTimerFired(Timer&);
 #endif
 
     void beginTrackingPotentialLongMousePress(const HitTestResult&);
-    void recognizeLongMousePress(Timer<EventHandler>&);
+    void recognizeLongMousePress(Timer&);
     void cancelTrackingPotentialLongMousePress();
     bool longMousePressHysteresisExceeded();
     void clearLongMousePressState();
@@ -470,12 +470,12 @@ private:
 
     bool m_panScrollButtonPressed;
 
-    Timer<EventHandler> m_hoverTimer;
+    Timer m_hoverTimer;
 #if ENABLE(CURSOR_SUPPORT)
-    Timer<EventHandler> m_cursorUpdateTimer;
+    Timer m_cursorUpdateTimer;
 #endif
 
-    Timer<EventHandler> m_longMousePressTimer;
+    Timer m_longMousePressTimer;
     bool m_didRecognizeLongMousePress;
 
     std::unique_ptr<AutoscrollController> m_autoscrollController;
@@ -483,7 +483,7 @@ private:
     bool m_mouseDownWasInSubframe;
 
 #if !ENABLE(IOS_TOUCH_EVENTS)
-    Timer<EventHandler> m_fakeMouseMoveEventTimer;
+    Timer m_fakeMouseMoveEventTimer;
 #endif
 
     bool m_svgPan;
@@ -558,7 +558,7 @@ private:
     bool m_isHandlingWheelEvent;
 
 #if ENABLE(CURSOR_VISIBILITY)
-    Timer<EventHandler> m_autoHideCursorTimer;
+    Timer m_autoHideCursorTimer;
 #endif
 };
 
index 336e151b648c15654dada092fd55f019ca4a593c..635c8ead0abfb660ac6643947e42fae73449715a 100644 (file)
@@ -170,7 +170,7 @@ void EventSource::scheduleReconnect()
     dispatchEvent(Event::create(eventNames().errorEvent, false, false));
 }
 
-void EventSource::connectTimerFired(Timer<EventSource>&)
+void EventSource::connectTimerFired(Timer&)
 {
     connect();
 }
index f2d1c12564712ea4b64cca5f47629c261cc6d58f..a4525f423cfc2e125e3cf5f3e93497753cf37cf4 100644 (file)
@@ -97,7 +97,7 @@ private:
     void networkRequestEnded();
     void scheduleInitialConnect();
     void scheduleReconnect();
-    void connectTimerFired(Timer<EventSource>&);
+    void connectTimerFired(Timer&);
     void abortConnectionAttempt();
     void parseEventStream();
     void parseEventStreamLine(unsigned pos, int fieldLength, int lineLength);
@@ -109,7 +109,7 @@ private:
 
     RefPtr<TextResourceDecoder> m_decoder;
     RefPtr<ThreadableLoader> m_loader;
-    Timer<EventSource> m_connectTimer;
+    Timer m_connectTimer;
     Vector<UChar> m_receiveBuf;
     bool m_discardTrailingNewline;
     bool m_requestInFlight;
index c2feb7c80fad163ca3a4ce8e5788a57773bdfe46..7a5f5d4ad126832efc4e997a86598298f3041626 100644 (file)
@@ -912,7 +912,7 @@ void FocusController::setFocusedElementNeedsRepaint()
     m_focusRepaintTimer.startOneShot(0.033);
 }
 
-void FocusController::focusRepaintTimerFired(Timer<FocusController>&)
+void FocusController::focusRepaintTimerFired(Timer&)
 {
     Document* focusedDocument = focusedOrMainFrame().document();
     if (!focusedDocument)
index bc48d4338fe789e1a861c105b7c8a477d80c6762..36f12008497ca5e8f7199755bc353ac64f939c97 100644 (file)
@@ -120,14 +120,14 @@ private:
     bool advanceFocusDirectionallyInContainer(Node* container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*);
     void findFocusCandidateInContainer(Node* container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*, FocusCandidate& closest);
 
-    void focusRepaintTimerFired(Timer<FocusController>&);
+    void focusRepaintTimerFired(Timer&);
 
     Page& m_page;
     RefPtr<Frame> m_focusedFrame;
     bool m_isChangingFocusedFrame;
     ViewState::Flags m_viewState;
 
-    Timer<FocusController> m_focusRepaintTimer;
+    Timer m_focusRepaintTimer;
     double m_focusSetTime;
 };
 
index 5ddca422ba4d6591175e31f51785dd233d8c3ba2..9c376a9053d9062dd03dc3f4225030907bc252ee 100644 (file)
@@ -516,7 +516,7 @@ void Frame::scrollOverflowLayer(RenderLayer* layer, const IntRect& visibleRect,
     selection().updateAppearance();
 }
 
-void Frame::overflowAutoScrollTimerFired(Timer<Frame>*)
+void Frame::overflowAutoScrollTimerFired(Timer*)
 {
     if (!eventHandler().mousePressed() || checkOverflowScroll(PerformOverflowScroll) == OverflowScrollNone) {
         if (m_overflowAutoScrollTimer.isActive())
index 6edda3420793038f832d7a8323ff70a13faca863..be74942597aa30d0fee391d8e57f25e0ab406c63 100644 (file)
@@ -295,13 +295,13 @@ namespace WebCore {
         bool hitTestResultAtViewportLocation(const FloatPoint& viewportLocation, HitTestResult&, IntPoint& center);
         Node* qualifyingNodeAtViewportLocation(const FloatPoint& viewportLocation, FloatPoint& adjustedViewportLocation, NodeQualifier, bool shouldApproximate);
 
-        void overflowAutoScrollTimerFired(Timer<Frame>*);
+        void overflowAutoScrollTimerFired(Timer*);
         void startOverflowAutoScroll(const IntPoint&);
         int checkOverflowScroll(OverflowScrollAction);
 
         void setTimersPausedInternal(bool);
 
-        Timer<Frame> m_overflowAutoScrollTimer;
+        Timer m_overflowAutoScrollTimer;
         float m_overflowAutoScrollDelta;
         IntPoint m_overflowAutoScrollPos;
         ViewportArguments m_viewportArguments;
index c599f1baa335798b21c19b547331b458d229c0f8..248f2a27a867f7c7484ad3b6c6ccb68fd805b176 100644 (file)
@@ -1738,7 +1738,7 @@ IntPoint FrameView::maximumScrollPosition() const
     return maximumOffset;
 }
 
-void FrameView::delayedScrollEventTimerFired(Timer<FrameView>&)
+void FrameView::delayedScrollEventTimerFired(Timer&)
 {
     sendScrollEvent();
 }
@@ -2400,7 +2400,7 @@ void FrameView::enableSpeculativeTilingIfNeeded()
     m_speculativeTilingEnableTimer.startOneShot(speculativeTilingEnableDelay);
 }
 
-void FrameView::speculativeTilingEnableTimerFired(Timer<FrameView>&)
+void FrameView::speculativeTilingEnableTimerFired(Timer&)
 {
     if (m_speculativeTilingEnabled)
         return;
@@ -2408,7 +2408,7 @@ void FrameView::speculativeTilingEnableTimerFired(Timer<FrameView>&)
     adjustTiledBackingCoverage();
 }
 
-void FrameView::layoutTimerFired(Timer<FrameView>&)
+void FrameView::layoutTimerFired(Timer&)
 {
 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
     if (!frame().document()->ownerElement())
@@ -2850,7 +2850,7 @@ bool FrameView::updateEmbeddedObjects()
     return m_embeddedObjectsToUpdate->isEmpty();
 }
 
-void FrameView::updateEmbeddedObjectsTimerFired(Timer<FrameView>*)
+void FrameView::updateEmbeddedObjectsTimerFired(Timer*)
 {
     RefPtr<FrameView> protect(this);
     m_updateEmbeddedObjectsTimer.stop();
@@ -2999,7 +2999,7 @@ void FrameView::willEndLiveResize()
     adjustTiledBackingCoverage();
 }
 
-void FrameView::postLayoutTimerFired(Timer<FrameView>&)
+void FrameView::postLayoutTimerFired(Timer&)
 {
     performPostLayoutTasks();
 }
index af980f58842270a6aabf5210423d6416c2d622ce..189ff476a1913c301e77e0a69b5721d903a15f62 100644 (file)
@@ -104,7 +104,7 @@ public:
 
     void layout(bool allowSubtree = true);
     WEBCORE_EXPORT bool didFirstLayout() const;
-    void layoutTimerFired(Timer<FrameView>&);
+    void layoutTimerFired(Timer&);
     void scheduleRelayout();
     void scheduleRelayoutOfSubtree(RenderElement&);
     void unscheduleRelayout();
@@ -239,7 +239,7 @@ public:
     virtual bool isRubberBandInProgress() const override;
     WEBCORE_EXPORT virtual IntPoint minimumScrollPosition() const override;
     WEBCORE_EXPORT virtual IntPoint maximumScrollPosition() const override;
-    void delayedScrollEventTimerFired(Timer<FrameView>&);
+    void delayedScrollEventTimerFired(Timer&);
 
     void resumeVisibleImageAnimationsIncludingSubframes();
 
@@ -301,7 +301,7 @@ public:
 
     void restoreScrollbar();
 
-    void postLayoutTimerFired(Timer<FrameView>&);
+    void postLayoutTimerFired(Timer&);
 
     WEBCORE_EXPORT bool wasScrolledByUser() const;
     WEBCORE_EXPORT void setWasScrolledByUser(bool);
@@ -607,9 +607,9 @@ private:
     virtual void notifyPageThatContentAreaWillPaint() const override;
 
     void enableSpeculativeTilingIfNeeded();
-    void speculativeTilingEnableTimerFired(Timer<FrameView>&);
+    void speculativeTilingEnableTimerFired(Timer&);
 
-    void updateEmbeddedObjectsTimerFired(Timer<FrameView>*);
+    void updateEmbeddedObjectsTimerFired(Timer*);
     bool updateEmbeddedObjects();
     void updateEmbeddedObject(RenderEmbeddedObject&);
     void scrollToAnchor();
@@ -653,7 +653,7 @@ private:
     bool m_isOverlapped;
     bool m_contentIsOpaque;
 
-    Timer<FrameView> m_layoutTimer;
+    Timer m_layoutTimer;
     bool m_delayedLayout;
     RenderElement* m_layoutRoot;
 
@@ -662,8 +662,8 @@ private:
     bool m_inSynchronousPostLayout;
     int m_layoutCount;
     unsigned m_nestedLayoutCount;
-    Timer<FrameView> m_postLayoutTasksTimer;
-    Timer<FrameView> m_updateEmbeddedObjectsTimer;
+    Timer m_postLayoutTasksTimer;
+    Timer m_updateEmbeddedObjectsTimer;
     bool m_firstLayoutCallbackPending;
 
     bool m_firstLayout;
@@ -685,7 +685,7 @@ private:
     bool m_wasScrolledByUser;
     bool m_inProgrammaticScroll;
     bool m_safeToPropagateScrollToParent;
-    Timer<FrameView> m_delayedScrollEventTimer;
+    Timer m_delayedScrollEventTimer;
 
     double m_lastPaintTime;
 
@@ -714,7 +714,7 @@ private:
     RenderPtr<RenderScrollbarPart> m_scrollCorner;
 
     bool m_speculativeTilingEnabled;
-    Timer<FrameView> m_speculativeTilingEnableTimer;
+    Timer m_speculativeTilingEnableTimer;
 
 #if PLATFORM(IOS)
     bool m_useCustomFixedPositionLayoutRect;
index 9e8ac1bd695a8e5be1a1aff5b32be96965b4924c..b51d46448703ea1c9b8279852319f138b410ee8d 100644 (file)
@@ -225,7 +225,7 @@ void PageOverlay::startFadeAnimation()
     m_fadeAnimationTimer.startRepeating(1 / fadeAnimationFrameRate);
 }
 
-void PageOverlay::fadeAnimationTimerFired(Timer<PageOverlay>&)
+void PageOverlay::fadeAnimationTimerFired(Timer&)
 {
     float animationProgress = (currentTime() - m_fadeAnimationStartTime) / m_fadeAnimationDuration;
 
index a3d82858eda4df3010abe46ddb4a164daf42b571..70febc8cba2e57b91d0df62480e0436599c307b2 100644 (file)
@@ -112,12 +112,12 @@ private:
     explicit PageOverlay(Client&, OverlayType);
 
     void startFadeAnimation();
-    void fadeAnimationTimerFired(Timer<PageOverlay>&);
+    void fadeAnimationTimerFired(Timer&);
 
     Client& m_client;
     Page* m_page;
 
-    Timer<PageOverlay> m_fadeAnimationTimer;
+    Timer m_fadeAnimationTimer;
     double m_fadeAnimationStartTime;
     double m_fadeAnimationDuration;
 
index e4093a40b0e9be240cdfbfd1bf4921e23e2f77b0..b55f96710e080aa858594b306b7d96379db6eea4 100644 (file)
@@ -394,7 +394,7 @@ void Settings::setLoadsImagesAutomatically(bool loadsImagesAutomatically)
     m_setImageLoadingSettingsTimer.startOneShot(0);
 }
 
-void Settings::imageLoadingSettingsTimerFired(Timer<Settings>*)
+void Settings::imageLoadingSettingsTimerFired(Timer*)
 {
     setImageLoadingSettings(m_page);
 }
index 76472f0085d3edd63860e379e8c0fd7b546bf922..5157ad355e8d02ec82be485a112524092f9abe2b 100644 (file)
@@ -321,8 +321,8 @@ private:
 
     double m_timeWithoutMouseMovementBeforeHidingControls;
 
-    Timer<Settings> m_setImageLoadingSettingsTimer;
-    void imageLoadingSettingsTimerFired(Timer<Settings>*);
+    Timer m_setImageLoadingSettingsTimer;
+    void imageLoadingSettingsTimerFired(Timer*);
 
 #if ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
     bool m_hiddenPageDOMTimerThrottlingEnabled : 1;
index c890333060481b9013bf05f767ed8eab54b79c00..8d89916bd2b670fbe3b6ee9d0bf373aad2893a75 100644 (file)
@@ -158,7 +158,7 @@ void AnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/
     m_animationTimer.startOneShot(timeToNextService);
 }
 
-void AnimationControllerPrivate::updateStyleIfNeededDispatcherFired(Timer<AnimationControllerPrivate>&)
+void AnimationControllerPrivate::updateStyleIfNeededDispatcherFired(Timer&)
 {
     fireEventsAndUpdateStyle();
 }
@@ -225,7 +225,7 @@ void AnimationControllerPrivate::animationFrameCallbackFired()
 }
 #endif
 
-void AnimationControllerPrivate::animationTimerFired(Timer<AnimationControllerPrivate>&)
+void AnimationControllerPrivate::animationTimerFired(Timer&)
 {
     // Make sure animationUpdateTime is updated, so that it is current even if no
     // styleChange has happened (e.g. accelerated animations)
index f60f69a8ecb2601d2bf957fbbb68f0b042ac7b4a..5a454f8ca4e4589488cfb1eecf8c79584f45a420 100644 (file)
@@ -68,7 +68,7 @@ public:
     CompositeAnimation& ensureCompositeAnimation(RenderElement&);
     bool clear(RenderElement&);
 
-    void updateStyleIfNeededDispatcherFired(Timer<AnimationControllerPrivate>&);
+    void updateStyleIfNeededDispatcherFired(Timer&);
     void startUpdateStyleIfNeededDispatcher();
     void addEventToDispatch(PassRefPtr<Element> element, const AtomicString& eventType, const String& name, double elapsedTime);
     void addElementChangeToDispatch(PassRef<Element>);
@@ -114,15 +114,15 @@ public:
     void setAllowsNewAnimationsWhileSuspended(bool);
 
 private:
-    void animationTimerFired(Timer<AnimationControllerPrivate>&);
+    void animationTimerFired(Timer&);
 
     void styleAvailable();
     void fireEventsAndUpdateStyle();
     void startTimeResponse(double t);
 
     HashMap<RenderElement*, RefPtr<CompositeAnimation>> m_compositeAnimations;
-    Timer<AnimationControllerPrivate> m_animationTimer;
-    Timer<AnimationControllerPrivate> m_updateStyleIfNeededDispatcher;
+    Timer m_animationTimer;
+    Timer m_updateStyleIfNeededDispatcher;
     Frame& m_frame;
     
     class EventToDispatch {
index 1d7c3ad515a291b6f4b20298606f23d278359bde..8aaf912e03256899af9ed766ad1205d2a68150a2 100644 (file)
@@ -123,7 +123,7 @@ private:
 
     bool mouseIsOverHighlight(Highlight&, bool& mouseIsOverButton) const;
     std::chrono::milliseconds remainingTimeUntilHighlightShouldBeShown(Highlight*) const;
-    void determineActiveHighlightTimerFired(Timer<ServicesOverlayController>&);
+    void determineActiveHighlightTimerFired(Timer&);
 
     static bool highlightsAreEquivalent(const Highlight* a, const Highlight* b);
 
@@ -156,7 +156,7 @@ private:
     RefPtr<Highlight> m_currentMouseDownOnButtonHighlight;
     IntPoint m_mousePosition;
 
-    Timer<ServicesOverlayController> m_determineActiveHighlightTimer;
+    Timer m_determineActiveHighlightTimer;
 };
 
 } // namespace WebKit
index 90ae5904cf4ce56b3bd7d98242fd1be5c9147eb6..0098c76313f4cc660e968a90d3e938a8b1bbc9de 100644 (file)
@@ -450,7 +450,7 @@ std::chrono::milliseconds ServicesOverlayController::remainingTimeUntilHighlight
     return std::chrono::duration_cast<std::chrono::milliseconds>(remainingDelay);
 }
 
-void ServicesOverlayController::determineActiveHighlightTimerFired(Timer<ServicesOverlayController>&)
+void ServicesOverlayController::determineActiveHighlightTimerFired(Timer&)
 {
     bool mouseIsOverButton;
     determineActiveHighlight(mouseIsOverButton);
index 233307d74eca9b51aa317ad7c6ba9eeb5702cf1f..acd2df225eb3fcd4f80c60dc97a6f1ee710f591f 100644 (file)
@@ -213,7 +213,7 @@ void AsyncScrollingCoordinator::scheduleUpdateScrollPositionAfterAsyncScroll(Scr
     m_updateNodeScrollPositionTimer.startOneShot(0);
 }
 
-void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired(Timer<AsyncScrollingCoordinator>*)
+void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired(Timer*)
 {
     updateScrollPositionAfterAsyncScroll(m_scheduledScrollUpdate.nodeID, m_scheduledScrollUpdate.scrollPosition, m_scheduledScrollUpdate.isProgrammaticScroll, m_scheduledScrollUpdate.updateLayerPositionAction);
 }
index afb002b95f1f680d2aefea2134125fa458a27013..3f4d7bc92f9e5bd1e5f8464ef756214912f0ac41 100644 (file)
@@ -105,11 +105,11 @@ private:
     void ensureRootStateNodeForFrameView(FrameView*);
     void updateMainFrameScrollLayerPosition();
 
-    void updateScrollPositionAfterAsyncScrollTimerFired(Timer<AsyncScrollingCoordinator>*);
+    void updateScrollPositionAfterAsyncScrollTimerFired(Timer*);
     
     FrameView* frameViewForScrollingNode(ScrollingNodeID) const;
 
-    Timer<AsyncScrollingCoordinator> m_updateNodeScrollPositionTimer;
+    Timer m_updateNodeScrollPositionTimer;
 
     struct ScheduledScrollUpdate {
         ScheduledScrollUpdate()
index 15faa0b70529ca5f7a638551af3cd18ee2f8332c..011fe8e2382b392261d6d6f031d73f5115f58bee 100644 (file)
@@ -53,10 +53,10 @@ public:
 private:
     virtual void scheduleTreeStateCommit() override;
 
-    void scrollingStateTreeCommitterTimerFired(Timer<ScrollingCoordinatorIOS>*);
+    void scrollingStateTreeCommitterTimerFired(Timer*);
     void commitTreeState();
 
-    Timer<ScrollingCoordinatorIOS> m_scrollingStateTreeCommitterTimer;
+    Timer m_scrollingStateTreeCommitterTimer;
 };
 
 } // namespace WebCore
index f2b7c404724d4945296e99ebcc8428ac2df8f24d..8927e9923aae7868cf9027d4f9ce2f20ea1c4643 100644 (file)
@@ -91,7 +91,7 @@ void ScrollingCoordinatorIOS::scheduleTreeStateCommit()
     m_scrollingStateTreeCommitterTimer.startOneShot(0);
 }
 
-void ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired(Timer<ScrollingCoordinatorIOS>*)
+void ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired(Timer*)
 {
     commitTreeState();
 }
index 7da8780b338832aa2d99b269c739b5cccecbf34d..f71ecc3469e2c0ad077629cf8d50cbfaf85ee690 100644 (file)
@@ -53,12 +53,12 @@ public:
 private:
     virtual void scheduleTreeStateCommit() override;
 
-    void scrollingStateTreeCommitterTimerFired(Timer<ScrollingCoordinatorMac>*);
+    void scrollingStateTreeCommitterTimerFired(Timer*);
     void commitTreeState();
     
     void updateTiledScrollingIndicator();
 
-    Timer<ScrollingCoordinatorMac> m_scrollingStateTreeCommitterTimer;
+    Timer m_scrollingStateTreeCommitterTimer;
 };
 
 } // namespace WebCore
index c6dc3965a2e1059baa88bb5f412c67b421c26251..0bc51997d0e211e1b2c758f1699380d8c03ec176 100644 (file)
@@ -106,7 +106,7 @@ void ScrollingCoordinatorMac::scheduleTreeStateCommit()
     m_scrollingStateTreeCommitterTimer.startOneShot(0);
 }
 
-void ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired(Timer<ScrollingCoordinatorMac>*)
+void ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired(Timer*)
 {
     commitTreeState();
 }
index b882636ad767f8e8db92b0da25ecd4fe467fba08..ca90834e895462c2b3a02038db824e0577ed1732 100644 (file)
@@ -88,7 +88,7 @@ public:
     }
     
 private:
-    void hysteresisTimerFired(Timer<HysteresisActivity>&)
+    void hysteresisTimerFired(Timer&)
     {
         m_delegate.stopped();
         m_timer.stop();
@@ -97,7 +97,7 @@ private:
     Delegate& m_delegate;
     double m_hysteresisSeconds;
     bool m_active;
-    Timer<HysteresisActivity> m_timer;
+    Timer m_timer;
 };
 
 } // namespace WebCore
index 05926601ddc32eb1338ea5133bf3cfcdbbabcb5a..ea3c3977b581d870eec23186ef046a3ef6253a5f 100644 (file)
@@ -176,14 +176,14 @@ void ScrollAnimator::updateScrollAnimatorsAndTimers()
     // FIXME: Currently, scroll snap animators are recreated even though the snap offsets alone can be updated.
     if (m_scrollableArea->horizontalSnapOffsets()) {
         m_horizontalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, m_scrollableArea->horizontalSnapOffsets(), ScrollEventAxis::Horizontal);
-        m_horizontalScrollSnapTimer = std::make_unique<Timer<ScrollAnimator>>(this, &ScrollAnimator::horizontalScrollSnapTimerFired);
+        m_horizontalScrollSnapTimer = std::make_unique<Timer>(this, &ScrollAnimator::horizontalScrollSnapTimerFired);
     } else if (m_horizontalScrollSnapAnimator) {
         m_horizontalScrollSnapAnimator = nullptr;
         m_horizontalScrollSnapTimer = nullptr;
     }
     if (m_scrollableArea->verticalSnapOffsets()) {
         m_verticalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, m_scrollableArea->verticalSnapOffsets(), ScrollEventAxis::Vertical);
-        m_verticalScrollSnapTimer = std::make_unique<Timer<ScrollAnimator>>(this, &ScrollAnimator::verticalScrollSnapTimerFired);
+        m_verticalScrollSnapTimer = std::make_unique<Timer>(this, &ScrollAnimator::verticalScrollSnapTimerFired);
     } else if (m_verticalScrollSnapAnimator) {
         m_verticalScrollSnapAnimator = nullptr;
         m_verticalScrollSnapTimer = nullptr;
@@ -207,24 +207,24 @@ void ScrollAnimator::immediateScrollInAxis(ScrollEventAxis axis, float delta)
 
 void ScrollAnimator::startScrollSnapTimer(ScrollEventAxis axis)
 {
-    Timer<ScrollAnimator>* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
+    Timer* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
     if (!scrollSnapTimer->isActive())
         scrollSnapTimer->startRepeating(1.0 / 60.0);
 }
 
 void ScrollAnimator::stopScrollSnapTimer(ScrollEventAxis axis)
 {
-    Timer<ScrollAnimator>* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
+    Timer* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
     if (scrollSnapTimer->isActive())
         scrollSnapTimer->stop();
 }
 
-void ScrollAnimator::horizontalScrollSnapTimerFired(Timer<ScrollAnimator>&)
+void ScrollAnimator::horizontalScrollSnapTimerFired(Timer&)
 {
     m_horizontalScrollSnapAnimator->scrollSnapAnimationUpdate();
 }
 
-void ScrollAnimator::verticalScrollSnapTimerFired(Timer<ScrollAnimator>&)
+void ScrollAnimator::verticalScrollSnapTimerFired(Timer&)
 {
     m_verticalScrollSnapAnimator->scrollSnapAnimationUpdate();
 }
index e3a7be319cdf3a94c4836cc774712ee8ac251800..eb150fcdfb50671a73fed4e6771f5d9a89148b0d 100644 (file)
@@ -130,8 +130,8 @@ protected:
 
 #if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
     // Trivial wrappers around the actual update loop in AxisScrollSnapAnimator, since WebCore Timer requires a Timer argument.
-    void horizontalScrollSnapTimerFired(Timer<ScrollAnimator>&);
-    void verticalScrollSnapTimerFired(Timer<ScrollAnimator>&);
+    void horizontalScrollSnapTimerFired(Timer&);
+    void verticalScrollSnapTimerFired(Timer&);
 #endif
 
     ScrollableArea* m_scrollableArea;
@@ -139,10 +139,10 @@ protected:
     float m_currentPosY; // subclass code complexity.
 #if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
     std::unique_ptr<AxisScrollSnapAnimator> m_horizontalScrollSnapAnimator;
-    std::unique_ptr<Timer<ScrollAnimator>> m_horizontalScrollSnapTimer;
+    std::unique_ptr<Timer> m_horizontalScrollSnapTimer;
     // FIXME: Find a way to consolidate both timers into one variable.
     std::unique_ptr<AxisScrollSnapAnimator> m_verticalScrollSnapAnimator;
-    std::unique_ptr<Timer<ScrollAnimator>> m_verticalScrollSnapTimer;
+    std::unique_ptr<Timer> m_verticalScrollSnapTimer;
 #endif
 };
 
index 35d8cf46656fc4bdc294a7fbfbf93d590d0df21f..cef833470f56a6affe571180e81f80ea31bbc94f 100644 (file)
@@ -491,7 +491,7 @@ void ScrollAnimatorNone::updateVisibleLengths()
 }
 
 #if USE(REQUEST_ANIMATION_FRAME_TIMER)
-void ScrollAnimatorNone::animationTimerFired(Timer<ScrollAnimatorNone>*)
+void ScrollAnimatorNone::animationTimerFired(Timer*)
 {
     animationTimerFired();
 }
index b38da16a87262267666e56c416f600945ed9dee2..700f4ee1e802a67a35dec00ef4f9e191772fe880 100644 (file)
@@ -145,7 +145,7 @@ protected:
     };
 
 #if USE(REQUEST_ANIMATION_FRAME_TIMER)
-    void animationTimerFired(Timer<ScrollAnimatorNone>*);
+    void animationTimerFired(Timer*);
     void startNextTimer(double delay);
 #else
     void startNextTimer();
@@ -161,7 +161,7 @@ protected:
 
     double m_startTime;
 #if USE(REQUEST_ANIMATION_FRAME_TIMER)
-    Timer<ScrollAnimatorNone> m_animationTimer;
+    Timer m_animationTimer;
 #else
     bool m_animationActive;
 #endif
index 7e8d117ac23af9fef2ea6777af4f1362b4093396..c63fb015989528125dca18717a86c52952e33edf 100644 (file)
@@ -185,7 +185,7 @@ void Scrollbar::paint(GraphicsContext* context, const IntRect& damageRect)
         Widget::paint(context, damageRect);
 }
 
-void Scrollbar::autoscrollTimerFired(Timer<Scrollbar>&)
+void Scrollbar::autoscrollTimerFired(Timer&)
 {
     autoscrollPressedPart(theme()->autoscrollTimerDelay());
 }
index 69885f5a0f07b1d99826e4ffac0733302fef97ff..731de5d3fe33b3c83ee27600a72438cada670516 100644 (file)
@@ -165,7 +165,7 @@ protected:
     virtual void updateThumbPosition();
     virtual void updateThumbProportion();
 
-    void autoscrollTimerFired(Timer<Scrollbar>&);
+    void autoscrollTimerFired(Timer&);
     void startTimerIfNeeded(double delay);
     void stopTimerIfNeeded();
     void autoscrollPressedPart(double delay);
@@ -194,7 +194,7 @@ protected:
 
     bool m_enabled;
 
-    Timer<Scrollbar> m_scrollTimer;
+    Timer m_scrollTimer;
     bool m_overlapsResizer;
 
     bool m_suppressInvalidation;
index 863158d3e857ee139754ee67ada9ff34ac281f43..eac883f41102ab0179552a242dbf05061434609b 100644 (file)
@@ -112,27 +112,38 @@ private:
     friend class TimerHeapReference;
 };
 
-template <typename TimerFiredClass> class Timer : public TimerBase {
-public:
-    typedef void (TimerFiredClass::*TimerFiredFunction)(Timer&);
-    typedef void (TimerFiredClass::*DeprecatedTimerFiredFunction)(Timer*);
 
-    Timer(TimerFiredClass* object, TimerFiredFunction function)
+class Timer : public TimerBase {
+public:
+    template <typename TimerFiredClass, typename TimerFiredBaseClass>
+    Timer(TimerFiredClass* object, void (TimerFiredBaseClass::*function)(Timer&))
         : m_function(std::bind(function, object, std::ref(*this)))
     {
     }
 
-    Timer(TimerFiredClass* object, DeprecatedTimerFiredFunction function)
+    template <typename TimerFiredClass, typename TimerFiredBaseClass>
+    Timer(TimerFiredClass* object, void (TimerFiredBaseClass::*function)(Timer*))
         : m_function(std::bind(function, object, this))
     {
     }
 
+    template <typename TimerFiredClass, typename TimerFiredBaseClass>
+    Timer(TimerFiredClass& object, void (TimerFiredBaseClass::*function)())
+        : m_function(std::bind(function, &object))
+    {
+    }
+
+    Timer(std::function<void ()> function)
+        : m_function(WTF::move(function))
+    {
+    }
+
 private:
     virtual void fired() override
     {
         m_function();
     }
-
+    
     std::function<void ()> m_function;
 };
 
index 51fa7dc2c5571a6cb983792e2c2cf464a7347d6b..d46d6b781cd88a3795da5db30c0d36ce484b545f 100644 (file)
@@ -180,7 +180,7 @@ void MediaSession::visibilityChanged()
         m_clientDataBufferingTimer.startOneShot(kClientDataBufferingTimerThrottleDelay);
 }
 
-void MediaSession::clientDataBufferingTimerFired(Timer<WebCore::MediaSession> &)
+void MediaSession::clientDataBufferingTimerFired(Timer &)
 {
     updateClientDataBuffering();
 }
index b06e067961122bf93d75cc89e2626d46d67f7f67..3241c9004abf18fc27969e87e76b13f76f2f46af 100644 (file)
@@ -106,11 +106,11 @@ protected:
     MediaSessionClient& client() const { return m_client; }
 
 private:
-    void clientDataBufferingTimerFired(Timer<MediaSession>&);
+    void clientDataBufferingTimerFired(Timer&);
     void updateClientDataBuffering();
 
     MediaSessionClient& m_client;
-    Timer<MediaSession> m_clientDataBufferingTimer;
+    Timer m_clientDataBufferingTimer;
     State m_state;
     State m_stateToRestore;
     bool m_notifyingClient;
index 1be9e1d25596967b6236a05664de8d6e9b97eb6e..db55d383e8f40408a8e939ce180379b24a4b3329 100644 (file)
@@ -73,7 +73,7 @@ void BatteryProviderEfl::setBatteryStatus(const AtomicString& eventType, PassRef
     m_client->didChangeBatteryStatus(eventType, m_batteryStatus);
 }
 
-void BatteryProviderEfl::timerFired(Timer<BatteryProviderEfl>* timer)
+void BatteryProviderEfl::timerFired(Timer* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_timer);
     E_DBus_Connection* edbusConnection = e_dbus_bus_get(DBUS_BUS_SYSTEM);
index bb4bb7f04bdddec4b1ea004a9a9c16741165c3e0..43138ea06fbc696cd894093591fa9abee8af3b84 100644 (file)
@@ -45,12 +45,12 @@ public:
     BatteryStatus* batteryStatus() const;
 
 private:
-    void timerFired(Timer<BatteryProviderEfl>*);
+    void timerFired(Timer*);
     static void getBatteryStatus(void* data, void* replyData, DBusError*);
     static void setBatteryClient(void* data, void* replyData, DBusError*);
 
     BatteryProviderEflClient* m_client;
-    Timer<BatteryProviderEfl> m_timer;
+    Timer m_timer;
     RefPtr<BatteryStatus> m_batteryStatus;
     const double m_batteryStatusRefreshInterval;
 };
index 220b369c0351dc201d538b49d9bb9c43e68d094c..48c9ab3f75a63308a755d342630d55fbe0c9f9a3 100644 (file)
@@ -528,7 +528,7 @@ void BitmapImage::startAnimation(CatchUpAnimation catchUpIfNecessary)
 
     if (catchUpIfNecessary == DoNotCatchUp || time < m_desiredFrameStartTime) {
         // Haven't yet reached time for next frame to start; delay until then.
-        m_frameTimer = std::make_unique<Timer<BitmapImage>>(this, &BitmapImage::advanceAnimation);
+        m_frameTimer = std::make_unique<Timer>(this, &BitmapImage::advanceAnimation);
         m_frameTimer->startOneShot(std::max(m_desiredFrameStartTime - time, 0.));
     } else {
         // We've already reached or passed the time for the next frame to start.
@@ -629,7 +629,7 @@ void BitmapImage::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect,
 }
 
 
-void BitmapImage::advanceAnimation(Timer<BitmapImage>&)
+void BitmapImage::advanceAnimation(Timer&)
 {
     internalAdvanceAnimation(false);
     // At this point the image region has been marked dirty, and if it's
index a0a0f24adf03f9e73f24264639551c2a49509b1b..72f71ae7c83ed0742e11a4e511c54413da20c159 100644 (file)
@@ -58,7 +58,7 @@ namespace WTF {
 
 namespace WebCore {
 
-template <typename T> class Timer;
+class Timer;
 
 // ================================================
 // FrameData Class
@@ -258,7 +258,7 @@ protected:
     int repetitionCount(bool imageKnownToBeComplete);  // |imageKnownToBeComplete| should be set if the caller knows the entire image has been decoded.
     bool shouldAnimate();
     virtual void startAnimation(CatchUpAnimation = CatchUp) override;
-    void advanceAnimation(Timer<BitmapImage>&);
+    void advanceAnimation(Timer&);
 
     // Function that does the real work of advancing the animation.  When
     // skippingFrames is true, we're in the middle of a loop trying to skip over
@@ -295,7 +295,7 @@ private:
     size_t m_currentFrame; // The index of the current frame of animation.
     Vector<FrameData, 1> m_frames; // An array of the cached frames of the animation. We have to ref frames to pin them in the cache.
 
-    std::unique_ptr<Timer<BitmapImage>> m_frameTimer;
+    std::unique_ptr<Timer> m_frameTimer;
     int m_repetitionCount; // How many total animation loops we should do.  This will be cAnimationNone if this image type is incapable of animation.
     RepetitionCountStatus m_repetitionCountStatus;
     int m_repetitionsComplete;  // How many repetitions we've finished.
index 7a533d002791fc19f7f9606c9ffc375dc31d8674..81fce9d1529f5951c947a40ccf1924843fe71b1b 100644 (file)
@@ -955,7 +955,7 @@ unsigned MediaPlayer::videoDecodedByteCount() const
     return m_private->videoDecodedByteCount();
 }
 
-void MediaPlayer::reloadTimerFired(Timer<MediaPlayer>&)
+void MediaPlayer::reloadTimerFired(Timer&)
 {
     m_private->cancelLoad();
     loadWithNextMediaEngine(m_currentMediaEngine);
index b1537d70bd5ecd06846f1d9fe256621670799ecb..687d045b0950c3cb0a126fe0ca012d1d4bccfe98 100644 (file)
@@ -582,12 +582,12 @@ private:
     MediaPlayer(MediaPlayerClient&);
     MediaPlayerFactory* nextBestMediaEngine(MediaPlayerFactory*) const;
     void loadWithNextMediaEngine(MediaPlayerFactory*);
-    void reloadTimerFired(Timer<MediaPlayer>&);
+    void reloadTimerFired(Timer&);
 
     static void initializeMediaEngines();
 
     MediaPlayerClient& m_client;
-    Timer<MediaPlayer> m_reloadTimer;
+    Timer m_reloadTimer;
     OwnPtr<MediaPlayerPrivateInterface> m_private;
     MediaPlayerFactory* m_currentMediaEngine;
     URL m_url;
index 917ce09387359dd6893ab38d0199506277c502ea..66df6bf2bc141e6e3a4fce722b457205990e9187 100644 (file)
@@ -130,7 +130,7 @@ public:
     static ScratchBuffer& shared();
 
 private:
-    void timerFired(Timer<ScratchBuffer>*)
+    void timerFired(Timer*)
     {
         clearScratchBuffer();
     }
@@ -143,7 +143,7 @@ private:
     }
 
     std::unique_ptr<ImageBuffer> m_imageBuffer;
-    Timer<ScratchBuffer> m_purgeTimer;
+    Timer m_purgeTimer;
     
     FloatRect m_lastInsetBounds;
     FloatRect m_lastShadowRect;
index 2eef413d344013b61531d81d531ab6203def6d13..04490dd273014ccedd7210fd0e23149533214516 100644 (file)
@@ -513,7 +513,7 @@ void TiledBackingStore::startTileBufferUpdateTimer()
     m_tileBufferUpdateTimer.startOneShot(0);
 }
 
-void TiledBackingStore::tileBufferUpdateTimerFired(Timer<TiledBackingStore>*)
+void TiledBackingStore::tileBufferUpdateTimerFired(Timer*)
 {
     ASSERT(m_commitTileUpdatesOnIdleEventLoop);
     updateTileBuffers();
@@ -529,7 +529,7 @@ void TiledBackingStore::startBackingStoreUpdateTimer(double interval)
     m_backingStoreUpdateTimer.startOneShot(interval);
 }
 
-void TiledBackingStore::backingStoreUpdateTimerFired(Timer<TiledBackingStore>*)
+void TiledBackingStore::backingStoreUpdateTimerFired(Timer*)
 {
     ASSERT(m_commitTileUpdatesOnIdleEventLoop);
     createTiles();
index 9e3040e2b4aa1a3b0e7740d1e4c6e51a5846c848..5693eb7811ad486c3e6cb1b4d9aeb169e05b942f 100644 (file)
@@ -81,8 +81,8 @@ private:
     void startTileBufferUpdateTimer();
     void startBackingStoreUpdateTimer(double = 0);
 
-    void tileBufferUpdateTimerFired(Timer<TiledBackingStore>*);
-    void backingStoreUpdateTimerFired(Timer<TiledBackingStore>*);
+    void tileBufferUpdateTimerFired(Timer*);
+    void backingStoreUpdateTimerFired(Timer*);
 
     void createTiles();
     void computeCoverAndKeepRect(const IntRect& visibleRect, IntRect& coverRect, IntRect& keepRect) const;
@@ -109,8 +109,8 @@ private:
     typedef HashMap<Tile::Coordinate, RefPtr<Tile> > TileMap;
     TileMap m_tiles;
 
-    Timer<TiledBackingStore> m_tileBufferUpdateTimer;
-    Timer<TiledBackingStore> m_backingStoreUpdateTimer;
+    Timer m_tileBufferUpdateTimer;
+    Timer m_backingStoreUpdateTimer;
 
     IntSize m_tileSize;
     float m_coverAreaMultiplier;
index 932ab28987c018e3a78d693db21a90bb60f117ac..471740dae89a59656658c9875f326b83880329d4 100644 (file)
@@ -84,13 +84,13 @@ public:
 private:
     MediaSelectionGroupAVFObjC(AVPlayerItem*, AVMediaSelectionGroup*);
 
-    void selectionTimerFired(Timer<MediaSelectionGroupAVFObjC>&);
+    void selectionTimerFired(Timer&);
 
     RetainPtr<AVPlayerItem> m_playerItem;
     RetainPtr<AVMediaSelectionGroup> m_mediaSelectionGroup;
     OptionContainer m_options;
     MediaSelectionOptionAVFObjC* m_selectedOption;
-    Timer<MediaSelectionGroupAVFObjC> m_selectionTimer;
+    Timer m_selectionTimer;
 };
 
 }
index a076a4874160db3b740990217bbf064a37aa337a..b7fde8ebbb02bc204d71f2931762c2ffc28558b4 100644 (file)
@@ -141,7 +141,7 @@ void MediaSelectionGroupAVFObjC::setSelectedOption(MediaSelectionOptionAVFObjC*
     m_selectionTimer.startOneShot(0);
 }
 
-void MediaSelectionGroupAVFObjC::selectionTimerFired(Timer<MediaSelectionGroupAVFObjC>&)
+void MediaSelectionGroupAVFObjC::selectionTimerFired(Timer&)
 {
     [m_playerItem selectMediaOption:(m_selectedOption ? m_selectedOption->avMediaSelectionOption() : nil) inMediaSelectionGroup:m_mediaSelectionGroup.get()];
 }
index 077ac2e32c38eb7bd25239a024b3f775106957b1..f72acc997db9aa643de9b56974ed711d242f0949 100644 (file)
@@ -168,7 +168,7 @@ private:
     void ensureLayer();
     void destroyLayer();
     bool shouldBePlaying() const;
-    void seekTimerFired(Timer<MediaPlayerPrivateMediaSourceAVFObjC>&);
+    void seekTimerFired(Timer&);
 
     friend class MediaSourcePrivateAVFObjC;
 
@@ -195,7 +195,7 @@ private:
     RetainPtr<id> m_timeJumpedObserver;
     RetainPtr<id> m_durationObserver;
     RetainPtr<AVStreamSession> m_streamSession;
-    Timer<MediaPlayerPrivateMediaSourceAVFObjC> m_seekTimer;
+    Timer m_seekTimer;
     CDMSessionMediaSourceAVFObjC* m_session;
     MediaPlayer::NetworkState m_networkState;
     MediaPlayer::ReadyState m_readyState;
index 1c948803e1c00e14e321980e9e363880a4c3d27c..b2b1db204103020f812f5bd8f9c9c8d931780e7e 100644 (file)
@@ -423,7 +423,7 @@ void MediaPlayerPrivateMediaSourceAVFObjC::seekWithTolerance(const MediaTime& ti
     m_seekTimer.startOneShot(0);
 }
 
-void MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired(Timer<MediaPlayerPrivateMediaSourceAVFObjC>&)
+void MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired(Timer&)
 {
     seekInternal();
 }
index b49bd49f6a9b7b0369b92f716558d8ad89e18f75..6f4be1d9dc68e5e422eb12bbbec9a3a013e58441 100644 (file)
@@ -113,7 +113,7 @@ void LayerPool::schedulePrune()
     m_pruneTimer.startOneShot(1);
 }
 
-void LayerPool::pruneTimerFired(Timer<LayerPool>&)
+void LayerPool::pruneTimerFired(Timer&)
 {
     unsigned shrinkTo = decayedCapacity();
     while (m_totalBytes > shrinkTo) {
index 868116f30a930b49263b40cd4695aa85ee3a6ddf..8bcbe560fcaa86081a2cd1d625b78a27ab6ec820 100644 (file)
@@ -61,7 +61,7 @@ private:
 
     bool canReuseLayerWithSize(const IntSize& size) const { return m_maxBytesForPool && !size.isEmpty(); }
     void schedulePrune();
-    void pruneTimerFired(Timer<LayerPool>&);
+    void pruneTimerFired(Timer&);
 
     typedef enum { LeaveUnchanged, MarkAsUsed } AccessType;
     LayerList& listOfLayersWithSize(const IntSize&, AccessType = LeaveUnchanged);
@@ -74,7 +74,7 @@ private:
     unsigned m_totalBytes;
     unsigned m_maxBytesForPool;
 
-    Timer<LayerPool> m_pruneTimer;
+    Timer m_pruneTimer;
 
     double m_lastAddTime;
 };
index a3c4d571a447abd749646fb0b8b75f0c5dfa99a9..f4ca9103db1862aea88cd0f334b0db01884e26d1 100644 (file)
@@ -340,7 +340,7 @@ bool TileController::shouldTemporarilyRetainTileCohorts() const
     return owningGraphicsLayer()->platformCALayerShouldTemporarilyRetainTileCohorts(m_tileCacheLayer);
 }
 
-void TileController::tileRevalidationTimerFired(Timer<TileController>*)
+void TileController::tileRevalidationTimerFired(Timer*)
 {
     if (!owningGraphicsLayer())
         return;
index 0a76eed9407a17540b27ef3ff9cdd0b7d2565fe6..4ae1a1b8126b041e68eadd38ae04bc69667a52ff 100644 (file)
@@ -156,7 +156,7 @@ private:
     virtual float zoomedOutContentsScale() const override;
 
 
-    void tileRevalidationTimerFired(Timer<TileController>*);
+    void tileRevalidationTimerFired(Timer*);
 
     void setNeedsRevalidateTiles();
 
@@ -174,7 +174,7 @@ private:
     FloatRect m_visibleRectAtLastRevalidate;
     IntRect m_boundsAtLastRevalidate;
 
-    Timer<TileController> m_tileRevalidationTimer;
+    Timer m_tileRevalidationTimer;
 
     float m_zoomedOutContentsScale;
     float m_deviceScaleFactor;
index f54ff04b0aeafef3aa22eff7249d39d935484a20..a77643ba040625c629e8aa2c49ea7a4352946684 100644 (file)
@@ -476,7 +476,7 @@ double TileGrid::TileCohortInfo::timeUntilExpiration()
     return creationTime - timeThreshold;
 }
 
-void TileGrid::cohortRemovalTimerFired(Timer<TileGrid>*)
+void TileGrid::cohortRemovalTimerFired(Timer*)
 {
     if (m_cohortList.isEmpty()) {
         m_cohortRemovalTimer.stop();
index 18fb326277e9c33e63768dd080dedaac989eadd6..56f528de7a378e4d24a0293c4cfe0eea2c1f29b9 100644 (file)
@@ -123,7 +123,7 @@ private:
     void removeTilesInCohort(TileCohort);
 
     void scheduleCohortRemoval();
-    void cohortRemovalTimerFired(Timer<TileGrid>*);
+    void cohortRemovalTimerFired(Timer*);
     TileCohort nextTileCohort() const;
     void startedNewCohort(TileCohort);
     TileCohort newestTileCohort() const;
@@ -154,7 +154,7 @@ private:
     typedef Deque<TileCohortInfo> TileCohortList;
     TileCohortList m_cohortList;
 
-    Timer<TileGrid> m_cohortRemovalTimer;
+    Timer m_cohortRemovalTimer;
 
     typedef HashMap<PlatformCALayer*, int> RepaintCountMap;
     RepaintCountMap m_tileRepaintCounts;
index b80a2fef3cf962281b8e7be6a232abd621974bba..210a1a88182124c649db57430f7bc634148e3682 100644 (file)
@@ -224,7 +224,7 @@ void LegacyCACFLayerTreeHost::resize()
     }
 }
 
-void LegacyCACFLayerTreeHost::renderTimerFired(Timer<LegacyCACFLayerTreeHost>*)
+void LegacyCACFLayerTreeHost::renderTimerFired(Timer*)
 {
     paint();
 }
index 102fcbc78fc7ae0d390b569524bdca55bd7f4751..8f616bf4c6ba0902d2a86640f26f2b58e15812e8 100644 (file)
@@ -50,7 +50,7 @@ private:
     bool resetDevice(ResetReason);
 
     void renderSoon();
-    void renderTimerFired(Timer<LegacyCACFLayerTreeHost>*);
+    void renderTimerFired(Timer*);
 
     virtual void initializeContext(void* userData, PlatformCALayer*);
     virtual void resize();
@@ -66,7 +66,7 @@ private:
     virtual GraphicsDeviceAdapter* graphicsDeviceAdapter() const override { return 0; }
 #endif
 
-    Timer<LegacyCACFLayerTreeHost> m_renderTimer;
+    Timer m_renderTimer;
     COMPtr<IDirect3DDevice9> m_d3dDevice;
     WKCACFContext* m_context;
     bool m_mightBeAbleToCreateDeviceLater;
index a941c930589216d4d35aa72fd9e44a74da9d2ae5..5285dce6e7f477c17ed95704a58a2cc1072ddc5f 100644 (file)
@@ -292,7 +292,7 @@ bool IOSurfacePool::markOlderSurfacesPurgeable()
     return markedAllSurfaces;
 }
 
-void IOSurfacePool::collectionTimerFired(Timer<IOSurfacePool>&)
+void IOSurfacePool::collectionTimerFired(Timer&)
 {
     collectInUseSurfaces();
     bool markedAllSurfaces = markOlderSurfacesPurgeable();
index 80af0d5f2f7043560a8e2521668c4a13af6a99e6..ba441168cfd756a155cd6ce6072f56751daf73bf 100644 (file)
@@ -87,13 +87,13 @@ private:
     void tryEvictOldestCachedSurface();
 
     void scheduleCollectionTimer();
-    void collectionTimerFired(Timer<IOSurfacePool>&);
+    void collectionTimerFired(Timer&);
     void collectInUseSurfaces();
     bool markOlderSurfacesPurgeable();
 
     void platformGarbageCollectNow();
 
-    Timer<IOSurfacePool> m_collectionTimer;
+    Timer m_collectionTimer;
     CachedSurfaceMap m_cachedSurfaces;
     CachedSurfaceQueue m_inUseSurfaces;
     CachedSurfaceDetailsMap m_surfaceDetails;
index 25e5eb619c70b4c79e31d446d461cd05a8ba9a09..ba3c7afbee5d016c2c359ba02c1e01345f1c482c 100644 (file)
@@ -1145,7 +1145,7 @@ void MediaPlayerPrivateGStreamer::processTableOfContentsEntry(GstTocEntry* entry
 }
 #endif
 
-void MediaPlayerPrivateGStreamer::fillTimerFired(Timer<MediaPlayerPrivateGStreamer>*)
+void MediaPlayerPrivateGStreamer::fillTimerFired(Timer*)
 {
     GstQuery* query = gst_query_new_buffering(GST_FORMAT_PERCENT);
 
index 7720015e34817a9835b2f4778aa2913e4cb4b2d5..056134e9abe66d2871ef4aa63e3a7f1b6bf4d01b 100644 (file)
@@ -87,7 +87,7 @@ public:
     void setPreservesPitch(bool);
 
     void setPreload(MediaPlayer::Preload);
-    void fillTimerFired(Timer<MediaPlayerPrivateGStreamer>*);
+    void fillTimerFired(Timer*);
 
     std::unique_ptr<PlatformTimeRanges> buffered() const;
     float maxTimeSeekable() const;
@@ -192,7 +192,7 @@ private:
     bool m_errorOccured;
     mutable gfloat m_mediaDuration;
     bool m_downloadFinished;
-    Timer<MediaPlayerPrivateGStreamer> m_fillTimer;
+    Timer m_fillTimer;
     float m_maxTimeLoaded;
     int m_bufferingPercentage;
     MediaPlayer::Preload m_preload;
index ef855e922b16da8c748687f8d4f08e45df17e285..5802c724b34c1d7f9baec6eb7381da0c115e8dd0 100644 (file)
@@ -156,7 +156,7 @@ private:
     void updateStates();
     void doSeek();
     void cancelSeek();
-    void seekTimerFired(Timer<MediaPlayerPrivateQTKit>&);
+    void seekTimerFired(Timer&);
     MediaTime maxMediaTimeLoaded() const;
     void disableUnsupportedTracks();
     
@@ -180,7 +180,7 @@ private:
     RetainPtr<WebCoreMovieObserver> m_objcObserver;
     String m_movieURL;
     MediaTime m_seekTo;
-    Timer<MediaPlayerPrivateQTKit> m_seekTimer;
+    Timer m_seekTimer;
     MediaPlayer::NetworkState m_networkState;
     MediaPlayer::ReadyState m_readyState;
     IntRect m_rect;
index 6d41153ef0fd094e8a93f66f46a56fae487e6e48..959284a0e42adf4285441ae70883eff3fa221d75 100644 (file)
@@ -676,7 +676,7 @@ void MediaPlayerPrivateQTKit::cancelSeek()
     m_seekTimer.stop();
 }
 
-void MediaPlayerPrivateQTKit::seekTimerFired(Timer<MediaPlayerPrivateQTKit>&)
+void MediaPlayerPrivateQTKit::seekTimerFired(Timer&)
 {        
     if (!metaDataAvailable() || !seeking() || currentMediaTime() == m_seekTo) {
         cancelSeek();
index 53ce4afb7cf4b404c6fb9758eb88ec5855594ad0..7e121a20d963ec85bdc4e3199272799d4421b577 100644 (file)
@@ -54,10 +54,10 @@ public:
 
 private:
     void scheduleReleaseUnusedTextures();
-    void releaseUnusedTexturesTimerFired(Timer<BitmapTexturePool>*);
+    void releaseUnusedTexturesTimerFired(Timer*);
 
     Vector<BitmapTexturePoolEntry> m_textures;
-    Timer<BitmapTexturePool> m_releaseUnusedTexturesTimer;
+    Timer m_releaseUnusedTexturesTimer;
 
     static const double s_releaseUnusedSecondsTolerance;
     static const double s_releaseUnusedTexturesTimerInterval;
@@ -78,7 +78,7 @@ void BitmapTexturePool::scheduleReleaseUnusedTextures()
     m_releaseUnusedTexturesTimer.startOneShot(s_releaseUnusedTexturesTimerInterval);
 }
 
-void BitmapTexturePool::releaseUnusedTexturesTimerFired(Timer<BitmapTexturePool>*)
+void BitmapTexturePool::releaseUnusedTexturesTimerFired(Timer*)
 {
     if (m_textures.isEmpty())
         return;
index 0da429bf296e940e8f08b55908cf5390bb188c2e..061d96fe3fc80c4806affbf49b7ee19842d31860 100644 (file)
@@ -396,7 +396,7 @@ void CompositingCoordinator::scheduleReleaseInactiveAtlases()
         m_releaseInactiveAtlasesTimer.startRepeating(ReleaseInactiveAtlasesTimerInterval);
 }
 
-void CompositingCoordinator::releaseInactiveAtlasesTimerFired(Timer<CompositingCoordinator>*)
+void CompositingCoordinator::releaseInactiveAtlasesTimerFired(Timer*)
 {
     // We always want to keep one atlas for root contents layer.
     std::unique_ptr<UpdateAtlas> atlasToKeepAnyway;
index 0bf4540a54babc35eae69859507def46e9bc0405..0cae86f2b916b4f3ea1b8ae187484c7d734cac75 100644 (file)
@@ -122,7 +122,7 @@ private:
 
     void scheduleReleaseInactiveAtlases();
 
-    void releaseInactiveAtlasesTimerFired(Timer<CompositingCoordinator>*);
+    void releaseInactiveAtlasesTimerFired(Timer*);
 
     Page* m_page;
     CompositingCoordinator::Client* m_client;
@@ -146,7 +146,7 @@ private:
 
     bool m_shouldSyncFrame;
     bool m_didInitializeRootCompositingLayer;
-    Timer<CompositingCoordinator> m_releaseInactiveAtlasesTimer;
+    Timer m_releaseInactiveAtlasesTimer;
 
 #if ENABLE(REQUEST_ANIMATION_FRAME)
     double m_lastAnimationServiceTime;
index 04c908b2a33cbcc124a2093ab4d5273aa9e434d9..99e92b545c46c8bb6994d8896684c7af2fc322a9 100644 (file)
@@ -1220,7 +1220,7 @@ void CoordinatedGraphicsLayer::resumeAnimations()
     didChangeAnimations();
 }
 
-void CoordinatedGraphicsLayer::animationStartedTimerFired(Timer<CoordinatedGraphicsLayer>*)
+void CoordinatedGraphicsLayer::animationStartedTimerFired(Timer*)
 {
     client().notifyAnimationStarted(this, "", m_lastAnimationStartTime);
 }
index 58fbfc0b9b00be7ff3c6b7776ad38c0060c689b1..07c2817c4210669f5a9d93702151fce6270a9e15 100644 (file)
@@ -201,7 +201,7 @@ private:
     void setShouldUpdateVisibleRect();
     float effectiveContentsScale();
 
-    void animationStartedTimerFired(Timer<CoordinatedGraphicsLayer>*);
+    void animationStartedTimerFired(Timer*);
 
     CoordinatedLayerID m_id;
     CoordinatedGraphicsLayerState m_layerState;
@@ -243,7 +243,7 @@ private:
     IntSize m_platformLayerSize;
     GraphicsSurfaceToken m_platformLayerToken;
 #endif
-    Timer<CoordinatedGraphicsLayer> m_animationStartedTimer;
+    Timer m_animationStartedTimer;
     GraphicsLayerAnimations m_animations;
     double m_lastAnimationStartTime;
 
index 80c4eed6b239bdb9d20111d304519abcf5361da1..0930e26901dd97adb6aeee35e99c93f358463811 100644 (file)
@@ -173,7 +173,7 @@ void CoordinatedImageBacking::updateVisibilityIfNeeded(bool& changedToVisible)
     }
 }
 
-void CoordinatedImageBacking::clearContentsTimerFired(Timer<CoordinatedImageBacking>*)
+void CoordinatedImageBacking::clearContentsTimerFired(Timer*)
 {
     m_client->clearImageBackingContents(id());
 }
index 711e491fe54862ccb701ecdbe9637f133ba4b04e..d61765f79a2d78841200cb1aab628f346aee7c01 100644 (file)
@@ -72,7 +72,7 @@ private:
 
     void releaseSurfaceIfNeeded();
     void updateVisibilityIfNeeded(bool& changedToVisible);
-    void clearContentsTimerFired(Timer<CoordinatedImageBacking>*);
+    void clearContentsTimerFired(Timer*);
 
     Client* m_client;
     RefPtr<Image> m_image;
@@ -82,7 +82,7 @@ private:
 
     RefPtr<CoordinatedSurface> m_surface;
 
-    Timer<CoordinatedImageBacking> m_clearContentsTimer;
+    Timer m_clearContentsTimer;
 
     bool m_isDirty;
     bool m_isVisible;
index da1b06da5f80b75b5116f115d24a5b340c6bc99d..f8759a442f62ae784c5407bb23409415bc84e800 100644 (file)
@@ -169,7 +169,7 @@ private:
     void createTilesInActiveGrid(SynchronousTileCreationMode);
     void scheduleLayerFlushForPendingRepaint();
 
-    void tileCreationTimerFired(Timer<LegacyTileCache>*);
+    void tileCreationTimerFired(Timer*);
 
     void drawReplacementImage(LegacyTileLayer*, CGContextRef, CGImageRef);
     void drawWindowContent(LegacyTileLayer*, CGContextRef, CGRect dirtyRect);
@@ -200,7 +200,7 @@ private:
     OwnPtr<LegacyTileGrid> m_zoomedOutTileGrid;
     OwnPtr<LegacyTileGrid> m_zoomedInTileGrid;
 
-    Timer<LegacyTileCache> m_tileCreationTimer;
+    Timer m_tileCreationTimer;
 
     Vector<IntRect> m_savedDisplayRects;
 
index 6c00142b96f6017db5b8e597fce81d6743495566..c3d99322e493db15e2a6424374e45f51e37ad1d2 100644 (file)
@@ -415,7 +415,7 @@ void LegacyTileCache::finishedCreatingTiles(bool didCreateTiles, bool createMore
         m_tileCreationTimer.startOneShot(0);
 }
 
-void LegacyTileCache::tileCreationTimerFired(Timer<LegacyTileCache>*)
+void LegacyTileCache::tileCreationTimerFired(Timer*)
 {
     if (isTileCreationSuspended())
         return;
index dcb34ccd9e13cca6050d903eb3b27d299da14dbc..c491cddbda4165cb7659ed7bfc566a54874c89f8 100644 (file)
@@ -108,7 +108,7 @@ unsigned HIDGamepadProvider::indexForNewlyConnectedDevice()
     return index;
 }
 
-void HIDGamepadProvider::connectionDelayTimerFired(Timer<HIDGamepadProvider>&)
+void HIDGamepadProvider::connectionDelayTimerFired(Timer&)
 {
     m_shouldDispatchCallbacks = true;
 }
@@ -228,7 +228,7 @@ void HIDGamepadProvider::valuesChanged(IOHIDValueRef value)
         m_inputNotificationTimer.startOneShot(InputNotificationDelay);
 }
 
-void HIDGamepadProvider::inputNotificationTimerFired(Timer<HIDGamepadProvider>&)
+void HIDGamepadProvider::inputNotificationTimerFired(Timer&)
 {
     if (!m_shouldDispatchCallbacks)
         return;
index ed76281ef48e54a892e72defa311233d99b59134..ffe75adf04e9ecae52387f2c766c99b1b918d5b5 100644 (file)
@@ -64,8 +64,8 @@ private:
     void openAndScheduleManager();
     void closeAndUnscheduleManager();
 
-    void connectionDelayTimerFired(Timer<HIDGamepadProvider>&);
-    void inputNotificationTimerFired(Timer<HIDGamepadProvider>&);
+    void connectionDelayTimerFired(Timer&);
+    void inputNotificationTimerFired(Timer&);
 
     unsigned indexForNewlyConnectedDevice();
 
@@ -77,8 +77,8 @@ private:
     HashSet<GamepadProviderClient*> m_clients;
     bool m_shouldDispatchCallbacks;
 
-    Timer<HIDGamepadProvider> m_connectionDelayTimer;
-    Timer<HIDGamepadProvider> m_inputNotificationTimer;
+    Timer m_connectionDelayTimer;
+    Timer m_inputNotificationTimer;
 };
 
 } // namespace WebCore
index 012e4a831e215fa80d454e39613cfbd384a56458..b06cdee9f6b9a951dfebc2c6ebbbcf458498cb4c 100644 (file)
@@ -78,11 +78,11 @@ private:
     RetainPtr<WebScrollbarPainterDelegate> m_horizontalScrollbarPainterDelegate;
     RetainPtr<WebScrollbarPainterDelegate> m_verticalScrollbarPainterDelegate;
 
-    void initialScrollbarPaintTimerFired(Timer<ScrollAnimatorMac>&);
-    Timer<ScrollAnimatorMac> m_initialScrollbarPaintTimer;
+    void initialScrollbarPaintTimerFired(Timer&);
+    Timer m_initialScrollbarPaintTimer;
 
-    void sendContentAreaScrolledTimerFired(Timer<ScrollAnimatorMac>&);
-    Timer<ScrollAnimatorMac> m_sendContentAreaScrolledTimer;
+    void sendContentAreaScrolledTimerFired(Timer&);
+    Timer m_sendContentAreaScrolledTimer;
     FloatSize m_contentAreaScrolledTimerScrollDelta;
 
     virtual bool scroll(ScrollbarOrientation, ScrollGranularity, float step, float multiplier);
@@ -155,12 +155,12 @@ private:
     virtual void adjustScrollPositionToBoundsIfNecessary() override;
 
     bool pinnedInDirection(float deltaX, float deltaY);
-    void snapRubberBandTimerFired(Timer<ScrollAnimatorMac>&);
+    void snapRubberBandTimerFired(Timer&);
 
     bool isAlreadyPinnedInDirectionOfGesture(const PlatformWheelEvent&, ScrollEventAxis);
 
     ScrollElasticityController m_scrollElasticityController;
-    Timer<ScrollAnimatorMac> m_snapRubberBandTimer;
+    Timer m_snapRubberBandTimer;
 #endif
 
     bool m_haveScrolledSincePageLoad;
index 43f909e46914d72f418dc2ee418a96b77ac2619b..ba7aac314c9376618ff7ef44be6a3f5bf3f0dbab 100644 (file)
@@ -1257,7 +1257,7 @@ void ScrollAnimatorMac::stopSnapRubberbandTimer()
     m_snapRubberBandTimer.stop();
 }
 
-void ScrollAnimatorMac::snapRubberBandTimerFired(Timer<ScrollAnimatorMac>&)
+void ScrollAnimatorMac::snapRubberBandTimerFired(Timer&)
 {
     m_scrollElasticityController.snapRubberBandTimerFired();
 }
@@ -1338,7 +1338,7 @@ void ScrollAnimatorMac::stopScrollbarPaintTimer()
     m_initialScrollbarPaintTimer.stop();
 }
 
-void ScrollAnimatorMac::initialScrollbarPaintTimerFired(Timer<ScrollAnimatorMac>&)
+void ScrollAnimatorMac::initialScrollbarPaintTimerFired(Timer&)
 {
     // To force the scrollbars to flash, we have to call hide first. Otherwise, the ScrollbarPainterController
     // might think that the scrollbars are already showing and bail early.
@@ -1362,7 +1362,7 @@ void ScrollAnimatorMac::sendContentAreaScrolled(const FloatSize& delta)
         [m_scrollbarPainterController contentAreaScrolled];
 }
 
-void ScrollAnimatorMac::sendContentAreaScrolledTimerFired(Timer<ScrollAnimatorMac>&)
+void ScrollAnimatorMac::sendContentAreaScrolledTimerFired(Timer&)
 {
     sendContentAreaScrolled(m_contentAreaScrolledTimerScrollDelta);
     m_contentAreaScrolledTimerScrollDelta = FloatSize();
index ecc4b13fd0234435fc81652a08943c8969f14013..28d8ee460dc5a46160e5da3135b5126b47d54545 100644 (file)
@@ -62,7 +62,7 @@ void DeviceMotionClientMock::setMotion(PassRefPtr<DeviceMotionData> motion)
         m_timer.startOneShot(0);
 }
 
-void DeviceMotionClientMock::timerFired(Timer<DeviceMotionClientMock>* timer)
+void DeviceMotionClientMock::timerFired(Timer* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_timer);
     m_timer.stop();
index f2e0a981ab496da5d46a217c5bbf5ebfe2e371dd..f218963f0e50399c62dab831a4a24fb448aa1fd9 100644 (file)
@@ -55,11 +55,11 @@ public:
     void setMotion(PassRefPtr<DeviceMotionData>);
 
 private:
-    void timerFired(Timer<DeviceMotionClientMock>*);
+    void timerFired(Timer*);
 
     RefPtr<DeviceMotionData> m_motion;
     DeviceMotionController* m_controller;
-    Timer<DeviceMotionClientMock> m_timer;
+    Timer m_timer;
     bool m_isUpdating;
 };
 
index 9716a7e6aa7de87a41aba1e0b5754f13ce3dcbe1..3a7a1e720db807dff7b67dc9b387175940dfd6ca 100644 (file)
@@ -62,7 +62,7 @@ void DeviceOrientationClientMock::setOrientation(PassRefPtr<DeviceOrientationDat
         m_timer.startOneShot(0);
 }
 
-void DeviceOrientationClientMock::timerFired(Timer<DeviceOrientationClientMock>& timer)
+void DeviceOrientationClientMock::timerFired(Timer& timer)
 {
     ASSERT_UNUSED(timer, &timer == &m_timer);
     m_timer.stop();
index 8450299dc6e35d5c00be6f31a5dcfd925141fb1e..6948b925a372aa850b5d6716172b940149a6cac3 100644 (file)
@@ -54,11 +54,11 @@ public:
     WEBCORE_EXPORT void setOrientation(PassRefPtr<DeviceOrientationData>);
 
 private:
-    void timerFired(Timer<DeviceOrientationClientMock>&);
+    void timerFired(Timer&);
 
     RefPtr<DeviceOrientationData> m_orientation;
     DeviceOrientationController* m_controller;
-    Timer<DeviceOrientationClientMock> m_timer;
+    Timer m_timer;
     bool m_isUpdating;
 };
 
index 9901b66aa7a9db2bcc9045915be141e27b8a5dd7..05325a7d9ef6c119f659c271d5e4537b7ef0e33d 100644 (file)
@@ -109,7 +109,7 @@ void GeolocationClientMock::asyncUpdatePermission()
         m_permissionTimer.startOneShot(0);
 }
 
-void GeolocationClientMock::permissionTimerFired(WebCore::Timer<GeolocationClientMock>* timer)
+void GeolocationClientMock::permissionTimerFired(WebCore::Timer* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_permissionTimer);
     ASSERT(m_permissionState != PermissionStateUnset);
@@ -169,7 +169,7 @@ void GeolocationClientMock::asyncUpdateController()
         m_controllerTimer.startOneShot(0);
 }
 
-void GeolocationClientMock::controllerTimerFired(Timer<GeolocationClientMock>* timer)
+void GeolocationClientMock::controllerTimerFired(Timer* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_controllerTimer);
     ASSERT(m_controller);
index f380c144347973db512c0fe24580dbfaedffc50a..558767bcb5883eeb32a7273af05b1628367135ac 100644 (file)
@@ -70,10 +70,10 @@ public:
 
 private:
     void asyncUpdateController();
-    void controllerTimerFired(Timer<GeolocationClientMock>*);
+    void controllerTimerFired(Timer*);
 
     void asyncUpdatePermission();
-    void permissionTimerFired(Timer<GeolocationClientMock>*);
+    void permissionTimerFired(Timer*);
 
     void clearError();
 
@@ -81,8 +81,8 @@ private:
     RefPtr<GeolocationPosition> m_lastPosition;
     bool m_hasError;
     String m_errorMessage;
-    Timer<GeolocationClientMock> m_controllerTimer;
-    Timer<GeolocationClientMock> m_permissionTimer;
+    Timer m_controllerTimer;
+    Timer m_permissionTimer;
     bool m_isActive;
 
     enum PermissionState {
index 430868e95010b33b2d54fd678d420af5ae3a4f65..eecba7746a63eb5fe9d2517c72f287c2a0f7fdac 100644 (file)
@@ -41,7 +41,7 @@ PlatformSpeechSynthesizerMock::~PlatformSpeechSynthesizerMock()
 {
 }
 
-void PlatformSpeechSynthesizerMock::speakingFinished(Timer<PlatformSpeechSynthesizerMock>*)
+void PlatformSpeechSynthesizerMock::speakingFinished(Timer*)
 {
     ASSERT(m_utterance.get());
     RefPtr<PlatformSpeechSynthesisUtterance> protect(m_utterance);
index afb2b40e7a66d2c316b05208be3b322c546b624d..82940a8eccc0d75b0ef1a56cee0defd490024675 100644 (file)
@@ -45,9 +45,9 @@ public:
     
 private:
     virtual void initializeVoiceList();
-    void speakingFinished(Timer<PlatformSpeechSynthesizerMock>*);
+    void speakingFinished(Timer*);
     
-    Timer<PlatformSpeechSynthesizerMock> m_speakingFinishedTimer;
+    Timer m_speakingFinishedTimer;
     RefPtr<PlatformSpeechSynthesisUtterance> m_utterance;
 };
     
index 9575acfc32bc09362cd6b1ec6ab947099354667a..6553f1adb80db6d574ca60ad2afff25ab92782fb 100644 (file)
@@ -68,7 +68,7 @@ public:
 
     virtual ~TimerEvent() { }
 
-    void timerFired(Timer<TimerEvent>*)
+    void timerFired(Timer*)
     {
         m_notifier->fire();
         m_mock->removeEvent(this);
@@ -76,7 +76,7 @@ public:
 
 private:
     TimerEventBasedMock* m_mock;
-    Timer<TimerEvent> m_timer;
+    Timer m_timer;
     RefPtr<MockNotifier> m_notifier;
 };
 
index d7f5fbbddd74a80a8ccd9ac1f41344c4ebd4a482..6c1032788e9975ba7efb99af4fa05b273a18eab6 100644 (file)
@@ -98,7 +98,7 @@ void DNSResolveQueue::add(const String& hostname)
     }
 }
 
-void DNSResolveQueue::timerFired(Timer<DNSResolveQueue>&)
+void DNSResolveQueue::timerFired(Timer&)
 {
     if (isUsingProxy()) {
         m_names.clear();
index c8c1caf38e846e5a40511e2cc32b8efbe44b787d..ad6f18bfb0b824c0181358c5f1f601d785319d99 100644 (file)
@@ -55,9 +55,9 @@ private:
     bool platformProxyIsEnabledInSystemPreferences();
     void platformResolve(const String&);
 
-    void timerFired(Timer<DNSResolveQueue>&);
+    void timerFired(Timer&);
 
-    Timer<DNSResolveQueue> m_timer;
+    Timer m_timer;
 
     HashSet<String> m_names;
     std::atomic<int> m_requestsInFlight;
index 6070d0c4641c4533f301ce4e6c5478a3530c4b06..113544bdf1717c750ec009c618f36760abcf99cb 100644 (file)
@@ -73,12 +73,12 @@ private:
     void updateState();
 
 #if PLATFORM(MAC)
-    void networkStateChangeTimerFired(Timer<NetworkStateNotifier>&);
+    void networkStateChangeTimerFired(Timer&);
 
     static void dynamicStoreCallback(SCDynamicStoreRef, CFArrayRef changedKeys, void *info); 
 
     RetainPtr<SCDynamicStoreRef> m_store;
-    Timer<NetworkStateNotifier> m_networkStateChangeTimer;
+    Timer m_networkStateChangeTimer;
 
 #elif PLATFORM(WIN)
     static void CALLBACK addrChangeCallback(void*, BOOLEAN timedOut);
index 01c7f72c221f123d9782a250305ebff21fcbe36d..3ae5200e9d046b31d4aee6dc11c90912522a4327 100644 (file)
@@ -108,7 +108,7 @@ void ResourceHandle::scheduleFailure(FailureType type)
     d->m_failureTimer.startOneShot(0);
 }
 
-void ResourceHandle::failureTimerFired(Timer<ResourceHandle>&)
+void ResourceHandle::failureTimerFired(Timer&)
 {
     if (!client())
         return;
index e22dfd9c996d82fb9f95e36964c7e45b7382c868..607f38d35875d01a8b952860e4bb4214ff759261 100644 (file)
@@ -99,8 +99,7 @@ class ResourceLoadTiming;
 class ResourceRequest;
 class ResourceResponse;
 class SharedBuffer;
-
-template <typename T> class Timer;
+class Timer;
 
 class ResourceHandle : public RefCounted<ResourceHandle>
 #if PLATFORM(COCOA) || USE(CFNETWORK) || USE(CURL) || USE(SOUP)
@@ -183,7 +182,7 @@ public:
 
 #if USE(WININET)
     void setSynchronousInternetHandle(HINTERNET);
-    void fileLoadTimer(Timer<ResourceHandle>*);
+    void fileLoadTimer(Timer*);
     void onRedirect();
     bool onRequestComplete();
     static void CALLBACK internetStatusCallback(HINTERNET, DWORD_PTR, DWORD, LPVOID, DWORD);
@@ -241,7 +240,7 @@ public:
     WEBCORE_EXPORT ResourceRequest& firstRequest();
     const String& lastHTTPMethod() const;
 
-    void failureTimerFired(Timer<ResourceHandle>&);
+    void failureTimerFired(Timer&);
 
     NetworkingContext* context() const;
 
index efc5c7c7e65dfd051d6584cd87881db5236d7760..a83f781418f06e42b66f6f91387dcc2763f7f240 100644 (file)
@@ -162,7 +162,7 @@ namespace WebCore {
         RetainPtr<CFURLStorageSessionRef> m_storageSession;
 #endif
 #if USE(WININET)
-        Timer<ResourceHandle> m_fileLoadTimer;
+        Timer m_fileLoadTimer;
         HINTERNET m_internetHandle;
         HINTERNET m_connectHandle;
         HINTERNET m_requestHandle;
@@ -220,7 +220,7 @@ namespace WebCore {
 
         AuthenticationChallenge m_currentWebChallenge;
         ResourceHandle::FailureType m_scheduledFailureType;
-        Timer<ResourceHandle> m_failureTimer;
+        Timer m_failureTimer;
     };
 
 } // namespace WebCore
index 5d372d10f55f071c062878de00d34ff4d67883e8..9e82e67d1abe0515ceea196ec44e58a629ea0734 100644 (file)
@@ -620,7 +620,7 @@ size_t readCallback(void* ptr, size_t size, size_t nmemb, void* data)
     return sent;
 }
 
-void ResourceHandleManager::downloadTimerCallback(Timer<ResourceHandleManager>* /* timer */)
+void ResourceHandleManager::downloadTimerCallback(Timer* /* timer */)
 {
     startScheduledJobs();
 
index 152fac58b19c8e4a8e7f9e5e0dfc7ea4e49e95c6..54f26d0b818eb524408952044e704038f7bf8e0c 100644 (file)
@@ -76,7 +76,7 @@ public:
 private:
     ResourceHandleManager();
     ~ResourceHandleManager();
-    void downloadTimerCallback(Timer<ResourceHandleManager>*);
+    void downloadTimerCallback(Timer*);
     void removeFromCurl(ResourceHandle*);
     bool removeScheduledJob(ResourceHandle*);
     void startJob(ResourceHandle*);
@@ -87,7 +87,7 @@ private:
 
     void initCookieSession();
 
-    Timer<ResourceHandleManager> m_downloadTimer;
+    Timer m_downloadTimer;
     CURLM* m_curlMultiHandle;
     CURLSH* m_curlShareHandle;
     char* m_cookieJarFileName;
index cef6fea6aee25ddec8f7421b67282786f29fe75e..00538bf32ab12423b424ce2b97eff564964e9772 100644 (file)
@@ -81,7 +81,7 @@ void NetworkStateNotifier::dynamicStoreCallback(SCDynamicStoreRef, CFArrayRef, v
     notifier->m_networkStateChangeTimer.startOneShot(StateChangeTimerInterval);
 }
 
-void NetworkStateNotifier::networkStateChangeTimerFired(Timer<NetworkStateNotifier>&)
+void NetworkStateNotifier::networkStateChangeTimerFired(Timer&)
 {
     bool oldOnLine = m_isOnLine;
     
index a1a6d51952f321ced404c65cd77fdb2fd1b76c16..fe60a55c3b76f3993526701e10b0f28f493d1d76 100644 (file)
@@ -353,7 +353,7 @@ bool ResourceHandle::start()
     return true;
 }
 
-void ResourceHandle::fileLoadTimer(Timer<ResourceHandle>*)
+void ResourceHandle::fileLoadTimer(Timer*)
 {
     RefPtr<ResourceHandle> protector(this);
     deref(); // balances ref in start
index 1ec112d6c7a5d8a581391b95870539953f4b8735..48decaf4f20185e42248739c0fec9b64aaebd7a0 100644 (file)
@@ -63,7 +63,7 @@ void PluginPackage::freeLibrarySoon()
     m_freeLibraryTimer.startOneShot(0);
 }
 
-void PluginPackage::freeLibraryTimerFired(Timer<PluginPackage>*)
+void PluginPackage::freeLibraryTimerFired(Timer*)
 {
     ASSERT(m_module);
     // Do nothing if the module got loaded again meanwhile
index 87fdab5c6e97ea931e31292e49dbfc5d17ff24aa..aefbb1f94b52561c28e98f0320ede5ffdd9dad10 100644 (file)
@@ -120,8 +120,8 @@ namespace WebCore {
 #endif
 
         void freeLibrarySoon();
-        void freeLibraryTimerFired(Timer<PluginPackage>*);
-        Timer<PluginPackage> m_freeLibraryTimer;
+        void freeLibraryTimerFired(Timer*);
+        Timer m_freeLibraryTimer;
 
         PluginQuirkSet m_quirks;
 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
index 3000c9cee7040a8709487521ce71180ed1364496..c5b4251bb4de575dba6e62fa99ef1d65ea4a4f74 100644 (file)
@@ -321,7 +321,7 @@ void PluginStream::destroyStream()
         deleteFile(m_path);
 }
 
-void PluginStream::delayDeliveryTimerFired(Timer<PluginStream>* timer)
+void PluginStream::delayDeliveryTimerFired(Timer* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_delayDeliveryTimer);
 
index d8fd23f500fa475f30e342a703669e4e792e8b5d..ca1500390c3a3c0d2094e2a14c4d67db3765ed7c 100644 (file)
@@ -100,8 +100,8 @@ namespace WebCore {
         PluginStreamState m_streamState;
         bool m_loadManually;
 
-        Timer<PluginStream> m_delayDeliveryTimer;
-        void delayDeliveryTimerFired(Timer<PluginStream>*);
+        Timer m_delayDeliveryTimer;
+        void delayDeliveryTimerFired(Timer*);
 
         OwnPtr< Vector<char> > m_deliveryData;
 
index dc7e017bb642025b4ee85419951b4ec604683879..6e1372131c829c83e3e26f556921a28f740e53b5 100644 (file)
@@ -115,7 +115,7 @@ static String scriptStringIfJavaScriptURL(const URL& url)
 
 PluginView* PluginView::s_currentPluginView = 0;
 
-void PluginView::popPopupsStateTimerFired(Timer