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: http://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 8dc3fa5..21a1454 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 f5376cf..060d77e 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 f0269d4..9c311ad 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 7d84811..81d6136 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 644dbfb..55623d0 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 379886c..a869e13 100644 (file)
@@ -270,7 +270,7 @@ void IDBTransactionBackend::commit()
     });
 }
 
-void IDBTransactionBackend::taskTimerFired(Timer<IDBTransactionBackend>&)
+void IDBTransactionBackend::taskTimerFired(Timer&)
 {
     LOG(StorageAPI, "IDBTransactionBackend::taskTimerFired");
 
index bb200dd..ba5ea4f 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 67921e3..7659577 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 ab48f93..d36802c 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 559895f..5ac5176 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 2681d26..806fdcc 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 e5adcd6..e242c40 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 0e6b49d..bed2a62 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 de78474..4233fd4 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 54a21d4..6f8038e 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 3519c3d..247b62f 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 ba8e7ae..aabfcdc 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 36ae61f..4e83830 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 a980100..38baa68 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 2a83553..bafb5ca 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 70acc4f..edabb62 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 e09cb30..50b452a 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 cc529a0..20673af 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 932c840..7fd621e 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 715946c..e4fac2b 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 02452d5..d8afb25 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 6f8e685..b4b5c37 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 eb8bc0c..c69156c 100644 (file)
@@ -73,7 +73,7 @@ void GCController::garbageCollectSoon()
 }
 
 #if !USE(CF)
-void GCController::gcTimerFired(Timer<GCController>*)
+void GCController::gcTimerFired(Timer*)
 {
     collect(nullptr);
 }
index 1c2d914..a371510 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 4e3d41e..e80fc29 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 3925aee..1150889 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 e1e5a05..18bf189 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 2cd7ce5..1778771 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 0ea1023..e3bf363 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 ffa0266..d75f755 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 c00e544..719d6cc 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 04fe258..550021a 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 cf6781d..b72f7e7 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 9fc2066..3655890 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 9948963..096e3c5 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 d7e692c..e13df8e 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 626bd4f..78562e7 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 73296e9..002c71e 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 d681106..3a246b4 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 1a6e54e..973613d 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 e8463ab..f12f81a 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 0dab96e..b82e2cc 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 f08efe7..8be1f73 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 13223dd..df4b843 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 3606012..a9dc92c 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 07a23af..ae83212 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 9ca3508..008e328 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 ac90b36..9260076 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 fc3db9d..b4d6866 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 3b10e43..7f32c81 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 086c359..116fdf2 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 2d17e7b..5240e9f 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 f8bc7f9..d7e3675 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 b60085d..6720885 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 3eef4c6..f17ef6e 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 a488ae8..fd19639 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 522d743..11c55a0 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 2c6e97b..7491388 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 526dc03..121b9c3 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 3a77682..4131674 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 3e36c9b..25419cb 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 fac958e..d6569a4 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 03ed81b..43b5f46 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 b2c4592..0bf9dfc 100644 (file)
@@ -173,7 +173,7 @@ void SearchInputType::stopSearchEventTimer()
     m_searchEventTimer.stop();
 }
 
-void SearchInputType::searchEventTimerFired(Timer<SearchInputType>*)
+void SearchInputType::searchEventTimerFired(Timer*)
 {
     element().onSearch();
 }
index 12326bc..883a12b 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 9b8fb39..ab9618d 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 7516843..9d61857 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 b682a7e..0be1d40 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 50ae42c..348befb 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 b931da2..8278110 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 b404ae9..ab7e2ed 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 4c7bd75..fc35832 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 1474aa4..ccb4996 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 7129fe6..787220f 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 6e17e35..a644c8e 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 bbdd01b..9836965 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 1139601..18cfa2d 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 bf9523d..bdc4dfa 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 06e3fea..aad2a08 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 6fb5aad..38a1c6a 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 e162f52..0413385 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 71c8c58..f57ea33 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 496ebb4..3375473 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 9aca7b8..6b97823 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 e14d1fa..1ed1e97 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 4b813f3..8908292 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 977ed14..1f175c7 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 6d0810e..50f04a1 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 b57e67e..ddbce0d 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 7925e4d..1560ca1 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 0f06774..602fb9d 100644 (file)
@@ -374,7 +374,7 @@ void ImageLoader::updatedHasPendingEvent()
     }   
 }
 
-void ImageLoader::timerFired(Timer<ImageLoader>&)
+void ImageLoader::timerFired(Timer&)
 {
     element().deref();
 }
index 5f3724c..83ad8dc 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 e63bbf0..995fc70 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 42b756c..ad4d579 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 21c3804..ac6e08a 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 7db21a7..356f188 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 b3bec06..b7b85ef 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 20d4461..e9e9504 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 4403b4d..8a39a11 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 8a41b87..6d8b9e7 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 4111e79..5b3742f 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 0f27b92..ed0cb75 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 c9886c8..187ffbe 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 ceee58c..1e85f5a 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 bf6e997..bcce274 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 d160849..a70c862 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 7076c86..66a812d 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 67dc0d9..abcb0cb 100644 (file)
@@ -855,7 +855,7 @@ void IconDatabase::scheduleOrDeferSyncTimer()
     });
 }
 
-void IconDatabase::syncTimerFired(Timer<IconDatabase>&)
+void IconDatabase::syncTimerFired(Timer&)
 {
     ASSERT_NOT_SYNC_THREAD();
     wakeSyncThread();
index 91070c8..4e04904 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 29971e9..b1dcff2 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 a009ea5..a060f9a 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 7e9a0ce..9ec05d7 100644 (file)
@@ -52,7 +52,7 @@ CaptionUserPreferences::~CaptionUserPreferences()
 {
 }
 
-void CaptionUserPreferences::timerFired(Timer<CaptionUserPreferences>&)
+void CaptionUserPreferences::timerFired(Timer&)
 {
     captionPreferencesChanged();
 }
index 0d045eb..6f02b57 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 9c5a919..3bb7628 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 71690d5..8b0bbc7 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 a2baa23..6a0e011 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 2abfb79..c46403d 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 e5cad6b..92fe65c 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 37ea75d..9cd857a 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 336e151..635c8ea 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 f2d1c12..a4525f4 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 c2feb7c..7a5f5d4 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 bc48d43..36f1200 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 5ddca42..9c376a9 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 6edda34..be74942 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 c599f1b..248f2a2 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 af980f5..189ff47 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 9e8ac1b..b51d464 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 a3d8285..70febc8 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 e4093a4..b55f967 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 76472f0..5157ad3 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 c890333..8d89916 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 f60f69a..5a454f8 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 1d7c3ad..8aaf912 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 90ae590..0098c76 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 233307d..acd2df2 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 afb002b..3f4d7bc 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 15faa0b..011fe8e 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 f2b7c40..8927e99 100644 (file)
@@ -91,7 +91,7 @@ void ScrollingCoordinatorIOS::scheduleTreeStateCommit()
     m_scrollingStateTreeCommitterTimer.startOneShot(0);
 }
 
-void ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired(Timer<ScrollingCoordinatorIOS>*)
+void ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired(Timer*)
 {
     commitTreeState();
 }
index 7da8780..f71ecc3 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 c6dc396..0bc5199 100644 (file)
@@ -106,7 +106,7 @@ void ScrollingCoordinatorMac::scheduleTreeStateCommit()
     m_scrollingStateTreeCommitterTimer.startOneShot(0);
 }
 
-void ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired(Timer<ScrollingCoordinatorMac>*)
+void ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired(Timer*)
 {
     commitTreeState();
 }
index b882636..ca90834 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 0592660..ea3c397 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 e3a7be3..eb150fc 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 35d8cf4..cef8334 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 b38da16..700f4ee 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 7e8d117..c63fb01 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 69885f5..731de5d 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 863158d..eac883f 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 51fa7dc..d46d6b7 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 b06e067..3241c90 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 1be9e1d..db55d38 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 bb4bb7f..43138ea 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 220b369..48c9ab3 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 a0a0f24..72f71ae 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 7a533d0..81fce9d 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 b1537d7..687d045 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 917ce09..66df6bf 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 2eef413..04490dd 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 9e3040e..5693eb7 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 932ab28..471740d 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 a076a48..b7fde8e 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 077ac2e..f72acc9 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 1c94880..b2b1db2 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 b49bd49..6f4be1d 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 868116f..8bcbe56 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 a3c4d57..f4ca910 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 0a76eed..4ae1a1b 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 f54ff04..a77643b 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 18fb326..56f528d 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 b80a2fe..210a1a8 100644 (file)
@@ -224,7 +224,7 @@ void LegacyCACFLayerTreeHost::resize()
     }
 }
 
-void LegacyCACFLayerTreeHost::renderTimerFired(Timer<LegacyCACFLayerTreeHost>*)
+void LegacyCACFLayerTreeHost::renderTimerFired(Timer*)
 {
     paint();
 }
index 102fcbc..8f616bf 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 a941c93..5285dce 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 80af0d5..ba44116 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 25e5eb6..ba3c7af 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 7720015..056134e 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 ef855e9..5802c72 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 6d41153..959284a 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 53ce4af..7e121a2 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 0da429b..061d96f 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 0bf4540..0cae86f 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 04c908b..99e92b5 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 58fbfc0..07c2817 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 80c4eed..0930e26 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 711e491..d61765f 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 da1b06d..f8759a4 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 6c00142..c3d9932 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 dcb34cc..c491cdd 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 ed76281..ffe75ad 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 012e4a8..b06cdee 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 43f909e..ba7aac3 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 ecc4b13..28d8ee4 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 f2e0a98..f218963 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 9716a7e..3a7a1e7 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 8450299..6948b92 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 9901b66..05325a7 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 f380c14..558767b 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 430868e..eecba77 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 afb2b40..82940a8 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 9575acf..6553f1a 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 d7f5fbb..6c10327 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();