Remove the Timer parameters from timer callbacks

author andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Fri, 21 Nov 2014 20:10:13 +0000 (20:10 +0000)

committer andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Fri, 21 Nov 2014 20:10:13 +0000 (20:10 +0000)
author andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 21 Nov 2014 20:10:13 +0000 (20:10 +0000)
committer andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 21 Nov 2014 20:10:13 +0000 (20:10 +0000)
diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog

index 551a6b6d96938f8bc3b603a13e100d864c1db83e..ed808100a5557f272142106400617dcc6d2c7406 100644 (file)
--- a/Source/WTF/ChangeLog
+++ b/Source/WTF/ChangeLog
@@ -1,3 +1,14 @@
+2014-11-21  Anders Carlsson  <andersca@apple.com>
+
+        Remove the Timer parameters from timer callbacks
+        https://bugs.webkit.org/show_bug.cgi?id=138974
+
+        Reviewed by Antti Koivisto.
+
+        * wtf/RunLoopTimer.h:
+        (WTF::RunLoopTimer::RunLoopTimer):
+        (WTF::RunLoopTimer::fired):
+
  2014-11-18  Chris Dumez  <cdumez@apple.com>
  
          Have Vector::capacity() return an unsigned instead of a size_t
diff --git a/Source/WTF/wtf/RunLoopTimer.h b/Source/WTF/wtf/RunLoopTimer.h

index d8f94b4b33d2cecc7a4bc718a49621a4816019df..3780e76c0313104aec7fd797323eb4104f83e597 100644 (file)
--- a/Source/WTF/wtf/RunLoopTimer.h
+++ b/Source/WTF/wtf/RunLoopTimer.h
@@ -61,14 +61,15 @@ private:
  #endif
  };
  
+// FIXME: This doesn't have to be a class template.
  template <typename TimerFiredClass> class RunLoopTimer : public RunLoopTimerBase {
  public:
-    typedef void (TimerFiredClass::*TimerFiredFunction)(RunLoopTimer*);
+    typedef void (TimerFiredClass::*TimerFiredFunction)();
  
-    RunLoopTimer(TimerFiredClass* o, TimerFiredFunction f)
-        : m_object(o), m_function(f) { }
+    RunLoopTimer(TimerFiredClass& o, TimerFiredFunction f)
+        : m_object(&o), m_function(f) { }
  
-    virtual void fired() { (m_object->*m_function)(this); }
+    virtual void fired() { (m_object->*m_function)(); }
  
  private:
      TimerFiredClass* m_object;
diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog

index 0b9733c6d97fad5a177fe8b8cacb4d059b51bc3b..2c99ca77e19961c6f150e8583dd3ae767c1d124d 100644 (file)
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,995 @@
+2014-11-21  Anders Carlsson  <andersca@apple.com>
+
+        Remove the Timer parameters from timer callbacks
+        https://bugs.webkit.org/show_bug.cgi?id=138974
+
+        Reviewed by Antti Koivisto.
+
+        * Modules/encryptedmedia/MediaKeySession.cpp:
+        (WebCore::MediaKeySession::MediaKeySession):
+        (WebCore::MediaKeySession::keyRequestTimerFired):
+        (WebCore::MediaKeySession::addKeyTimerFired):
+        * Modules/encryptedmedia/MediaKeySession.h:
+        * Modules/geolocation/Geolocation.cpp:
+        (WebCore::Geolocation::GeoNotifier::GeoNotifier):
+        (WebCore::Geolocation::GeoNotifier::timerFired):
+        (WebCore::Geolocation::Geolocation):
+        (WebCore::Geolocation::resumeTimerFired):
+        * Modules/geolocation/Geolocation.h:
+        * Modules/indexeddb/IDBTransactionBackend.cpp:
+        (WebCore::IDBTransactionBackend::IDBTransactionBackend):
+        (WebCore::IDBTransactionBackend::taskTimerFired):
+        * Modules/indexeddb/IDBTransactionBackend.h:
+        * Modules/mediasource/SourceBuffer.cpp:
+        (WebCore::SourceBuffer::SourceBuffer):
+        (WebCore::SourceBuffer::appendBufferTimerFired):
+        (WebCore::SourceBuffer::removeTimerFired):
+        * Modules/mediasource/SourceBuffer.h:
+        * Modules/mediastream/MediaStream.cpp:
+        (WebCore::MediaStream::MediaStream):
+        (WebCore::MediaStream::scheduledEventTimerFired):
+        * Modules/mediastream/MediaStream.h:
+        * Modules/mediastream/RTCDTMFSender.cpp:
+        (WebCore::RTCDTMFSender::RTCDTMFSender):
+        (WebCore::RTCDTMFSender::scheduledEventTimerFired):
+        * Modules/mediastream/RTCDTMFSender.h:
+        * Modules/mediastream/RTCDataChannel.cpp:
+        (WebCore::RTCDataChannel::RTCDataChannel):
+        (WebCore::RTCDataChannel::scheduledEventTimerFired):
+        * Modules/mediastream/RTCDataChannel.h:
+        * Modules/mediastream/RTCPeerConnection.cpp:
+        (WebCore::RTCPeerConnection::RTCPeerConnection):
+        (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::NotificationRequestCallback):
+        (WebCore::NotificationCenter::NotificationRequestCallback::timerFired):
+        * Modules/notifications/NotificationCenter.h:
+        * Modules/websockets/WebSocketChannel.cpp:
+        (WebCore::WebSocketChannel::WebSocketChannel):
+        (WebCore::WebSocketChannel::resumeTimerFired):
+        (WebCore::WebSocketChannel::closingTimerFired):
+        * Modules/websockets/WebSocketChannel.h:
+        * accessibility/AXObjectCache.cpp:
+        (WebCore::AXObjectCache::AXObjectCache):
+        (WebCore::AXObjectCache::notificationPostTimerFired):
+        * accessibility/AXObjectCache.h:
+        * bindings/js/GCController.cpp:
+        (WebCore::GCController::GCController):
+        (WebCore::GCController::gcTimerFired):
+        * bindings/js/GCController.h:
+        * css/CSSFontFaceSource.h:
+        * css/CSSFontSelector.cpp:
+        (WebCore::CSSFontSelector::CSSFontSelector):
+        (WebCore::CSSFontSelector::beginLoadTimerFired):
+        * css/CSSFontSelector.h:
+        * css/CSSImageGeneratorValue.cpp:
+        (WebCore::CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage):
+        * css/StyleResolver.cpp:
+        (WebCore::StyleResolver::StyleResolver):
+        (WebCore::StyleResolver::sweepMatchedPropertiesCache):
+        * css/StyleResolver.h:
+        * dom/Document.cpp:
+        (WebCore::Document::Document):
+        (WebCore::Document::visualUpdatesSuppressionTimerFired):
+        (WebCore::Document::styleRecalcTimerFired):
+        (WebCore::Document::optimizedStyleSheetUpdateTimerFired):
+        (WebCore::Document::sharedObjectPoolClearTimerFired):
+        (WebCore::Document::updateFocusAppearanceTimerFired):
+        (WebCore::Document::pendingTasksTimerFired):
+        (WebCore::Document::webkitWillEnterFullScreenForElement):
+        (WebCore::Document::webkitDidExitFullScreenForElement):
+        (WebCore::Document::fullScreenChangeDelayTimerFired):
+        (WebCore::Document::loadEventDelayTimerFired):
+        (WebCore::Document::didAssociateFormControlsTimerFired):
+        (WebCore::Document::domCookieCacheExpiryTimerFired):
+        * dom/Document.h:
+        * dom/EventSender.h:
+        (WebCore::EventSender::timerFired):
+        (WebCore::EventSender<T>::EventSender):
+        * dom/ScriptRunner.cpp:
+        (WebCore::ScriptRunner::ScriptRunner):
+        (WebCore::ScriptRunner::timerFired):
+        * dom/ScriptRunner.h:
+        * dom/ScriptedAnimationController.cpp:
+        (WebCore::ScriptedAnimationController::ScriptedAnimationController):
+        (WebCore::ScriptedAnimationController::animationTimerFired):
+        * dom/ScriptedAnimationController.h:
+        * dom/StyledElement.cpp:
+        (WebCore::PresentationAttributeCacheCleaner::PresentationAttributeCacheCleaner):
+        (WebCore::PresentationAttributeCacheCleaner::cleanCache):
+        * editing/AlternativeTextController.cpp:
+        (WebCore::AlternativeTextController::AlternativeTextController):
+        (WebCore::AlternativeTextController::timerFired):
+        * editing/AlternativeTextController.h:
+        * editing/Editor.cpp:
+        (WebCore::Editor::Editor):
+        (WebCore::Editor::updateEditorUINowIfScheduled):
+        (WebCore::Editor::editorUIUpdateTimerFired):
+        (WebCore::Editor::scanSelectionForTelephoneNumbers): Deleted.
+        * editing/Editor.h:
+        * editing/FrameSelection.cpp:
+        (WebCore::FrameSelection::FrameSelection):
+        (WebCore::FrameSelection::caretBlinkTimerFired):
+        * editing/FrameSelection.h:
+        * editing/SpellChecker.cpp:
+        (WebCore::SpellChecker::SpellChecker):
+        (WebCore::SpellChecker::timerFiredToProcessQueuedRequest):
+        * editing/SpellChecker.h:
+        * html/HTMLFormElement.cpp:
+        (WebCore::HTMLFormElement::HTMLFormElement):
+        (WebCore::HTMLFormElement::requestAutocompleteTimerFired):
+        * html/HTMLFormElement.h:
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::HTMLMediaElement):
+        (WebCore::HTMLMediaElement::parseAttribute):
+        * html/HTMLMediaElement.h:
+        * html/HTMLPlugInElement.cpp:
+        (WebCore::HTMLPlugInElement::HTMLPlugInElement):
+        (WebCore::HTMLPlugInElement::swapRendererTimerFired):
+        * html/HTMLPlugInElement.h:
+        * html/HTMLPlugInImageElement.cpp:
+        (WebCore::HTMLPlugInImageElement::HTMLPlugInImageElement):
+        (WebCore::HTMLPlugInImageElement::removeSnapshotTimerFired):
+        * html/HTMLPlugInImageElement.h:
+        * html/HTMLSourceElement.cpp:
+        (WebCore::HTMLSourceElement::HTMLSourceElement):
+        (WebCore::HTMLSourceElement::errorEventTimerFired):
+        * html/HTMLSourceElement.h:
+        * html/HTMLTrackElement.cpp:
+        (WebCore::HTMLTrackElement::HTMLTrackElement):
+        (WebCore::HTMLTrackElement::loadTimerFired):
+        * html/HTMLTrackElement.h:
+        * html/MediaController.cpp:
+        (MediaController::MediaController):
+        (MediaController::asyncEventTimerFired):
+        (MediaController::clearPositionTimerFired):
+        (MediaController::timeupdateTimerFired):
+        * html/MediaController.h:
+        * html/MediaDocument.cpp:
+        (WebCore::MediaDocument::MediaDocument):
+        (WebCore::MediaDocument::replaceMediaElementTimerFired):
+        * html/MediaDocument.h:
+        * html/SearchInputType.cpp:
+        (WebCore::SearchInputType::SearchInputType):
+        (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::WebGLRenderingContext):
+        (WebCore::WebGLRenderingContext::dispatchContextLostEvent):
+        (WebCore::WebGLRenderingContext::maybeRestoreContext):
+        * html/canvas/WebGLRenderingContext.h:
+        * html/parser/HTMLParserScheduler.cpp:
+        (WebCore::HTMLParserScheduler::HTMLParserScheduler):
+        (WebCore::HTMLParserScheduler::continueNextChunkTimerFired):
+        * html/parser/HTMLParserScheduler.h:
+        * html/shadow/MediaControlElements.cpp:
+        (WebCore::MediaControlPanelElement::MediaControlPanelElement):
+        (WebCore::MediaControlPanelElement::transitionTimerFired):
+        (WebCore::MediaControlTextTrackContainerElement::MediaControlTextTrackContainerElement):
+        (WebCore::MediaControlTextTrackContainerElement::updateTimerFired):
+        * html/shadow/MediaControlElements.h:
+        * html/shadow/MediaControls.cpp:
+        (WebCore::MediaControls::MediaControls):
+        (WebCore::MediaControls::hideFullscreenControlsTimerFired):
+        * html/shadow/MediaControls.h:
+        * html/shadow/SpinButtonElement.cpp:
+        (WebCore::SpinButtonElement::SpinButtonElement):
+        (WebCore::SpinButtonElement::repeatingTimerFired):
+        * html/shadow/SpinButtonElement.h:
+        * html/track/LoadableTextTrack.cpp:
+        (WebCore::LoadableTextTrack::LoadableTextTrack):
+        (WebCore::LoadableTextTrack::loadTimerFired):
+        * html/track/LoadableTextTrack.h:
+        * html/track/VTTRegion.cpp:
+        (WebCore::VTTRegion::VTTRegion):
+        (WebCore::VTTRegion::scrollTimerFired):
+        * html/track/VTTRegion.h:
+        * inspector/InspectorCSSAgent.cpp:
+        (WebCore::ChangeRegionOversetTask::ChangeRegionOversetTask):
+        (WebCore::ChangeRegionOversetTask::timerFired):
+        * inspector/InspectorDOMAgent.cpp:
+        (WebCore::RevalidateStyleAttributeTask::RevalidateStyleAttributeTask):
+        (WebCore::RevalidateStyleAttributeTask::timerFired):
+        * inspector/InspectorFrontendClientLocal.cpp:
+        (WebCore::InspectorBackendDispatchTask::InspectorBackendDispatchTask):
+        (WebCore::InspectorBackendDispatchTask::timerFired):
+        * inspector/InspectorOverlay.cpp:
+        (WebCore::InspectorOverlay::InspectorOverlay):
+        (WebCore::InspectorOverlay::updatePaintRectsTimerFired):
+        * inspector/InspectorOverlay.h:
+        * loader/DocumentLoader.cpp:
+        (WebCore::DocumentLoader::DocumentLoader):
+        (WebCore::DocumentLoader::handleSubstituteDataLoadNow):
+        (WebCore::DocumentLoader::handleSubstituteDataLoadSoon):
+        (WebCore::DocumentLoader::substituteResourceDeliveryTimerFired):
+        * loader/DocumentLoader.h:
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::FrameLoader):
+        (WebCore::FrameLoader::checkTimerFired):
+        * loader/FrameLoader.h:
+        * loader/ImageLoader.cpp:
+        (WebCore::ImageLoader::ImageLoader):
+        (WebCore::ImageLoader::timerFired):
+        * loader/ImageLoader.h:
+        * loader/LinkLoader.cpp:
+        (WebCore::LinkLoader::LinkLoader):
+        (WebCore::LinkLoader::linkLoadTimerFired):
+        (WebCore::LinkLoader::linkLoadingErrorTimerFired):
+        * loader/LinkLoader.h:
+        * loader/NavigationScheduler.cpp:
+        (WebCore::NavigationScheduler::NavigationScheduler):
+        (WebCore::NavigationScheduler::timerFired):
+        * loader/NavigationScheduler.h:
+        * loader/PingLoader.cpp:
+        (WebCore::PingLoader::PingLoader):
+        * loader/PingLoader.h:
+        (WebCore::PingLoader::timeoutTimerFired):
+        * loader/ProgressTracker.cpp:
+        (WebCore::ProgressTracker::ProgressTracker):
+        (WebCore::ProgressTracker::progressHeartbeatTimerFired):
+        * loader/ProgressTracker.h:
+        * loader/ResourceLoadScheduler.cpp:
+        (WebCore::ResourceLoadScheduler::ResourceLoadScheduler):
+        (WebCore::ResourceLoadScheduler::requestTimerFired):
+        * loader/ResourceLoadScheduler.h:
+        * loader/TextTrackLoader.cpp:
+        (WebCore::TextTrackLoader::TextTrackLoader):
+        (WebCore::TextTrackLoader::cueLoadTimerFired):
+        * loader/TextTrackLoader.h:
+        * loader/cache/CachedResource.cpp:
+        (WebCore::CachedResource::CachedResource):
+        (WebCore::CachedResource::Callback::Callback):
+        (WebCore::CachedResource::Callback::timerFired):
+        * loader/cache/CachedResource.h:
+        * loader/cache/CachedResourceLoader.cpp:
+        (WebCore::CachedResourceLoader::CachedResourceLoader):
+        (WebCore::CachedResourceLoader::garbageCollectDocumentResourcesTimerFired):
+        * loader/cache/CachedResourceLoader.h:
+        * loader/icon/IconDatabase.cpp:
+        (WebCore::IconDatabase::IconDatabase):
+        (WebCore::IconDatabase::syncTimerFired):
+        * loader/icon/IconDatabase.h:
+        * page/AutoscrollController.cpp:
+        (WebCore::AutoscrollController::AutoscrollController):
+        (WebCore::AutoscrollController::autoscrollTimerFired):
+        * page/AutoscrollController.h:
+        * page/CaptionUserPreferences.cpp:
+        (WebCore::CaptionUserPreferences::CaptionUserPreferences):
+        (WebCore::CaptionUserPreferences::timerFired):
+        * page/CaptionUserPreferences.h:
+        * page/CaptionUserPreferencesMediaAF.cpp:
+        (WebCore::CaptionUserPreferencesMediaAF::CaptionUserPreferencesMediaAF):
+        (WebCore::CaptionUserPreferencesMediaAF::updateTimerFired):
+        * page/CaptionUserPreferencesMediaAF.h:
+        * page/DeviceController.cpp:
+        (WebCore::DeviceController::DeviceController):
+        (WebCore::DeviceController::fireDeviceEvent):
+        * page/DeviceController.h:
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::EventHandler):
+        (WebCore::EventHandler::cursorUpdateTimerFired):
+        (WebCore::EventHandler::autoHideCursorTimerFired):
+        (WebCore::EventHandler::recognizeLongMousePress):
+        (WebCore::EventHandler::fakeMouseMoveEventTimerFired):
+        (WebCore::EventHandler::hoverTimerFired):
+        * page/EventHandler.h:
+        * page/EventSource.cpp:
+        (WebCore::EventSource::EventSource):
+        (WebCore::EventSource::connectTimerFired):
+        * page/EventSource.h:
+        * page/FocusController.cpp:
+        (WebCore::FocusController::FocusController):
+        (WebCore::FocusController::focusRepaintTimerFired):
+        * page/FocusController.h:
+        * page/Frame.cpp:
+        (WebCore::Frame::Frame):
+        (WebCore::Frame::overflowAutoScrollTimerFired):
+        * page/Frame.h:
+        * page/FrameView.cpp:
+        (WebCore::FrameView::FrameView):
+        (WebCore::FrameView::delayedScrollEventTimerFired):
+        (WebCore::FrameView::speculativeTilingEnableTimerFired):
+        (WebCore::FrameView::layoutTimerFired):
+        (WebCore::FrameView::updateEmbeddedObjectsTimerFired):
+        (WebCore::FrameView::flushAnyPendingPostLayoutTasks):
+        (WebCore::FrameView::postLayoutTimerFired):
+        * page/FrameView.h:
+        * page/PageOverlay.cpp:
+        (WebCore::PageOverlay::PageOverlay):
+        (WebCore::PageOverlay::fadeAnimationTimerFired):
+        * page/PageOverlay.h:
+        * page/Settings.cpp:
+        (WebCore::Settings::Settings):
+        (WebCore::Settings::imageLoadingSettingsTimerFired):
+        * page/Settings.h:
+        * page/animation/AnimationController.cpp:
+        (WebCore::AnimationControllerPrivate::AnimationControllerPrivate):
+        (WebCore::AnimationControllerPrivate::updateStyleIfNeededDispatcherFired):
+        (WebCore::AnimationControllerPrivate::animationTimerFired):
+        * page/animation/AnimationControllerPrivate.h:
+        * page/mac/ServicesOverlayController.h:
+        * page/mac/ServicesOverlayController.mm:
+        (WebCore::ServicesOverlayController::ServicesOverlayController):
+        (WebCore::ServicesOverlayController::determineActiveHighlightTimerFired):
+        * page/scrolling/AsyncScrollingCoordinator.cpp:
+        (WebCore::AsyncScrollingCoordinator::AsyncScrollingCoordinator):
+        (WebCore::AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired):
+        * page/scrolling/AsyncScrollingCoordinator.h:
+        * page/scrolling/ios/ScrollingCoordinatorIOS.h:
+        * page/scrolling/ios/ScrollingCoordinatorIOS.mm:
+        (WebCore::ScrollingCoordinatorIOS::ScrollingCoordinatorIOS):
+        (WebCore::ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired):
+        * page/scrolling/mac/ScrollingCoordinatorMac.h:
+        * page/scrolling/mac/ScrollingCoordinatorMac.mm:
+        (WebCore::ScrollingCoordinatorMac::ScrollingCoordinatorMac):
+        (WebCore::ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired):
+        * platform/HysteresisActivity.h:
+        (WebCore::HysteresisActivity::HysteresisActivity):
+        (WebCore::HysteresisActivity::hysteresisTimerFired):
+        * platform/ScrollAnimator.cpp:
+        (WebCore::ScrollAnimator::updateScrollAnimatorsAndTimers):
+        (WebCore::ScrollAnimator::horizontalScrollSnapTimerFired):
+        (WebCore::ScrollAnimator::verticalScrollSnapTimerFired):
+        * platform/ScrollAnimator.h:
+        * platform/Scrollbar.cpp:
+        (WebCore::Scrollbar::Scrollbar):
+        (WebCore::Scrollbar::autoscrollTimerFired):
+        * platform/Scrollbar.h:
+        * platform/Timer.h:
+        (WebCore::DeferrableOneShotTimer::DeferrableOneShotTimer):
+        (WebCore::Timer::Timer): Deleted.
+        * platform/audio/MediaSession.cpp:
+        (WebCore::MediaSession::MediaSession):
+        (WebCore::MediaSession::clientDataBufferingTimerFired):
+        * platform/audio/MediaSession.h:
+        * platform/graphics/BitmapImage.cpp:
+        (WebCore::BitmapImage::startAnimation):
+        (WebCore::BitmapImage::advanceAnimation):
+        * platform/graphics/BitmapImage.h:
+        * platform/graphics/MediaPlayer.cpp:
+        (WebCore::MediaPlayer::MediaPlayer):
+        (WebCore::MediaPlayer::reloadTimerFired):
+        * platform/graphics/MediaPlayer.h:
+        * platform/graphics/ShadowBlur.cpp:
+        (WebCore::ScratchBuffer::ScratchBuffer):
+        (WebCore::ScratchBuffer::timerFired):
+        * platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h:
+        * platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm:
+        (WebCore::MediaSelectionGroupAVFObjC::MediaSelectionGroupAVFObjC):
+        (WebCore::MediaSelectionGroupAVFObjC::selectionTimerFired):
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
+        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::MediaPlayerPrivateMediaSourceAVFObjC):
+        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired):
+        * platform/graphics/ca/LayerPool.cpp:
+        (WebCore::LayerPool::LayerPool):
+        (WebCore::LayerPool::pruneTimerFired):
+        * platform/graphics/ca/LayerPool.h:
+        * platform/graphics/ca/TileController.cpp:
+        (WebCore::TileController::TileController):
+        (WebCore::TileController::tileRevalidationTimerFired):
+        * platform/graphics/ca/TileController.h:
+        * platform/graphics/ca/TileGrid.cpp:
+        (WebCore::TileGrid::TileGrid):
+        (WebCore::TileGrid::cohortRemovalTimerFired):
+        * platform/graphics/ca/TileGrid.h:
+        * platform/graphics/cg/IOSurfacePool.cpp:
+        (WebCore::IOSurfacePool::IOSurfacePool):
+        (WebCore::IOSurfacePool::collectionTimerFired):
+        * platform/graphics/cg/IOSurfacePool.h:
+        * platform/graphics/cg/SubimageCacheWithTimer.cpp:
+        (WebCore::SubimageCacheWithTimer::SubimageCacheWithTimer):
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.h:
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
+        (WebCore::MediaPlayerPrivateQTKit::MediaPlayerPrivateQTKit):
+        (WebCore::MediaPlayerPrivateQTKit::seekTimerFired):
+        * platform/ios/LegacyTileCache.h:
+        * platform/ios/LegacyTileCache.mm:
+        (WebCore::LegacyTileCache::LegacyTileCache):
+        (WebCore::LegacyTileCache::tileCreationTimerFired):
+        * platform/mac/HIDGamepadProvider.cpp:
+        (WebCore::HIDGamepadProvider::HIDGamepadProvider):
+        (WebCore::HIDGamepadProvider::connectionDelayTimerFired):
+        (WebCore::HIDGamepadProvider::inputNotificationTimerFired):
+        * platform/mac/HIDGamepadProvider.h:
+        * platform/mac/ScrollAnimatorMac.h:
+        * platform/mac/ScrollAnimatorMac.mm:
+        (WebCore::ScrollAnimatorMac::ScrollAnimatorMac):
+        (WebCore::ScrollAnimatorMac::snapRubberBandTimerFired):
+        (WebCore::ScrollAnimatorMac::initialScrollbarPaintTimerFired):
+        (WebCore::ScrollAnimatorMac::sendContentAreaScrolledTimerFired):
+        * platform/mock/DeviceOrientationClientMock.cpp:
+        (WebCore::DeviceOrientationClientMock::DeviceOrientationClientMock):
+        (WebCore::DeviceOrientationClientMock::timerFired):
+        * platform/mock/DeviceOrientationClientMock.h:
+        * platform/mock/PlatformSpeechSynthesizerMock.cpp:
+        (WebCore::PlatformSpeechSynthesizerMock::PlatformSpeechSynthesizerMock):
+        (WebCore::PlatformSpeechSynthesizerMock::speakingFinished):
+        * platform/mock/PlatformSpeechSynthesizerMock.h:
+        * platform/network/DNSResolveQueue.cpp:
+        (WebCore::DNSResolveQueue::DNSResolveQueue):
+        (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:
+        (WebCore::ResourceHandleInternal::ResourceHandleInternal):
+        * platform/network/mac/NetworkStateNotifierMac.cpp:
+        (WebCore::NetworkStateNotifier::networkStateChangeTimerFired):
+        (WebCore::NetworkStateNotifier::NetworkStateNotifier):
+        * rendering/ImageQualityController.cpp:
+        (WebCore::ImageQualityController::ImageQualityController):
+        (WebCore::ImageQualityController::highQualityRepaintTimerFired):
+        * rendering/ImageQualityController.h:
+        * rendering/RenderButton.cpp:
+        (WebCore::RenderButton::styleDidChange):
+        (WebCore::RenderButton::timerFired):
+        * rendering/RenderButton.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::RenderLayerCompositor):
+        (WebCore::RenderLayerCompositor::updateCompositingLayersTimerFired):
+        (WebCore::RenderLayerCompositor::layerFlushTimerFired):
+        (WebCore::RenderLayerCompositor::paintRelatedMilestonesTimerFired):
+        * rendering/RenderLayerCompositor.h:
+        * rendering/RenderMarquee.cpp:
+        (WebCore::RenderMarquee::RenderMarquee):
+        (WebCore::RenderMarquee::timerFired):
+        * rendering/RenderMarquee.h:
+        * rendering/RenderNamedFlowThread.cpp:
+        (WebCore::RenderNamedFlowThread::RenderNamedFlowThread):
+        (WebCore::RenderNamedFlowThread::regionOversetChangeEventTimerFired):
+        * rendering/RenderNamedFlowThread.h:
+        * rendering/RenderProgress.cpp:
+        (WebCore::RenderProgress::RenderProgress):
+        (WebCore::RenderProgress::animationTimerFired):
+        * rendering/RenderProgress.h:
+        * rendering/RenderView.cpp:
+        (WebCore::RenderView::RenderView):
+        (WebCore::RenderView::lazyRepaintTimerFired):
+        * rendering/RenderView.h:
+        * replay/EventLoopInputDispatcher.cpp:
+        (WebCore::EventLoopInputDispatcher::EventLoopInputDispatcher):
+        (WebCore::EventLoopInputDispatcher::timerFired):
+        * replay/EventLoopInputDispatcher.h:
+        * storage/StorageAreaImpl.cpp:
+        (WebCore::StorageAreaImpl::StorageAreaImpl):
+        (WebCore::StorageAreaImpl::closeDatabaseTimerFired):
+        (WebCore::StorageAreaImpl::closeDatabaseIfIdle):
+        * storage/StorageAreaImpl.h:
+        * storage/StorageAreaSync.cpp:
+        (WebCore::StorageAreaSync::StorageAreaSync):
+        (WebCore::StorageAreaSync::scheduleFinalSync):
+        (WebCore::StorageAreaSync::syncTimerFired):
+        (WebCore::StorageAreaSync::scheduleSync):
+        * storage/StorageAreaSync.h:
+        * svg/SVGElement.cpp:
+        (WebCore::SVGElement::svgLoadEventTimerFired):
+        * svg/SVGElement.h:
+        * svg/SVGScriptElement.cpp:
+        (WebCore::SVGScriptElement::SVGScriptElement):
+        * svg/SVGStyleElement.cpp:
+        (WebCore::SVGStyleElement::SVGStyleElement):
+        * svg/SVGUseElement.cpp:
+        (WebCore::SVGUseElement::SVGUseElement):
+        * svg/animation/SMILTimeContainer.cpp:
+        (WebCore::SMILTimeContainer::SMILTimeContainer):
+        (WebCore::SMILTimeContainer::timerFired):
+        * svg/animation/SMILTimeContainer.h:
+        * xml/XMLHttpRequestProgressEventThrottle.cpp:
+        (WebCore::XMLHttpRequestProgressEventThrottle::XMLHttpRequestProgressEventThrottle):
+        (WebCore::XMLHttpRequestProgressEventThrottle::dispatchDeferredEvents):
+        * xml/XMLHttpRequestProgressEventThrottle.h:
+
+2014-11-21  Anders Carlsson  <andersca@apple.com>
+
+        Remove the Timer parameters from timer callbacks
+        https://bugs.webkit.org/show_bug.cgi?id=138974
+
+        Reviewed by Antti Koivisto.
+
+        * Modules/encryptedmedia/MediaKeySession.cpp:
+        (WebCore::MediaKeySession::MediaKeySession):
+        (WebCore::MediaKeySession::keyRequestTimerFired):
+        (WebCore::MediaKeySession::addKeyTimerFired):
+        * Modules/encryptedmedia/MediaKeySession.h:
+        * Modules/geolocation/Geolocation.cpp:
+        (WebCore::Geolocation::GeoNotifier::GeoNotifier):
+        (WebCore::Geolocation::GeoNotifier::timerFired):
+        (WebCore::Geolocation::Geolocation):
+        (WebCore::Geolocation::resumeTimerFired):
+        * Modules/geolocation/Geolocation.h:
+        * Modules/indexeddb/IDBTransactionBackend.cpp:
+        (WebCore::IDBTransactionBackend::IDBTransactionBackend):
+        (WebCore::IDBTransactionBackend::taskTimerFired):
+        * Modules/indexeddb/IDBTransactionBackend.h:
+        * Modules/mediasource/SourceBuffer.cpp:
+        (WebCore::SourceBuffer::SourceBuffer):
+        (WebCore::SourceBuffer::appendBufferTimerFired):
+        (WebCore::SourceBuffer::removeTimerFired):
+        * Modules/mediasource/SourceBuffer.h:
+        * Modules/mediastream/MediaStream.cpp:
+        (WebCore::MediaStream::MediaStream):
+        (WebCore::MediaStream::scheduledEventTimerFired):
+        * Modules/mediastream/MediaStream.h:
+        * Modules/mediastream/RTCDTMFSender.cpp:
+        (WebCore::RTCDTMFSender::RTCDTMFSender):
+        (WebCore::RTCDTMFSender::scheduledEventTimerFired):
+        * Modules/mediastream/RTCDTMFSender.h:
+        * Modules/mediastream/RTCDataChannel.cpp:
+        (WebCore::RTCDataChannel::RTCDataChannel):
+        (WebCore::RTCDataChannel::scheduledEventTimerFired):
+        * Modules/mediastream/RTCDataChannel.h:
+        * Modules/mediastream/RTCPeerConnection.cpp:
+        (WebCore::RTCPeerConnection::RTCPeerConnection):
+        (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::NotificationRequestCallback):
+        (WebCore::NotificationCenter::NotificationRequestCallback::timerFired):
+        * Modules/notifications/NotificationCenter.h:
+        * Modules/websockets/WebSocketChannel.cpp:
+        (WebCore::WebSocketChannel::WebSocketChannel):
+        (WebCore::WebSocketChannel::resumeTimerFired):
+        (WebCore::WebSocketChannel::closingTimerFired):
+        * Modules/websockets/WebSocketChannel.h:
+        * accessibility/AXObjectCache.cpp:
+        (WebCore::AXObjectCache::AXObjectCache):
+        (WebCore::AXObjectCache::notificationPostTimerFired):
+        * accessibility/AXObjectCache.h:
+        * bindings/js/GCController.cpp:
+        (WebCore::GCController::GCController):
+        (WebCore::GCController::gcTimerFired):
+        * bindings/js/GCController.h:
+        * css/CSSFontFaceSource.h:
+        * css/CSSFontSelector.cpp:
+        (WebCore::CSSFontSelector::CSSFontSelector):
+        (WebCore::CSSFontSelector::beginLoadTimerFired):
+        * css/CSSFontSelector.h:
+        * css/CSSImageGeneratorValue.cpp:
+        (WebCore::CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage):
+        * css/StyleResolver.cpp:
+        (WebCore::StyleResolver::StyleResolver):
+        (WebCore::StyleResolver::sweepMatchedPropertiesCache):
+        * css/StyleResolver.h:
+        * dom/Document.cpp:
+        (WebCore::Document::Document):
+        (WebCore::Document::visualUpdatesSuppressionTimerFired):
+        (WebCore::Document::styleRecalcTimerFired):
+        (WebCore::Document::optimizedStyleSheetUpdateTimerFired):
+        (WebCore::Document::sharedObjectPoolClearTimerFired):
+        (WebCore::Document::updateFocusAppearanceTimerFired):
+        (WebCore::Document::pendingTasksTimerFired):
+        (WebCore::Document::webkitWillEnterFullScreenForElement):
+        (WebCore::Document::webkitDidExitFullScreenForElement):
+        (WebCore::Document::fullScreenChangeDelayTimerFired):
+        (WebCore::Document::loadEventDelayTimerFired):
+        (WebCore::Document::didAssociateFormControlsTimerFired):
+        (WebCore::Document::domCookieCacheExpiryTimerFired):
+        * dom/Document.h:
+        * dom/EventSender.h:
+        (WebCore::EventSender::timerFired):
+        (WebCore::EventSender<T>::EventSender):
+        * dom/ScriptRunner.cpp:
+        (WebCore::ScriptRunner::ScriptRunner):
+        (WebCore::ScriptRunner::timerFired):
+        * dom/ScriptRunner.h:
+        * dom/ScriptedAnimationController.cpp:
+        (WebCore::ScriptedAnimationController::ScriptedAnimationController):
+        (WebCore::ScriptedAnimationController::animationTimerFired):
+        * dom/ScriptedAnimationController.h:
+        * dom/StyledElement.cpp:
+        (WebCore::PresentationAttributeCacheCleaner::PresentationAttributeCacheCleaner):
+        (WebCore::PresentationAttributeCacheCleaner::cleanCache):
+        * editing/AlternativeTextController.cpp:
+        (WebCore::AlternativeTextController::AlternativeTextController):
+        (WebCore::AlternativeTextController::timerFired):
+        * editing/AlternativeTextController.h:
+        * editing/Editor.cpp:
+        (WebCore::Editor::Editor):
+        (WebCore::Editor::updateEditorUINowIfScheduled):
+        (WebCore::Editor::editorUIUpdateTimerFired):
+        (WebCore::Editor::scanSelectionForTelephoneNumbers): Deleted.
+        * editing/Editor.h:
+        * editing/FrameSelection.cpp:
+        (WebCore::FrameSelection::FrameSelection):
+        (WebCore::FrameSelection::caretBlinkTimerFired):
+        * editing/FrameSelection.h:
+        * editing/SpellChecker.cpp:
+        (WebCore::SpellChecker::SpellChecker):
+        (WebCore::SpellChecker::timerFiredToProcessQueuedRequest):
+        * editing/SpellChecker.h:
+        * html/HTMLFormElement.cpp:
+        (WebCore::HTMLFormElement::HTMLFormElement):
+        (WebCore::HTMLFormElement::requestAutocompleteTimerFired):
+        * html/HTMLFormElement.h:
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::HTMLMediaElement):
+        (WebCore::HTMLMediaElement::parseAttribute):
+        * html/HTMLMediaElement.h:
+        * html/HTMLPlugInElement.cpp:
+        (WebCore::HTMLPlugInElement::HTMLPlugInElement):
+        (WebCore::HTMLPlugInElement::swapRendererTimerFired):
+        * html/HTMLPlugInElement.h:
+        * html/HTMLPlugInImageElement.cpp:
+        (WebCore::HTMLPlugInImageElement::HTMLPlugInImageElement):
+        (WebCore::HTMLPlugInImageElement::removeSnapshotTimerFired):
+        * html/HTMLPlugInImageElement.h:
+        * html/HTMLSourceElement.cpp:
+        (WebCore::HTMLSourceElement::HTMLSourceElement):
+        (WebCore::HTMLSourceElement::errorEventTimerFired):
+        * html/HTMLSourceElement.h:
+        * html/HTMLTrackElement.cpp:
+        (WebCore::HTMLTrackElement::HTMLTrackElement):
+        (WebCore::HTMLTrackElement::loadTimerFired):
+        * html/HTMLTrackElement.h:
+        * html/MediaController.cpp:
+        (MediaController::MediaController):
+        (MediaController::asyncEventTimerFired):
+        (MediaController::clearPositionTimerFired):
+        (MediaController::timeupdateTimerFired):
+        * html/MediaController.h:
+        * html/MediaDocument.cpp:
+        (WebCore::MediaDocument::MediaDocument):
+        (WebCore::MediaDocument::replaceMediaElementTimerFired):
+        * html/MediaDocument.h:
+        * html/SearchInputType.cpp:
+        (WebCore::SearchInputType::SearchInputType):
+        (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::WebGLRenderingContext):
+        (WebCore::WebGLRenderingContext::dispatchContextLostEvent):
+        (WebCore::WebGLRenderingContext::maybeRestoreContext):
+        * html/canvas/WebGLRenderingContext.h:
+        * html/parser/HTMLParserScheduler.cpp:
+        (WebCore::HTMLParserScheduler::HTMLParserScheduler):
+        (WebCore::HTMLParserScheduler::continueNextChunkTimerFired):
+        * html/parser/HTMLParserScheduler.h:
+        * html/shadow/MediaControlElements.cpp:
+        (WebCore::MediaControlPanelElement::MediaControlPanelElement):
+        (WebCore::MediaControlPanelElement::transitionTimerFired):
+        (WebCore::MediaControlTextTrackContainerElement::MediaControlTextTrackContainerElement):
+        (WebCore::MediaControlTextTrackContainerElement::updateTimerFired):
+        * html/shadow/MediaControlElements.h:
+        * html/shadow/MediaControls.cpp:
+        (WebCore::MediaControls::MediaControls):
+        (WebCore::MediaControls::hideFullscreenControlsTimerFired):
+        * html/shadow/MediaControls.h:
+        * html/shadow/SpinButtonElement.cpp:
+        (WebCore::SpinButtonElement::SpinButtonElement):
+        (WebCore::SpinButtonElement::repeatingTimerFired):
+        * html/shadow/SpinButtonElement.h:
+        * html/track/LoadableTextTrack.cpp:
+        (WebCore::LoadableTextTrack::LoadableTextTrack):
+        (WebCore::LoadableTextTrack::loadTimerFired):
+        * html/track/LoadableTextTrack.h:
+        * html/track/VTTRegion.cpp:
+        (WebCore::VTTRegion::VTTRegion):
+        (WebCore::VTTRegion::scrollTimerFired):
+        * html/track/VTTRegion.h:
+        * inspector/InspectorCSSAgent.cpp:
+        (WebCore::ChangeRegionOversetTask::ChangeRegionOversetTask):
+        (WebCore::ChangeRegionOversetTask::timerFired):
+        * inspector/InspectorDOMAgent.cpp:
+        (WebCore::RevalidateStyleAttributeTask::RevalidateStyleAttributeTask):
+        (WebCore::RevalidateStyleAttributeTask::timerFired):
+        * inspector/InspectorFrontendClientLocal.cpp:
+        (WebCore::InspectorBackendDispatchTask::InspectorBackendDispatchTask):
+        (WebCore::InspectorBackendDispatchTask::timerFired):
+        * inspector/InspectorOverlay.cpp:
+        (WebCore::InspectorOverlay::InspectorOverlay):
+        (WebCore::InspectorOverlay::updatePaintRectsTimerFired):
+        * inspector/InspectorOverlay.h:
+        * loader/DocumentLoader.cpp:
+        (WebCore::DocumentLoader::DocumentLoader):
+        (WebCore::DocumentLoader::handleSubstituteDataLoadNow):
+        (WebCore::DocumentLoader::handleSubstituteDataLoadSoon):
+        (WebCore::DocumentLoader::substituteResourceDeliveryTimerFired):
+        * loader/DocumentLoader.h:
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::FrameLoader):
+        (WebCore::FrameLoader::checkTimerFired):
+        * loader/FrameLoader.h:
+        * loader/ImageLoader.cpp:
+        (WebCore::ImageLoader::ImageLoader):
+        (WebCore::ImageLoader::timerFired):
+        * loader/ImageLoader.h:
+        * loader/LinkLoader.cpp:
+        (WebCore::LinkLoader::LinkLoader):
+        (WebCore::LinkLoader::linkLoadTimerFired):
+        (WebCore::LinkLoader::linkLoadingErrorTimerFired):
+        * loader/LinkLoader.h:
+        * loader/NavigationScheduler.cpp:
+        (WebCore::NavigationScheduler::NavigationScheduler):
+        (WebCore::NavigationScheduler::timerFired):
+        * loader/NavigationScheduler.h:
+        * loader/PingLoader.cpp:
+        (WebCore::PingLoader::PingLoader):
+        * loader/PingLoader.h:
+        (WebCore::PingLoader::timeoutTimerFired):
+        * loader/ProgressTracker.cpp:
+        (WebCore::ProgressTracker::ProgressTracker):
+        (WebCore::ProgressTracker::progressHeartbeatTimerFired):
+        * loader/ProgressTracker.h:
+        * loader/ResourceLoadScheduler.cpp:
+        (WebCore::ResourceLoadScheduler::ResourceLoadScheduler):
+        (WebCore::ResourceLoadScheduler::requestTimerFired):
+        * loader/ResourceLoadScheduler.h:
+        * loader/TextTrackLoader.cpp:
+        (WebCore::TextTrackLoader::TextTrackLoader):
+        (WebCore::TextTrackLoader::cueLoadTimerFired):
+        * loader/TextTrackLoader.h:
+        * loader/cache/CachedResource.cpp:
+        (WebCore::CachedResource::CachedResource):
+        (WebCore::CachedResource::Callback::Callback):
+        (WebCore::CachedResource::Callback::timerFired):
+        * loader/cache/CachedResource.h:
+        * loader/cache/CachedResourceLoader.cpp:
+        (WebCore::CachedResourceLoader::CachedResourceLoader):
+        (WebCore::CachedResourceLoader::garbageCollectDocumentResourcesTimerFired):
+        * loader/cache/CachedResourceLoader.h:
+        * loader/icon/IconDatabase.cpp:
+        (WebCore::IconDatabase::IconDatabase):
+        (WebCore::IconDatabase::syncTimerFired):
+        * loader/icon/IconDatabase.h:
+        * page/AutoscrollController.cpp:
+        (WebCore::AutoscrollController::AutoscrollController):
+        (WebCore::AutoscrollController::autoscrollTimerFired):
+        * page/AutoscrollController.h:
+        * page/CaptionUserPreferences.cpp:
+        (WebCore::CaptionUserPreferences::CaptionUserPreferences):
+        (WebCore::CaptionUserPreferences::timerFired):
+        * page/CaptionUserPreferences.h:
+        * page/CaptionUserPreferencesMediaAF.cpp:
+        (WebCore::CaptionUserPreferencesMediaAF::CaptionUserPreferencesMediaAF):
+        (WebCore::CaptionUserPreferencesMediaAF::updateTimerFired):
+        * page/CaptionUserPreferencesMediaAF.h:
+        * page/DeviceController.cpp:
+        (WebCore::DeviceController::DeviceController):
+        (WebCore::DeviceController::fireDeviceEvent):
+        * page/DeviceController.h:
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::EventHandler):
+        (WebCore::EventHandler::cursorUpdateTimerFired):
+        (WebCore::EventHandler::autoHideCursorTimerFired):
+        (WebCore::EventHandler::recognizeLongMousePress):
+        (WebCore::EventHandler::fakeMouseMoveEventTimerFired):
+        (WebCore::EventHandler::hoverTimerFired):
+        * page/EventHandler.h:
+        * page/EventSource.cpp:
+        (WebCore::EventSource::EventSource):
+        (WebCore::EventSource::connectTimerFired):
+        * page/EventSource.h:
+        * page/FocusController.cpp:
+        (WebCore::FocusController::FocusController):
+        (WebCore::FocusController::focusRepaintTimerFired):
+        * page/FocusController.h:
+        * page/Frame.cpp:
+        (WebCore::Frame::Frame):
+        (WebCore::Frame::overflowAutoScrollTimerFired):
+        * page/Frame.h:
+        * page/FrameView.cpp:
+        (WebCore::FrameView::FrameView):
+        (WebCore::FrameView::delayedScrollEventTimerFired):
+        (WebCore::FrameView::speculativeTilingEnableTimerFired):
+        (WebCore::FrameView::layoutTimerFired):
+        (WebCore::FrameView::updateEmbeddedObjectsTimerFired):
+        (WebCore::FrameView::flushAnyPendingPostLayoutTasks):
+        (WebCore::FrameView::postLayoutTimerFired):
+        * page/FrameView.h:
+        * page/PageOverlay.cpp:
+        (WebCore::PageOverlay::PageOverlay):
+        (WebCore::PageOverlay::fadeAnimationTimerFired):
+        * page/PageOverlay.h:
+        * page/Settings.cpp:
+        (WebCore::Settings::Settings):
+        (WebCore::Settings::imageLoadingSettingsTimerFired):
+        * page/Settings.h:
+        * page/animation/AnimationController.cpp:
+        (WebCore::AnimationControllerPrivate::AnimationControllerPrivate):
+        (WebCore::AnimationControllerPrivate::updateStyleIfNeededDispatcherFired):
+        (WebCore::AnimationControllerPrivate::animationTimerFired):
+        * page/animation/AnimationControllerPrivate.h:
+        * page/mac/ServicesOverlayController.h:
+        * page/mac/ServicesOverlayController.mm:
+        (WebCore::ServicesOverlayController::ServicesOverlayController):
+        (WebCore::ServicesOverlayController::determineActiveHighlightTimerFired):
+        * page/scrolling/AsyncScrollingCoordinator.cpp:
+        (WebCore::AsyncScrollingCoordinator::AsyncScrollingCoordinator):
+        (WebCore::AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired):
+        * page/scrolling/AsyncScrollingCoordinator.h:
+        * page/scrolling/ios/ScrollingCoordinatorIOS.h:
+        * page/scrolling/ios/ScrollingCoordinatorIOS.mm:
+        (WebCore::ScrollingCoordinatorIOS::ScrollingCoordinatorIOS):
+        (WebCore::ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired):
+        * page/scrolling/mac/ScrollingCoordinatorMac.h:
+        * page/scrolling/mac/ScrollingCoordinatorMac.mm:
+        (WebCore::ScrollingCoordinatorMac::ScrollingCoordinatorMac):
+        (WebCore::ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired):
+        * platform/HysteresisActivity.h:
+        (WebCore::HysteresisActivity::HysteresisActivity):
+        (WebCore::HysteresisActivity::hysteresisTimerFired):
+        * platform/ScrollAnimator.cpp:
+        (WebCore::ScrollAnimator::updateScrollAnimatorsAndTimers):
+        (WebCore::ScrollAnimator::horizontalScrollSnapTimerFired):
+        (WebCore::ScrollAnimator::verticalScrollSnapTimerFired):
+        * platform/ScrollAnimator.h:
+        * platform/Scrollbar.cpp:
+        (WebCore::Scrollbar::Scrollbar):
+        (WebCore::Scrollbar::autoscrollTimerFired):
+        * platform/Scrollbar.h:
+        * platform/Timer.h:
+        (WebCore::DeferrableOneShotTimer::DeferrableOneShotTimer):
+        (WebCore::Timer::Timer): Deleted.
+        * platform/audio/MediaSession.cpp:
+        (WebCore::MediaSession::MediaSession):
+        (WebCore::MediaSession::clientDataBufferingTimerFired):
+        * platform/audio/MediaSession.h:
+        * platform/graphics/BitmapImage.cpp:
+        (WebCore::BitmapImage::startAnimation):
+        (WebCore::BitmapImage::advanceAnimation):
+        * platform/graphics/BitmapImage.h:
+        * platform/graphics/MediaPlayer.cpp:
+        (WebCore::MediaPlayer::MediaPlayer):
+        (WebCore::MediaPlayer::reloadTimerFired):
+        * platform/graphics/MediaPlayer.h:
+        * platform/graphics/ShadowBlur.cpp:
+        (WebCore::ScratchBuffer::ScratchBuffer):
+        (WebCore::ScratchBuffer::timerFired):
+        * platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h:
+        * platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm:
+        (WebCore::MediaSelectionGroupAVFObjC::MediaSelectionGroupAVFObjC):
+        (WebCore::MediaSelectionGroupAVFObjC::selectionTimerFired):
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
+        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
+        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::MediaPlayerPrivateMediaSourceAVFObjC):
+        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired):
+        * platform/graphics/ca/LayerPool.cpp:
+        (WebCore::LayerPool::LayerPool):
+        (WebCore::LayerPool::pruneTimerFired):
+        * platform/graphics/ca/LayerPool.h:
+        * platform/graphics/ca/TileController.cpp:
+        (WebCore::TileController::TileController):
+        (WebCore::TileController::tileRevalidationTimerFired):
+        * platform/graphics/ca/TileController.h:
+        * platform/graphics/ca/TileGrid.cpp:
+        (WebCore::TileGrid::TileGrid):
+        (WebCore::TileGrid::cohortRemovalTimerFired):
+        * platform/graphics/ca/TileGrid.h:
+        * platform/graphics/cg/IOSurfacePool.cpp:
+        (WebCore::IOSurfacePool::IOSurfacePool):
+        (WebCore::IOSurfacePool::collectionTimerFired):
+        * platform/graphics/cg/IOSurfacePool.h:
+        * platform/graphics/cg/SubimageCacheWithTimer.cpp:
+        (WebCore::SubimageCacheWithTimer::SubimageCacheWithTimer):
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.h:
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
+        (WebCore::MediaPlayerPrivateQTKit::MediaPlayerPrivateQTKit):
+        (WebCore::MediaPlayerPrivateQTKit::seekTimerFired):
+        * platform/ios/LegacyTileCache.h:
+        * platform/ios/LegacyTileCache.mm:
+        (WebCore::LegacyTileCache::LegacyTileCache):
+        (WebCore::LegacyTileCache::tileCreationTimerFired):
+        * platform/mac/HIDGamepadProvider.cpp:
+        (WebCore::HIDGamepadProvider::HIDGamepadProvider):
+        (WebCore::HIDGamepadProvider::connectionDelayTimerFired):
+        (WebCore::HIDGamepadProvider::inputNotificationTimerFired):
+        * platform/mac/HIDGamepadProvider.h:
+        * platform/mac/ScrollAnimatorMac.h:
+        * platform/mac/ScrollAnimatorMac.mm:
+        (WebCore::ScrollAnimatorMac::ScrollAnimatorMac):
+        (WebCore::ScrollAnimatorMac::snapRubberBandTimerFired):
+        (WebCore::ScrollAnimatorMac::initialScrollbarPaintTimerFired):
+        (WebCore::ScrollAnimatorMac::sendContentAreaScrolledTimerFired):
+        * platform/mock/DeviceOrientationClientMock.cpp:
+        (WebCore::DeviceOrientationClientMock::DeviceOrientationClientMock):
+        (WebCore::DeviceOrientationClientMock::timerFired):
+        * platform/mock/DeviceOrientationClientMock.h:
+        * platform/mock/PlatformSpeechSynthesizerMock.cpp:
+        (WebCore::PlatformSpeechSynthesizerMock::PlatformSpeechSynthesizerMock):
+        (WebCore::PlatformSpeechSynthesizerMock::speakingFinished):
+        * platform/mock/PlatformSpeechSynthesizerMock.h:
+        * platform/network/DNSResolveQueue.cpp:
+        (WebCore::DNSResolveQueue::DNSResolveQueue):
+        (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:
+        (WebCore::ResourceHandleInternal::ResourceHandleInternal):
+        * platform/network/mac/NetworkStateNotifierMac.cpp:
+        (WebCore::NetworkStateNotifier::networkStateChangeTimerFired):
+        (WebCore::NetworkStateNotifier::NetworkStateNotifier):
+        * rendering/ImageQualityController.cpp:
+        (WebCore::ImageQualityController::ImageQualityController):
+        (WebCore::ImageQualityController::highQualityRepaintTimerFired):
+        * rendering/ImageQualityController.h:
+        * rendering/RenderButton.cpp:
+        (WebCore::RenderButton::styleDidChange):
+        (WebCore::RenderButton::timerFired):
+        * rendering/RenderButton.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::RenderLayerCompositor):
+        (WebCore::RenderLayerCompositor::updateCompositingLayersTimerFired):
+        (WebCore::RenderLayerCompositor::layerFlushTimerFired):
+        (WebCore::RenderLayerCompositor::paintRelatedMilestonesTimerFired):
+        * rendering/RenderLayerCompositor.h:
+        * rendering/RenderMarquee.cpp:
+        (WebCore::RenderMarquee::RenderMarquee):
+        (WebCore::RenderMarquee::timerFired):
+        * rendering/RenderMarquee.h:
+        * rendering/RenderNamedFlowThread.cpp:
+        (WebCore::RenderNamedFlowThread::RenderNamedFlowThread):
+        (WebCore::RenderNamedFlowThread::regionOversetChangeEventTimerFired):
+        * rendering/RenderNamedFlowThread.h:
+        * rendering/RenderProgress.cpp:
+        (WebCore::RenderProgress::RenderProgress):
+        (WebCore::RenderProgress::animationTimerFired):
+        * rendering/RenderProgress.h:
+        * rendering/RenderView.cpp:
+        (WebCore::RenderView::RenderView):
+        (WebCore::RenderView::lazyRepaintTimerFired):
+        * rendering/RenderView.h:
+        * replay/EventLoopInputDispatcher.cpp:
+        (WebCore::EventLoopInputDispatcher::EventLoopInputDispatcher):
+        (WebCore::EventLoopInputDispatcher::timerFired):
+        * replay/EventLoopInputDispatcher.h:
+        * storage/StorageAreaImpl.cpp:
+        (WebCore::StorageAreaImpl::StorageAreaImpl):
+        (WebCore::StorageAreaImpl::closeDatabaseTimerFired):
+        (WebCore::StorageAreaImpl::closeDatabaseIfIdle):
+        * storage/StorageAreaImpl.h:
+        * storage/StorageAreaSync.cpp:
+        (WebCore::StorageAreaSync::StorageAreaSync):
+        (WebCore::StorageAreaSync::scheduleFinalSync):
+        (WebCore::StorageAreaSync::syncTimerFired):
+        (WebCore::StorageAreaSync::scheduleSync):
+        * storage/StorageAreaSync.h:
+        * svg/SVGElement.cpp:
+        (WebCore::SVGElement::svgLoadEventTimerFired):
+        * svg/SVGElement.h:
+        * svg/SVGScriptElement.cpp:
+        (WebCore::SVGScriptElement::SVGScriptElement):
+        * svg/SVGStyleElement.cpp:
+        (WebCore::SVGStyleElement::SVGStyleElement):
+        * svg/SVGUseElement.cpp:
+        (WebCore::SVGUseElement::SVGUseElement):
+        * svg/animation/SMILTimeContainer.cpp:
+        (WebCore::SMILTimeContainer::SMILTimeContainer):
+        (WebCore::SMILTimeContainer::timerFired):
+        * svg/animation/SMILTimeContainer.h:
+        * xml/XMLHttpRequestProgressEventThrottle.cpp:
+        (WebCore::XMLHttpRequestProgressEventThrottle::XMLHttpRequestProgressEventThrottle):
+        (WebCore::XMLHttpRequestProgressEventThrottle::dispatchDeferredEvents):
+        * xml/XMLHttpRequestProgressEventThrottle.h:
+
  2014-11-21  Chris Dumez  <cdumez@apple.com>
  
          Crash when setting 'transition-delay' CSS property to a calculated value
diff --git a/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp b/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp

index 060d77e53c4790ab1a1745adc2a5aa7d2cda1fe1..c672de07dcbe511fb3e1bbff1384037557b20649 100644 (file)
--- a/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp
+++ b/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp
@@ -51,8 +51,8 @@ MediaKeySession::MediaKeySession(ScriptExecutionContext* context, MediaKeys* key
      , m_keySystem(keySystem)
      , m_asyncEventQueue(*this)
      , m_session(keys->cdm()->createSession())
-    , m_keyRequestTimer(this, &MediaKeySession::keyRequestTimerFired)
-    , m_addKeyTimer(this, &MediaKeySession::addKeyTimerFired)
+    , m_keyRequestTimer(*this, &MediaKeySession::keyRequestTimerFired)
+    , m_addKeyTimer(*this, &MediaKeySession::addKeyTimerFired)
  {
      m_session->setClient(this);
  }
@@ -89,7 +89,7 @@ void MediaKeySession::generateKeyRequest(const String& mimeType, Uint8Array* ini
      m_keyRequestTimer.startOneShot(0);
  }
  
-void MediaKeySession::keyRequestTimerFired(Timer&)
+void MediaKeySession::keyRequestTimerFired()
  {
      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&)
+void MediaKeySession::addKeyTimerFired()
  {
      ASSERT(m_pendingKeys.size());
      if (!m_session)
diff --git a/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h b/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h

index 9c311ad2f641d10d30a95a4a312a97443cb80e0c..4f5732b2f4b81b66005fa7eeb30b00b5aa2e655e 100644 (file)
--- a/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h
+++ b/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h
@@ -84,8 +84,8 @@ public:
  
  protected:
      MediaKeySession(ScriptExecutionContext*, MediaKeys*, const String& keySystem);
-    void keyRequestTimerFired(Timer&);
-    void addKeyTimerFired(Timer&);
+    void keyRequestTimerFired();
+    void addKeyTimerFired();
  
      // CDMSessionClient
      virtual void sendMessage(Uint8Array*, String destinationURL);
diff --git a/Source/WebCore/Modules/geolocation/Geolocation.cpp b/Source/WebCore/Modules/geolocation/Geolocation.cpp

index 81d6136e143c5937b547d8a212217c63abb5e558..17df26842ba1a1600e634b471316e09d0744fad2 100644 (file)
--- a/Source/WebCore/Modules/geolocation/Geolocation.cpp
+++ b/Source/WebCore/Modules/geolocation/Geolocation.cpp
@@ -80,7 +80,7 @@ Geolocation::GeoNotifier::GeoNotifier(Geolocation* geolocation, PassRefPtr<Posit
      , m_successCallback(successCallback)
      , m_errorCallback(errorCallback)
      , m_options(options)
-    , m_timer(this, &Geolocation::GeoNotifier::timerFired)
+    , m_timer(*this, &Geolocation::GeoNotifier::timerFired)
      , m_useCachedPosition(false)
  {
      ASSERT(m_geolocation);
@@ -142,7 +142,7 @@ void Geolocation::GeoNotifier::stopTimer()
      m_timer.stop();
  }
  
-void Geolocation::GeoNotifier::timerFired(Timer&)
+void Geolocation::GeoNotifier::timerFired()
  {
      m_timer.stop();
  
@@ -238,7 +238,7 @@ Geolocation::Geolocation(ScriptExecutionContext* context)
  #if PLATFORM(IOS)
      , m_isSuspended(false)
      , m_hasChangedPosition(false)
-    , m_resumeTimer(this, &Geolocation::resumeTimerFired)
+    , m_resumeTimer(*this, &Geolocation::resumeTimerFired)
  #endif
  {
  }
@@ -297,7 +297,7 @@ void Geolocation::resume()
          m_resumeTimer.startOneShot(0);
  }
  
-void Geolocation::resumeTimerFired(Timer&)
+void Geolocation::resumeTimerFired()
  {
      m_isSuspended = false;
  
diff --git a/Source/WebCore/Modules/geolocation/Geolocation.h b/Source/WebCore/Modules/geolocation/Geolocation.h

index 55623d0e11d72080b0306d90c798b51aedc39854..526ddc0ca2ef704b1779d6b990127d3cba556994 100644 (file)
--- a/Source/WebCore/Modules/geolocation/Geolocation.h
+++ b/Source/WebCore/Modules/geolocation/Geolocation.h
@@ -100,7 +100,7 @@ private:
  
          void startTimerIfNeeded();
          void stopTimer();
-        void timerFired(Timer&);
+        void timerFired();
          bool hasZeroTimeout() const;
  
      private:
@@ -186,7 +186,7 @@ private:
      bool m_hasChangedPosition;
      RefPtr<PositionError> m_errorWaitingForResume;
  
-    void resumeTimerFired(Timer&);
+    void resumeTimerFired();
      Timer m_resumeTimer;
  #endif // PLATFORM(IOS)
  
diff --git a/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.cpp b/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.cpp

index a869e1308eb443573b32e0017bed4b7e934e237b..28409cb78ceb93ff672ad4c6db58a8415e0c7acf 100644 (file)
--- a/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.cpp
+++ b/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.cpp
@@ -57,7 +57,7 @@ IDBTransactionBackend::IDBTransactionBackend(IDBDatabaseBackend* databaseBackend
      , m_commitPending(false)
      , m_callbacks(callbacks)
      , m_database(databaseBackend)
-    , m_taskTimer(this, &IDBTransactionBackend::taskTimerFired)
+    , m_taskTimer(*this, &IDBTransactionBackend::taskTimerFired)
      , m_pendingPreemptiveEvents(0)
      , m_id(id)
  {
@@ -270,7 +270,7 @@ void IDBTransactionBackend::commit()
      });
  }
  
-void IDBTransactionBackend::taskTimerFired(Timer&)
+void IDBTransactionBackend::taskTimerFired()
  {
      LOG(StorageAPI, "IDBTransactionBackend::taskTimerFired");
  
diff --git a/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h b/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h

index ba5ea4f8a8160430de36e80b01b378ff52f0b5fa..e602f247d6a489ade5402f85971868c3949db154 100644 (file)
--- a/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h
+++ b/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h
@@ -96,7 +96,7 @@ private:
      bool isTaskQueueEmpty() const;
      bool hasPendingTasks() const;
  
-    void taskTimerFired(Timer&);
+    void taskTimerFired();
      void closeOpenCursors();
  
      const HashSet<int64_t> m_objectStoreIds;
diff --git a/Source/WebCore/Modules/mediasource/SourceBuffer.cpp b/Source/WebCore/Modules/mediasource/SourceBuffer.cpp

index 7659577d36d331d0d6a614ff345c70d9888b8acb..922fafdc084e0bf14624f1040ffee28178d83d90 100644 (file)
--- a/Source/WebCore/Modules/mediasource/SourceBuffer.cpp
+++ b/Source/WebCore/Modules/mediasource/SourceBuffer.cpp
@@ -109,7 +109,7 @@ SourceBuffer::SourceBuffer(PassRef<SourceBufferPrivate> sourceBufferPrivate, Med
      , m_private(WTF::move(sourceBufferPrivate))
      , m_source(source)
      , m_asyncEventQueue(*this)
-    , m_appendBufferTimer(this, &SourceBuffer::appendBufferTimerFired)
+    , m_appendBufferTimer(*this, &SourceBuffer::appendBufferTimerFired)
      , m_highestPresentationEndTimestamp(MediaTime::invalidTime())
      , m_buffered(TimeRanges::create())
      , m_appendState(WaitingForSegment)
@@ -119,7 +119,7 @@ SourceBuffer::SourceBuffer(PassRef<SourceBufferPrivate> sourceBufferPrivate, Med
      , m_reportedExtraMemoryCost(0)
      , m_pendingRemoveStart(MediaTime::invalidTime())
      , m_pendingRemoveEnd(MediaTime::invalidTime())
-    , m_removeTimer(this, &SourceBuffer::removeTimerFired)
+    , m_removeTimer(*this, &SourceBuffer::removeTimerFired)
      , m_updating(false)
      , m_receivedFirstInitializationSegment(false)
      , m_active(false)
@@ -447,7 +447,7 @@ void SourceBuffer::appendBufferInternal(unsigned char* data, unsigned size, Exce
      reportExtraMemoryCost();
  }
  
-void SourceBuffer::appendBufferTimerFired(Timer&)
+void SourceBuffer::appendBufferTimerFired()
  {
      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*)
+void SourceBuffer::removeTimerFired()
  {
      ASSERT(m_updating);
      ASSERT(m_pendingRemoveStart.isValid());
diff --git a/Source/WebCore/Modules/mediasource/SourceBuffer.h b/Source/WebCore/Modules/mediasource/SourceBuffer.h

index d36802cec9f06a972c8d39d6815ee7c31c192158..06610383fe035c6356660c0ced29976e0affc251 100644 (file)
--- a/Source/WebCore/Modules/mediasource/SourceBuffer.h
+++ b/Source/WebCore/Modules/mediasource/SourceBuffer.h
@@ -152,7 +152,7 @@ private:
      void scheduleEvent(const AtomicString& eventName);
  
      void appendBufferInternal(unsigned char*, unsigned, ExceptionCode&);
-    void appendBufferTimerFired(Timer&);
+    void appendBufferTimerFired();
  
      void setActive(bool);
  
@@ -166,7 +166,7 @@ private:
  
      void monitorBufferingRate();
  
-    void removeTimerFired(Timer*);
+    void removeTimerFired();
      void removeCodedFrames(const MediaTime& start, const MediaTime& end);
  
      size_t extraMemoryCost() const;
diff --git a/Source/WebCore/Modules/mediastream/MediaStream.cpp b/Source/WebCore/Modules/mediastream/MediaStream.cpp

index 5ac5176edecfb7588932b081af592031cab14189..f09650e5e3c06805822c6f5e512d759cf2742b65 100644 (file)
--- a/Source/WebCore/Modules/mediastream/MediaStream.cpp
+++ b/Source/WebCore/Modules/mediastream/MediaStream.cpp
@@ -86,7 +86,7 @@ PassRefPtr<MediaStream> MediaStream::create(ScriptExecutionContext& context, Pas
  MediaStream::MediaStream(ScriptExecutionContext& context, PassRefPtr<MediaStreamPrivate> privateStream)
      : ContextDestructionObserver(&context)
      , m_private(privateStream)
-    , m_scheduledEventTimer(this, &MediaStream::scheduledEventTimerFired)
+    , m_scheduledEventtimer(*this, &MediaStream::scheduledEventTimerFired)
  {
      ASSERT(m_private);
      m_private->setClient(this);
@@ -361,7 +361,7 @@ void MediaStream::scheduleDispatchEvent(PassRefPtr<Event> event)
          m_scheduledEventTimer.startOneShot(0);
  }
  
-void MediaStream::scheduledEventTimerFired(Timer*)
+void MediaStream::scheduledEventTimerFired()
  {
      Vector<RefPtr<Event>> events;
      events.swap(m_scheduledEvents);
diff --git a/Source/WebCore/Modules/mediastream/MediaStream.h b/Source/WebCore/Modules/mediastream/MediaStream.h

index 806fdcca5c85cff7fa779d91d51e0fbfbcd6cf06..d49af61640ff43e3a4f74dddc9e9aa570b3a4dcb 100644 (file)
--- a/Source/WebCore/Modules/mediastream/MediaStream.h
+++ b/Source/WebCore/Modules/mediastream/MediaStream.h
@@ -120,7 +120,7 @@ private:
      bool haveTrackWithSource(PassRefPtr<MediaStreamSource>);
  
      void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer*);
+    void scheduledEventTimerFired();
  
      void cloneMediaStreamTrackVector(Vector<RefPtr<MediaStreamTrack>>&, const Vector<RefPtr<MediaStreamTrack>>&);
  
diff --git a/Source/WebCore/Modules/mediastream/RTCDTMFSender.cpp b/Source/WebCore/Modules/mediastream/RTCDTMFSender.cpp

index e242c40d25c6ef08ec28f4717eb93c2f0a439db4..0431e54c7427ac3af12ef08fb6d7fd8e473eb4fa 100644 (file)
--- a/Source/WebCore/Modules/mediastream/RTCDTMFSender.cpp
+++ b/Source/WebCore/Modules/mediastream/RTCDTMFSender.cpp
@@ -65,7 +65,7 @@ RTCDTMFSender::RTCDTMFSender(ScriptExecutionContext* context, PassRefPtr<MediaSt
      , m_interToneGap(defaultInterToneGapMs)
      , m_handler(WTF::move(handler))
      , m_stopped(false)
-    , m_scheduledEventTimer(this, &RTCDTMFSender::scheduledEventTimerFired)
+    , m_scheduledEventtimer(*this, &RTCDTMFSender::scheduledEventTimerFired)
  {
      m_handler->setClient(this);
  }
@@ -142,7 +142,7 @@ void RTCDTMFSender::scheduleDispatchEvent(PassRefPtr<Event> event)
          m_scheduledEventTimer.startOneShot(0);
  }
  
-void RTCDTMFSender::scheduledEventTimerFired(Timer*)
+void RTCDTMFSender::scheduledEventTimerFired()
  {
      if (m_stopped)
          return;
diff --git a/Source/WebCore/Modules/mediastream/RTCDTMFSender.h b/Source/WebCore/Modules/mediastream/RTCDTMFSender.h

index bed2a621295e4ca4691ed94c414f79943ed9c8fd..4d6003571748e6e6a8d564db391b0bcb5ef4e7d4 100644 (file)
--- a/Source/WebCore/Modules/mediastream/RTCDTMFSender.h
+++ b/Source/WebCore/Modules/mediastream/RTCDTMFSender.h
@@ -72,7 +72,7 @@ private:
      RTCDTMFSender(ScriptExecutionContext*, PassRefPtr<MediaStreamTrack>, std::unique_ptr<RTCDTMFSenderHandler>);
  
      void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer*);
+    void scheduledEventTimerFired();
  
      // EventTarget
      virtual void refEventTarget() override { ref(); }
diff --git a/Source/WebCore/Modules/mediastream/RTCDataChannel.cpp b/Source/WebCore/Modules/mediastream/RTCDataChannel.cpp

index 4233fd49caf658181badaf78566127187a39c30d..72f65840e34e4331d70c13ce29f81bf31643c68c 100644 (file)
--- a/Source/WebCore/Modules/mediastream/RTCDataChannel.cpp
+++ b/Source/WebCore/Modules/mediastream/RTCDataChannel.cpp
@@ -95,7 +95,7 @@ RTCDataChannel::RTCDataChannel(ScriptExecutionContext* context, std::unique_ptr<
      , m_stopped(false)
      , m_readyState(ReadyStateConnecting)
      , m_binaryType(BinaryTypeArrayBuffer)
-    , m_scheduledEventTimer(this, &RTCDataChannel::scheduledEventTimerFired)
+    , m_scheduledEventtimer(*this, &RTCDataChannel::scheduledEventTimerFired)
  {
      m_handler->setClient(this);
  }
@@ -312,7 +312,7 @@ void RTCDataChannel::scheduleDispatchEvent(PassRefPtr<Event> event)
          m_scheduledEventTimer.startOneShot(0);
  }
  
-void RTCDataChannel::scheduledEventTimerFired(Timer*)
+void RTCDataChannel::scheduledEventTimerFired()
  {
      if (m_stopped)
          return;
diff --git a/Source/WebCore/Modules/mediastream/RTCDataChannel.h b/Source/WebCore/Modules/mediastream/RTCDataChannel.h

index 6f8038e28b648e1729cdc03ffd549af244c0d4e7..56e201fa0815440b6bfc42040e8b2aad5f1f7d0c 100644 (file)
--- a/Source/WebCore/Modules/mediastream/RTCDataChannel.h
+++ b/Source/WebCore/Modules/mediastream/RTCDataChannel.h
@@ -89,7 +89,7 @@ private:
      RTCDataChannel(ScriptExecutionContext*, std::unique_ptr<RTCDataChannelHandler>);
  
      void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer*);
+    void scheduledEventTimerFired();
  
      // EventTarget
      virtual void refEventTarget() override { ref(); }
diff --git a/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp b/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

index 247b62f3af976995f54f0d44b1f87963758500fb..3ff5504c5d82e7b964ba65a78e178959f5a72265 100644 (file)
--- a/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp
+++ b/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp
@@ -174,7 +174,7 @@ RTCPeerConnection::RTCPeerConnection(ScriptExecutionContext& context, PassRefPtr
      , m_signalingState(SignalingStateStable)
      , m_iceGatheringState(IceGatheringStateNew)
      , m_iceConnectionState(IceConnectionStateNew)
-    , m_scheduledEventTimer(this, &RTCPeerConnection::scheduledEventTimerFired)
+    , m_scheduledEventtimer(*this, &RTCPeerConnection::scheduledEventTimerFired)
      , m_configuration(configuration)
      , m_stopped(false)
  {
@@ -724,7 +724,7 @@ void RTCPeerConnection::scheduleDispatchEvent(PassRefPtr<Event> event)
          m_scheduledEventTimer.startOneShot(0);
  }
  
-void RTCPeerConnection::scheduledEventTimerFired(Timer*)
+void RTCPeerConnection::scheduledEventTimerFired()
  {
      if (m_stopped)
          return;
diff --git a/Source/WebCore/Modules/mediastream/RTCPeerConnection.h b/Source/WebCore/Modules/mediastream/RTCPeerConnection.h

index aabfcdc2c2180230a1ae6ee2faec51d067d627d2..d3416acfdd6bc9dfcc604261359c72c50624f038 100644 (file)
--- a/Source/WebCore/Modules/mediastream/RTCPeerConnection.h
+++ b/Source/WebCore/Modules/mediastream/RTCPeerConnection.h
@@ -139,7 +139,7 @@ private:
  
      static PassRefPtr<RTCConfiguration> parseConfiguration(const Dictionary& configuration, ExceptionCode&);
      void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer*);
+    void scheduledEventTimerFired();
      bool hasLocalStreamWithTrackId(const String& trackId);
  
      // EventTarget implementation.
diff --git a/Source/WebCore/Modules/notifications/Notification.cpp b/Source/WebCore/Modules/notifications/Notification.cpp

index 4e838300672022a3691f0444fb4b5f21f12d817d..d086e9787fabcc123459c2e5acc5869cf7c53548 100644 (file)
--- a/Source/WebCore/Modules/notifications/Notification.cpp
+++ b/Source/WebCore/Modules/notifications/Notification.cpp
@@ -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>(this, &Notification::taskTimerFired))
+    , m_taskTimer(std::make_unique<Timer>(*this, &Notification::taskTimerFired))
  {
      m_notificationCenter = DOMWindowNotifications::webkitNotifications(downcast<Document>(context).domWindow());
      
@@ -201,10 +201,9 @@ void Notification::dispatchErrorEvent()
  }
  
  #if ENABLE(NOTIFICATIONS)
-void Notification::taskTimerFired(Timer& timer)
+void Notification::taskTimerFired()
  {
      ASSERT(scriptExecutionContext()->isDocument());
-    ASSERT_UNUSED(timer, &timer == m_taskTimer.get());
      show();
  }
  #endif
diff --git a/Source/WebCore/Modules/notifications/Notification.h b/Source/WebCore/Modules/notifications/Notification.h

index 38baa68821112e6c5cbd2866ece674e4bc86f538..50797ae3baeceaed5463b7725b156bf608b3a2e5 100644 (file)
--- a/Source/WebCore/Modules/notifications/Notification.h
+++ b/Source/WebCore/Modules/notifications/Notification.h
@@ -157,7 +157,7 @@ private:
      void finishLoadingIcon();
  
  #if ENABLE(NOTIFICATIONS)
-    void taskTimerFired(Timer&);
+    void taskTimerFired();
  #endif
  
      // Text notifications.
diff --git a/Source/WebCore/Modules/notifications/NotificationCenter.cpp b/Source/WebCore/Modules/notifications/NotificationCenter.cpp

index bafb5ca3597d3a50a3bc0273170a9fe25d378d3f..3a5a007c77bde2eadc4dfa887326e0ca356f8eaf 100644 (file)
--- a/Source/WebCore/Modules/notifications/NotificationCenter.cpp
+++ b/Source/WebCore/Modules/notifications/NotificationCenter.cpp
@@ -119,7 +119,7 @@ PassRefPtr<NotificationCenter::NotificationRequestCallback> NotificationCenter::
  
  NotificationCenter::NotificationRequestCallback::NotificationRequestCallback(NotificationCenter* center, PassRefPtr<VoidCallback> callback)
      : m_notificationCenter(center)
-    , m_timer(this, &NotificationCenter::NotificationRequestCallback::timerFired)
+    , m_timer(*this, &NotificationCenter::NotificationRequestCallback::timerFired)
      , m_callback(callback)
  {
  }
@@ -129,7 +129,7 @@ void NotificationCenter::NotificationRequestCallback::startTimer()
      m_timer.startOneShot(0);
  }
  
-void NotificationCenter::NotificationRequestCallback::timerFired(Timer&)
+void NotificationCenter::NotificationRequestCallback::timerFired()
  {
      if (m_callback)
          m_callback->handleEvent();
diff --git a/Source/WebCore/Modules/notifications/NotificationCenter.h b/Source/WebCore/Modules/notifications/NotificationCenter.h

index edabb62adf305402d626aceacf32918e65c12af6..d3cda3b070098f7513463cd1d4c9819f487dabe6 100644 (file)
--- a/Source/WebCore/Modules/notifications/NotificationCenter.h
+++ b/Source/WebCore/Modules/notifications/NotificationCenter.h
@@ -80,7 +80,7 @@ private:
      public:
          static PassRefPtr<NotificationRequestCallback> createAndStartTimer(NotificationCenter*, PassRefPtr<VoidCallback>);
          void startTimer();
-        void timerFired(Timer&);
+        void timerFired();
      private:
          NotificationRequestCallback(NotificationCenter*, PassRefPtr<VoidCallback>);
  
diff --git a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp b/Source/WebCore/Modules/websockets/WebSocketChannel.cpp

index d9c6abd27720a227aa0262ac9706d0136c5c16d6..b0498afb29e9745c410af178bd5981e82467a728 100644 (file)
--- a/Source/WebCore/Modules/websockets/WebSocketChannel.cpp
+++ b/Source/WebCore/Modules/websockets/WebSocketChannel.cpp
@@ -67,11 +67,11 @@ const double TCPMaximumSegmentLifetime = 2 * 60.0;
  WebSocketChannel::WebSocketChannel(Document* document, WebSocketChannelClient* client)
      : m_document(document)
      , m_client(client)
-    , m_resumeTimer(this, &WebSocketChannel::resumeTimerFired)
+    , m_resumeTimer(*this, &WebSocketChannel::resumeTimerFired)
      , m_suspended(false)
      , m_closing(false)
      , m_receivedClosingHandshake(false)
-    , m_closingTimer(this, &WebSocketChannel::closingTimerFired)
+    , m_closingTimer(*this, &WebSocketChannel::closingTimerFired)
      , m_closed(false)
      , m_shouldDiscardReceivedData(false)
      , m_unhandledBufferedAmount(0)
@@ -447,10 +447,8 @@ bool WebSocketChannel::processBuffer()
      return processFrame();
  }
  
-void WebSocketChannel::resumeTimerFired(Timer* timer)
+void WebSocketChannel::resumeTimerFired()
  {
-    ASSERT_UNUSED(timer, timer == &m_resumeTimer);
-
      Ref<WebSocketChannel> protect(*this); // The client can close the channel, potentially removing the last reference.
      while (!m_suspended && m_client && !m_buffer.isEmpty())
          if (!processBuffer())
@@ -489,10 +487,9 @@ void WebSocketChannel::startClosingHandshake(int code, const String& reason)
          m_client->didStartClosingHandshake();
  }
  
-void WebSocketChannel::closingTimerFired(Timer* timer)
+void WebSocketChannel::closingTimerFired()
  {
      LOG(Network, "WebSocketChannel %p closingTimerFired()", this);
-    ASSERT_UNUSED(timer, &m_closingTimer == timer);
      if (m_handle)
          m_handle->disconnect();
  }
diff --git a/Source/WebCore/Modules/websockets/WebSocketChannel.h b/Source/WebCore/Modules/websockets/WebSocketChannel.h

index be75d33449646a1e28de295c71a107566a467d03..9ee5c8accb34fefad025019e213569ac73a7530b 100644 (file)
--- a/Source/WebCore/Modules/websockets/WebSocketChannel.h
+++ b/Source/WebCore/Modules/websockets/WebSocketChannel.h
@@ -127,9 +127,9 @@ private:
      bool appendToBuffer(const char* data, size_t len);
      void skipBuffer(size_t len);
      bool processBuffer();
-    void resumeTimerFired(Timer*);
+    void resumeTimerFired();
      void startClosingHandshake(int code, const String& reason);
-    void closingTimerFired(Timer*);
+    void closingTimerFired();
  
      bool processFrame();
  
diff --git a/Source/WebCore/accessibility/AXObjectCache.cpp b/Source/WebCore/accessibility/AXObjectCache.cpp

index d8afb257fab8f9989b414f3a9a93416ee9d05348..097b3b3b9c33aa9fff3a15e947759135144da9db 100644 (file)
--- a/Source/WebCore/accessibility/AXObjectCache.cpp
+++ b/Source/WebCore/accessibility/AXObjectCache.cpp
@@ -128,7 +128,7 @@ void AXObjectCache::setEnhancedUserInterfaceAccessibility(bool flag)
  
  AXObjectCache::AXObjectCache(Document& document)
      : m_document(document)
-    , m_notificationPostTimer(this, &AXObjectCache::notificationPostTimerFired)
+    , m_notificationPostTimer(*this, &AXObjectCache::notificationPostTimerFired)
  {
  }
  
@@ -700,7 +700,7 @@ void AXObjectCache::childrenChanged(AccessibilityObject* obj)
      obj->childrenChanged();
  }
      
-void AXObjectCache::notificationPostTimerFired(Timer&)
+void AXObjectCache::notificationPostTimerFired()
  {
      Ref<Document> protectorForCacheOwner(m_document);
      m_notificationPostTimer.stop();
diff --git a/Source/WebCore/accessibility/AXObjectCache.h b/Source/WebCore/accessibility/AXObjectCache.h

index b4b5c37f6a12b55b6cde564fc9cbae6cdb11f685..f83ea7d4a87efcfd1bf1e0f7bb300bd49a43aa40 100644 (file)
--- a/Source/WebCore/accessibility/AXObjectCache.h
+++ b/Source/WebCore/accessibility/AXObjectCache.h
@@ -244,7 +244,7 @@ private:
      
      Timer m_notificationPostTimer;
      Vector<std::pair<RefPtr<AccessibilityObject>, AXNotification>> m_notificationsToPost;
-    void notificationPostTimerFired(Timer&);
+    void notificationPostTimerFired();
      void handleMenuOpened(Node*);
      void handleLiveRegionCreated(Node*);
      void handleMenuItemSelected(Node*);
diff --git a/Source/WebCore/bindings/js/GCController.cpp b/Source/WebCore/bindings/js/GCController.cpp

index c69156cc43b040bc47bf7da50237746cff9caa36..18ecf769963e529475a301e8cf503c0b6c2639ee 100644 (file)
--- a/Source/WebCore/bindings/js/GCController.cpp
+++ b/Source/WebCore/bindings/js/GCController.cpp
@@ -51,7 +51,7 @@ GCController& gcController()
  
  GCController::GCController()
  #if !USE(CF)
-    : m_GCTimer(this, &GCController::gcTimerFired)
+    : m_GCtimer(*this, &GCController::gcTimerFired)
  #endif
  {
  }
@@ -73,7 +73,7 @@ void GCController::garbageCollectSoon()
  }
  
  #if !USE(CF)
-void GCController::gcTimerFired(Timer*)
+void GCController::gcTimerFired()
  {
      collect(nullptr);
  }
diff --git a/Source/WebCore/bindings/js/GCController.h b/Source/WebCore/bindings/js/GCController.h

index a371510a4d2dec00591840c695d863f734ce6f58..eebe107be63c724be32aa81a9eb2573528c2cd23 100644 (file)
--- a/Source/WebCore/bindings/js/GCController.h
+++ b/Source/WebCore/bindings/js/GCController.h
@@ -52,7 +52,7 @@ namespace WebCore {
          GCController(); // Use gcController() instead
  
  #if !USE(CF)
-        void gcTimerFired(Timer*);
+        void gcTimerFired();
          Timer m_GCTimer;
  #endif
      };
diff --git a/Source/WebCore/css/CSSFontFaceSource.h b/Source/WebCore/css/CSSFontFaceSource.h

index 6b164104735615de300b7556dd2f0d4c04063a6c..834b6e508ce1e8d0ce0a54d8569f3d40c8001f5d 100644 (file)
--- a/Source/WebCore/css/CSSFontFaceSource.h
+++ b/Source/WebCore/css/CSSFontFaceSource.h
@@ -76,7 +76,7 @@ public:
  #endif
  
  private:
-    void startLoadingTimerFired(Timer*);
+    void startLoadingTimerFired();
  
      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.
diff --git a/Source/WebCore/css/CSSFontSelector.cpp b/Source/WebCore/css/CSSFontSelector.cpp

index 1baaefc2504575993dbdda59378835ad09f9590c..4369290f195996b5a3521fa161c49c704f4b2c44 100644 (file)
--- a/Source/WebCore/css/CSSFontSelector.cpp
+++ b/Source/WebCore/css/CSSFontSelector.cpp
@@ -60,7 +60,7 @@ static unsigned fontSelectorId;
  
  CSSFontSelector::CSSFontSelector(Document* document)
      : m_document(document)
-    , m_beginLoadingTimer(this, &CSSFontSelector::beginLoadTimerFired)
+    , m_beginLoadingTimer(*this, &CSSFontSelector::beginLoadTimerFired)
      , m_uniqueId(++fontSelectorId)
      , m_version(0)
      
@@ -587,7 +587,7 @@ void CSSFontSelector::beginLoadingFontSoon(CachedFont* font)
      m_beginLoadingTimer.startOneShot(0);
  }
  
-void CSSFontSelector::beginLoadTimerFired(Timer&)
+void CSSFontSelector::beginLoadTimerFired()
  {
      Vector<CachedResourceHandle<CachedFont>> fontsToBeginLoading;
      fontsToBeginLoading.swap(m_fontsToBeginLoading);
diff --git a/Source/WebCore/css/CSSFontSelector.h b/Source/WebCore/css/CSSFontSelector.h

index 18bf1896b803a5a0eba3eaf8cf09cf32d35701b9..c541c4538542cf893d2e6bafe03dc48c5a9ce5bd 100644 (file)
--- a/Source/WebCore/css/CSSFontSelector.h
+++ b/Source/WebCore/css/CSSFontSelector.h
@@ -86,7 +86,7 @@ private:
  
      void dispatchInvalidationCallbacks();
  
-    void beginLoadTimerFired(Timer&);
+    void beginLoadTimerFired();
  
      Document* m_document;
      HashMap<String, std::unique_ptr<Vector<RefPtr<CSSFontFace>>>, CaseFoldingHash> m_fontFaces;
diff --git a/Source/WebCore/css/CSSImageGeneratorValue.cpp b/Source/WebCore/css/CSSImageGeneratorValue.cpp

index fb899557175563b955d3817874ed4b778c0247c5..d2f042dd0b1106fbc2dedcaf9120bcfde2fabf3f 100644 (file)
--- a/Source/WebCore/css/CSSImageGeneratorValue.cpp
+++ b/Source/WebCore/css/CSSImageGeneratorValue.cpp
@@ -94,7 +94,7 @@ CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage(CSSImageGener
      : m_owner(owner)
      , m_size(size)
      , m_image(image)
-    , m_evictionTimer(this, &CSSImageGeneratorValue::CachedGeneratedImage::evictionTimerFired, timeToKeepCachedGeneratedImages)
+    , m_evictionTimer(*this, &CSSImageGeneratorValue::CachedGeneratedImage::evictionTimerFired, timeToKeepCachedGeneratedImages)
  {
      m_evictionTimer.restart();
  }
diff --git a/Source/WebCore/css/FontLoader.cpp b/Source/WebCore/css/FontLoader.cpp

index eea352d489e84dec169e6268539366338385f7b3..903ccfae3fdff58278d1f086ce95b2089570deaf 100644 (file)
--- a/Source/WebCore/css/FontLoader.cpp
+++ b/Source/WebCore/css/FontLoader.cpp
@@ -122,7 +122,7 @@ FontLoader::FontLoader(Document* document)
      , m_document(document)
      , m_numLoadingFromCSS(0)
      , m_numLoadingFromJS(0)
-    , m_pendingEventsTimer(this, &FontLoader::pendingEventsTimerFired)
+    , m_pendingEventsTimer(*this, &FontLoader::pendingEventsTimerFired)
  {
      suspendIfNeeded();
  }
diff --git a/Source/WebCore/css/FontLoader.h b/Source/WebCore/css/FontLoader.h

index 64d2c26b9f0dd63bb370716d8f55c90ef99a03ee..b6d6d911a14cc4c88264cc23225ee3844350c5d0 100644 (file)
--- a/Source/WebCore/css/FontLoader.h
+++ b/Source/WebCore/css/FontLoader.h
@@ -95,7 +95,7 @@ private:
      virtual EventTargetData* eventTargetData() override;
      virtual EventTargetData& ensureEventTargetData() override;
  
-    void pendingEventsTimerFired(Timer&) { firePendingEvents(); }
+    void pendingEventsTimerFired() { firePendingEvents(); }
      void scheduleEvent(PassRefPtr<Event>);
      void firePendingEvents();
      bool resolveFontStyle(const String&, Font&);
diff --git a/Source/WebCore/css/StyleResolver.cpp b/Source/WebCore/css/StyleResolver.cpp

index 8cc7a31023e6a5f06cbcecdd6b16f0f8a8a30cbc..724ff3c2cd284dd48b0271d06df5412190422d86 100644 (file)
--- a/Source/WebCore/css/StyleResolver.cpp
+++ b/Source/WebCore/css/StyleResolver.cpp
@@ -251,7 +251,7 @@ void StyleResolver::MatchResult::addMatchedProperties(const StyleProperties& pro
  
  StyleResolver::StyleResolver(Document& document, bool matchAuthorAndUserStyles)
      : m_matchedPropertiesCacheAdditionsSinceLastSweep(0)
-    , m_matchedPropertiesCacheSweepTimer(this, &StyleResolver::sweepMatchedPropertiesCache)
+    , m_matchedPropertiesCacheSweepTimer(*this, &StyleResolver::sweepMatchedPropertiesCache)
      , m_document(document)
      , m_matchAuthorAndUserStyles(matchAuthorAndUserStyles)
      , m_fontSelector(CSSFontSelector::create(&m_document))
@@ -349,7 +349,7 @@ StyleResolver::~StyleResolver()
  #endif
  }
  
-void StyleResolver::sweepMatchedPropertiesCache(Timer*)
+void StyleResolver::sweepMatchedPropertiesCache()
  {
      // 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()
diff --git a/Source/WebCore/css/StyleResolver.h b/Source/WebCore/css/StyleResolver.h

index c9958f9c91bc217d623292ed2e4303504f79e2c0..55ca0f6ede9764618a1e63b1031a825917457c76 100644 (file)
--- a/Source/WebCore/css/StyleResolver.h
+++ b/Source/WebCore/css/StyleResolver.h
@@ -496,7 +496,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*);
+    void sweepMatchedPropertiesCache();
  
      bool classNamesAffectedByRules(const SpaceSplitString&) const;
      bool sharingCandidateHasIdenticalStyleAffectingAttributes(StyledElement*) const;
diff --git a/Source/WebCore/dom/Document.cpp b/Source/WebCore/dom/Document.cpp

index 02d1fa4a6811fbd5d816f6669ea5a451c12e79ee..37483ce228f5740156776a8993fa4bc5609fe2cd 100644 (file)
--- a/Source/WebCore/dom/Document.cpp
+++ b/Source/WebCore/dom/Document.cpp
@@ -408,7 +408,7 @@ Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsig
  #if ENABLE(IOS_TOUCH_EVENTS)
      , m_handlingTouchEvent(false)
      , m_touchEventRegionsDirty(false)
-    , m_touchEventsChangedTimer(this, &Document::touchEventsChangedTimerFired)
+    , m_touchEventsChangedTimer(*this, &Document::touchEventsChangedTimerFired)
  #endif
      , m_referencingNodeCount(0)
      , m_didCalculateStyleResolver(false)
@@ -433,8 +433,8 @@ Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsig
      , m_visuallyOrdered(false)
      , m_readyState(Complete)
      , m_bParsing(false)
-    , m_optimizedStyleSheetUpdateTimer(this, &Document::optimizedStyleSheetUpdateTimerFired)
-    , m_styleRecalcTimer(this, &Document::styleRecalcTimerFired)
+    , m_optimizedStyleSheetUpdateTimer(*this, &Document::optimizedStyleSheetUpdateTimerFired)
+    , m_styleRecalcTimer(*this, &Document::styleRecalcTimerFired)
      , m_pendingStyleRecalcShouldForce(false)
      , m_inStyleRecalc(false)
      , m_closeAfterStyleRecalc(false)
@@ -444,7 +444,7 @@ Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsig
      , m_ignoreDestructiveWriteCount(0)
      , m_titleSetExplicitly(false)
      , m_markers(std::make_unique<DocumentMarkerController>())
-    , m_updateFocusAppearanceTimer(this, &Document::updateFocusAppearanceTimerFired)
+    , m_updateFocusAppearanceTimer(*this, &Document::updateFocusAppearanceTimerFired)
      , m_cssTarget(nullptr)
      , m_processingLoadEvent(false)
      , m_loadEventFinished(false)
@@ -475,11 +475,11 @@ Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsig
  #if ENABLE(FULLSCREEN_API)
      , m_areKeysEnabledInFullScreen(0)
      , m_fullScreenRenderer(nullptr)
-    , m_fullScreenChangeDelayTimer(this, &Document::fullScreenChangeDelayTimerFired)
+    , m_fullScreenChangeDelayTimer(*this, &Document::fullScreenChangeDelayTimerFired)
      , m_isAnimatingFullScreen(false)
  #endif
      , m_loadEventDelayCount(0)
-    , m_loadEventDelayTimer(this, &Document::loadEventDelayTimerFired)
+    , m_loadEventDelayTimer(*this, &Document::loadEventDelayTimerFired)
      , m_referrerPolicy(ReferrerPolicyDefault)
      , m_directionSetOnDocumentElement(false)
      , m_writingModeSetOnDocumentElement(false)
@@ -498,11 +498,11 @@ Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsig
  #if ENABLE(TELEPHONE_NUMBER_DETECTION)
      , m_isTelephoneNumberParsingAllowed(true)
  #endif
-    , m_pendingTasksTimer(this, &Document::pendingTasksTimerFired)
+    , m_pendingTasksTimer(*this, &Document::pendingTasksTimerFired)
      , m_scheduledTasksAreSuspended(false)
      , m_visualUpdatesAllowed(true)
-    , m_visualUpdatesSuppressionTimer(this, &Document::visualUpdatesSuppressionTimerFired)
-    , m_sharedObjectPoolClearTimer(this, &Document::sharedObjectPoolClearTimerFired)
+    , m_visualUpdatesSuppressionTimer(*this, &Document::visualUpdatesSuppressionTimerFired)
+    , m_sharedObjectPoolClearTimer(*this, &Document::sharedObjectPoolClearTimerFired)
  #ifndef NDEBUG
      , m_didDispatchViewportPropertiesChanged(false)
  #endif
@@ -512,8 +512,8 @@ Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsig
  #if ENABLE(WEB_REPLAY)
      , m_inputCursor(EmptyInputCursor::create())
  #endif
-    , m_didAssociateFormControlsTimer(this, &Document::didAssociateFormControlsTimerFired)
-    , m_cookieCacheExpiryTimer(this, &Document::domCookieCacheExpiryTimerFired)
+    , m_didAssociateFormControlsTimer(*this, &Document::didAssociateFormControlsTimerFired)
+    , m_cookieCacheExpiryTimer(*this, &Document::domCookieCacheExpiryTimerFired)
      , m_disabledFieldsetElementsCount(0)
      , m_hasInjectedPlugInsScript(false)
      , m_renderTreeBeingDestroyed(false)
@@ -1264,7 +1264,7 @@ void Document::setVisualUpdatesAllowed(bool visualUpdatesAllowed)
          frame->loader().forcePageTransitionIfNeeded();
  }
  
-void Document::visualUpdatesSuppressionTimerFired(Timer&)
+void Document::visualUpdatesSuppressionTimerFired()
  {
      ASSERT(!m_visualUpdatesAllowed);
  
@@ -1745,7 +1745,7 @@ bool Document::hasPendingForcedStyleRecalc() const
      return m_styleRecalcTimer.isActive() && m_pendingStyleRecalcShouldForce;
  }
  
-void Document::styleRecalcTimerFired(Timer&)
+void Document::styleRecalcTimerFired()
  {
      updateStyleIfNeeded();
  }
@@ -3244,7 +3244,7 @@ void Document::evaluateMediaQueryList()
          m_mediaQueryMatcher->styleResolverChanged();
  }
  
-void Document::optimizedStyleSheetUpdateTimerFired(Timer&)
+void Document::optimizedStyleSheetUpdateTimerFired()
  {
      styleResolverChanged(RecalcStyleIfNeeded);
  }
@@ -4629,7 +4629,7 @@ void Document::finishedParsing()
      m_cachedResourceLoader->clearPreloads();
  }
  
-void Document::sharedObjectPoolClearTimerFired(Timer&)
+void Document::sharedObjectPoolClearTimerFired()
  {
      m_sharedObjectPool = nullptr;
  }
@@ -4868,7 +4868,7 @@ void Document::cancelFocusAppearanceUpdate()
      m_updateFocusAppearanceTimer.stop();
  }
  
-void Document::updateFocusAppearanceTimerFired(Timer&)
+void Document::updateFocusAppearanceTimerFired()
  {
      Element* element = focusedElement();
      if (!element)
@@ -5023,7 +5023,7 @@ void Document::postTask(Task task)
      });
  }
  
-void Document::pendingTasksTimerFired(Timer&)
+void Document::pendingTasksTimerFired()
  {
      Vector<Task> pendingTasks = WTF::move(m_pendingTasks);
      for (auto& task : pendingTasks)
@@ -5474,7 +5474,7 @@ void Document::webkitWillEnterFullScreenForElement(Element* element)
      recalcStyle(Style::Force);
  
      if (settings() && settings()->needsSiteSpecificQuirks() && hostIsYouTube(url().host()))
-        fullScreenChangeDelayTimerFired(m_fullScreenChangeDelayTimer);
+        fullScreenChangeDelayTimerFired();
  }
  
  void Document::webkitDidEnterFullScreenForElement(Element*)
@@ -5528,7 +5528,7 @@ void Document::webkitDidExitFullScreenForElement(Element*)
      // FIXME(136605): Remove this quirk once YouTube moves to relative widths and heights for
      // fullscreen mode.
      if (settings() && settings()->needsSiteSpecificQuirks() && hostIsYouTube(url().host()))
-        exitingDocument.fullScreenChangeDelayTimerFired(exitingDocument.m_fullScreenChangeDelayTimer);
+        exitingDocument.fullScreenChangeDelayTimerFired();
      else
          exitingDocument.m_fullScreenChangeDelayTimer.startOneShot(0);
  
@@ -5558,7 +5558,7 @@ void Document::fullScreenRendererDestroyed()
      m_fullScreenRenderer = nullptr;
  }
  
-void Document::fullScreenChangeDelayTimerFired(Timer&)
+void Document::fullScreenChangeDelayTimerFired()
  {
      // 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
@@ -5696,7 +5696,7 @@ void Document::decrementLoadEventDelayCount()
          m_loadEventDelayTimer.startOneShot(0);
  }
  
-void Document::loadEventDelayTimerFired(Timer&)
+void Document::loadEventDelayTimerFired()
  {
      if (frame())
          frame()->loader().checkCompleted();
@@ -6212,10 +6212,8 @@ void Document::didAssociateFormControl(Element* element)
          m_didAssociateFormControlsTimer.startOneShot(0);
  }
  
-void Document::didAssociateFormControlsTimerFired(Timer& timer)
+void Document::didAssociateFormControlsTimerFired()
  {
-    ASSERT_UNUSED(timer, &timer == &m_didAssociateFormControlsTimer);
-
      if (!frame() || !frame()->page())
          return;
  
@@ -6240,7 +6238,7 @@ void Document::invalidateDOMCookieCache()
      m_cachedDOMCookies = String();
  }
  
-void Document::domCookieCacheExpiryTimerFired(Timer&)
+void Document::domCookieCacheExpiryTimerFired()
  {
      invalidateDOMCookieCache();
  }
diff --git a/Source/WebCore/dom/Document.h b/Source/WebCore/dom/Document.h

index 8b413e62632afe31736590e5a2123cd817facc6d..2609670bb732458202d0d6e344ca6ffa8524c6c4 100644 (file)
--- a/Source/WebCore/dom/Document.h
+++ b/Source/WebCore/dom/Document.h
@@ -773,8 +773,8 @@ public:
      void unscheduleStyleRecalc();
      bool hasPendingStyleRecalc() const;
      bool hasPendingForcedStyleRecalc() const;
-    void styleRecalcTimerFired(Timer&);
-    void optimizedStyleSheetUpdateTimerFired(Timer&);
+    void styleRecalcTimerFired();
+    void optimizedStyleSheetUpdateTimerFired();
  
      void registerNodeListForInvalidation(LiveNodeList&);
      void unregisterNodeListForInvalidation(LiveNodeList&);
@@ -1142,7 +1142,7 @@ public:
      RenderFullScreen* fullScreenRenderer() const { return m_fullScreenRenderer; }
      void fullScreenRendererDestroyed();
      
-    void fullScreenChangeDelayTimerFired(Timer&);
+    void fullScreenChangeDelayTimerFired();
      bool fullScreenIsAllowedForElement(Element*) const;
      void fullScreenElementRemoved();
      void removeFullScreenElementOfSubtree(Node*, bool amongChildrenOnly = false);
@@ -1334,16 +1334,16 @@ private:
      virtual double timerAlignmentInterval() const override final;
  
      void updateTitle(const StringWithDirection&);
-    void updateFocusAppearanceTimerFired(Timer&);
+    void updateFocusAppearanceTimerFired();
      void updateBaseURL();
  
      void buildAccessKeyMap(TreeScope* root);
  
      void createStyleResolver();
  
-    void loadEventDelayTimerFired(Timer&);
+    void loadEventDelayTimerFired();
  
-    void pendingTasksTimerFired(Timer&);
+    void pendingTasksTimerFired();
  
      template <typename CharacterType>
      void displayBufferModifiedByEncodingInternal(CharacterType*, unsigned) const;
@@ -1364,18 +1364,18 @@ private:
  
      void setVisualUpdatesAllowed(ReadyState);
      void setVisualUpdatesAllowed(bool);
-    void visualUpdatesSuppressionTimerFired(Timer&);
+    void visualUpdatesSuppressionTimerFired();
  
      void addListenerType(ListenerType listenerType) { m_listenerTypes |= listenerType; }
  
-    void didAssociateFormControlsTimerFired(Timer&);
+    void didAssociateFormControlsTimerFired();
  
      // 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&);
+    void domCookieCacheExpiryTimerFired();
      virtual void didLoadResourceSynchronously(const ResourceRequest&) override final;
  
      unsigned m_referencingNodeCount;
@@ -1683,7 +1683,7 @@ private:
      RefPtr<DOMSecurityPolicy> m_domSecurityPolicy;
  #endif
  
-    void sharedObjectPoolClearTimerFired(Timer&);
+    void sharedObjectPoolClearTimerFired();
      Timer m_sharedObjectPoolClearTimer;
  
      std::unique_ptr<DocumentSharedObjectPool> m_sharedObjectPool;
diff --git a/Source/WebCore/dom/EventSender.h b/Source/WebCore/dom/EventSender.h

index 550021ab1986e2036fcd44c029acc43fa89a773a..7cd82e114918d572b1a6296b53ee94b7ff4307a9 100644 (file)
--- a/Source/WebCore/dom/EventSender.h
+++ b/Source/WebCore/dom/EventSender.h
@@ -49,7 +49,7 @@ public:
  #endif
  
  private:
-    void timerFired(Timer&) { dispatchPendingEvents(); }
+    void timerFired() { dispatchPendingEvents(); }
  
      AtomicString m_eventType;
      Timer m_timer;
@@ -59,7 +59,7 @@ private:
  
  template<typename T> EventSender<T>::EventSender(const AtomicString& eventType)
      : m_eventType(eventType)
-    , m_timer(this, &EventSender::timerFired)
+    , m_timer(*this, &EventSender::timerFired)
  {
  }
  
diff --git a/Source/WebCore/dom/ScriptRunner.cpp b/Source/WebCore/dom/ScriptRunner.cpp

index 096e3c517c9f0ff80bc4c78bb28191293145b7aa..ed94da3e73db130178b99ea4b7f92b5ac19809d6 100644 (file)
--- a/Source/WebCore/dom/ScriptRunner.cpp
+++ b/Source/WebCore/dom/ScriptRunner.cpp
@@ -35,7 +35,7 @@ namespace WebCore {
  
  ScriptRunner::ScriptRunner(Document& document)
      : m_document(document)
-    , m_timer(this, &ScriptRunner::timerFired)
+    , m_timer(*this, &ScriptRunner::timerFired)
  {
  }
  
@@ -96,10 +96,8 @@ void ScriptRunner::notifyScriptReady(ScriptElement* scriptElement, ExecutionType
      m_timer.startOneShot(0);
  }
  
-void ScriptRunner::timerFired(Timer& timer)
+void ScriptRunner::timerFired()
  {
-    ASSERT_UNUSED(timer, &timer == &m_timer);
-
      Ref<Document> protect(m_document);
  
      Vector<PendingScript> scripts;
diff --git a/Source/WebCore/dom/ScriptRunner.h b/Source/WebCore/dom/ScriptRunner.h

index e13df8e07c311a5ac7a03e88848bf417dfbcb516..27cdbf8b3af569462e5b9aeb16cd765050891e0d 100644 (file)
--- a/Source/WebCore/dom/ScriptRunner.h
+++ b/Source/WebCore/dom/ScriptRunner.h
@@ -54,7 +54,7 @@ public:
      void notifyScriptReady(ScriptElement*, ExecutionType);
  
  private:
-    void timerFired(Timer&);
+    void timerFired();
  
      Document& m_document;
      Vector<PendingScript> m_scriptsToExecuteInOrder;
diff --git a/Source/WebCore/dom/ScriptedAnimationController.cpp b/Source/WebCore/dom/ScriptedAnimationController.cpp

index 78562e70cb1079381ace0f85ad7cbb19e73852e5..df4d446ed9c5327112891095294d19ef7c61b784 100644 (file)
--- a/Source/WebCore/dom/ScriptedAnimationController.cpp
+++ b/Source/WebCore/dom/ScriptedAnimationController.cpp
@@ -54,7 +54,7 @@ ScriptedAnimationController::ScriptedAnimationController(Document* document, Pla
      , m_nextCallbackId(0)
      , m_suspendCount(0)
  #if USE(REQUEST_ANIMATION_FRAME_TIMER)
-    , m_animationTimer(this, &ScriptedAnimationController::animationTimerFired)
+    , m_animationTimer(*this, &ScriptedAnimationController::animationTimerFired)
      , m_lastAnimationFrameTimeMonotonic(0)
  #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
      , m_isUsingTimer(false)
@@ -211,7 +211,7 @@ void ScriptedAnimationController::scheduleAnimation()
  }
  
  #if USE(REQUEST_ANIMATION_FRAME_TIMER)
-void ScriptedAnimationController::animationTimerFired(Timer&)
+void ScriptedAnimationController::animationTimerFired()
  {
      m_lastAnimationFrameTimeMonotonic = monotonicallyIncreasingTime();
      serviceScriptedAnimations(m_lastAnimationFrameTimeMonotonic);
diff --git a/Source/WebCore/dom/ScriptedAnimationController.h b/Source/WebCore/dom/ScriptedAnimationController.h

index 002c71efbdfba340277cb621ca7164b6dd608e42..69b6dc2c4431a8fba23e84366f2d1be15996bea6 100644 (file)
--- a/Source/WebCore/dom/ScriptedAnimationController.h
+++ b/Source/WebCore/dom/ScriptedAnimationController.h
@@ -84,7 +84,7 @@ private:
      void scheduleAnimation();
  
  #if USE(REQUEST_ANIMATION_FRAME_TIMER)
-    void animationTimerFired(Timer&);
+    void animationTimerFired();
      Timer m_animationTimer;
      double m_lastAnimationFrameTimeMonotonic;
  
diff --git a/Source/WebCore/dom/StyledElement.cpp b/Source/WebCore/dom/StyledElement.cpp

index 3a246b426c04f88771d69e4a8eb793ea20247df3..a8d3e6f7d6f2d2a65e65dcbdbab6514ed5c52f1e 100644 (file)
--- a/Source/WebCore/dom/StyledElement.cpp
+++ b/Source/WebCore/dom/StyledElement.cpp
@@ -79,7 +79,7 @@ class PresentationAttributeCacheCleaner {
  public:
      PresentationAttributeCacheCleaner()
          : m_hitCount(0)
-        , m_cleanTimer(this, &PresentationAttributeCacheCleaner::cleanCache)
+        , m_cleanTimer(*this, &PresentationAttributeCacheCleaner::cleanCache)
      {
      }
  
@@ -99,9 +99,8 @@ private:
      static const int minimumPresentationAttributeCacheSizeForCleaning = 100;
      static const unsigned minimumPresentationAttributeCacheHitCountPerMinute = (100 * presentationAttributeCacheCleanTimeInSeconds) / 60;
  
-    void cleanCache(Timer* timer)
+    void cleanCache()
      {
-        ASSERT_UNUSED(timer, timer == &m_cleanTimer);
          unsigned hitCount = m_hitCount;
          m_hitCount = 0;
          if (hitCount > minimumPresentationAttributeCacheHitCountPerMinute)
diff --git a/Source/WebCore/editing/AlternativeTextController.cpp b/Source/WebCore/editing/AlternativeTextController.cpp

index 973613d4af56c3275debb256fe0f32e7ca407726..0ef7bda83450250f0dac00cffc019d15f12b811e 100644 (file)
--- a/Source/WebCore/editing/AlternativeTextController.cpp
+++ b/Source/WebCore/editing/AlternativeTextController.cpp
@@ -129,7 +129,7 @@ static bool markersHaveIdenticalDescription(const Vector<RenderedDocumentMarker*
  }
  
  AlternativeTextController::AlternativeTextController(Frame& frame)
-    : m_timer(this, &AlternativeTextController::timerFired)
+    : m_timer(*this, &AlternativeTextController::timerFired)
      , m_frame(frame)
  {
  }
@@ -327,7 +327,7 @@ void AlternativeTextController::respondToUnappliedSpellCorrection(const VisibleS
      markers.addMarker(range.get(), DocumentMarker::SpellCheckingExemption);
  }
  
-void AlternativeTextController::timerFired(Timer&)
+void AlternativeTextController::timerFired()
  {
      m_isDismissedByEditing = false;
      switch (m_alternativeTextInfo.type) {
diff --git a/Source/WebCore/editing/AlternativeTextController.h b/Source/WebCore/editing/AlternativeTextController.h

index f12f81a807b836e87b328322c96fc5d35df30688..b106ac552198feff12f006cdc3320317da049fea 100644 (file)
--- a/Source/WebCore/editing/AlternativeTextController.h
+++ b/Source/WebCore/editing/AlternativeTextController.h
@@ -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&);
+    void timerFired();
      void recordAutocorrectionResponseReversed(const String& replacedString, const String& replacementString);
      void recordSpellcheckerResponseForModifiedCorrection(Range* rangeOfCorrection, const String& corrected, const String& correction);
      String markerDescriptionForAppliedAlternativeText(AlternativeTextType, DocumentMarker::MarkerType);
diff --git a/Source/WebCore/editing/Editor.cpp b/Source/WebCore/editing/Editor.cpp

index b82e2cc119c54856d185dbf80b514ff441408617..ed63a2873f0f8f7b13fb588f3331c0077e5854cc 100644 (file)
--- a/Source/WebCore/editing/Editor.cpp
+++ b/Source/WebCore/editing/Editor.cpp
@@ -1076,11 +1076,11 @@ Editor::Editor(Frame& frame)
      , m_areMarkedTextMatchesHighlighted(false)
      , m_defaultParagraphSeparator(EditorParagraphSeparatorIsDiv)
      , m_overwriteModeEnabled(false)
-    , m_editorUIUpdateTimer(this, &Editor::editorUIUpdateTimerFired)
+    , m_editorUIUpdateTimer(*this, &Editor::editorUIUpdateTimerFired)
      , m_editorUIUpdateTimerShouldCheckSpellingAndGrammar(false)
      , m_editorUIUpdateTimerWasTriggeredByDictation(false)
  #if ENABLE(TELEPHONE_NUMBER_DETECTION) && !PLATFORM(IOS)
-    , m_telephoneNumberDetectionUpdateTimer(this, &Editor::scanSelectionForTelephoneNumbers)
+    , m_telephoneNumberDetectionUpdateTimer(*this, &Editor::scanSelectionForTelephoneNumbers)
  #endif
  {
  }
@@ -3270,11 +3270,6 @@ bool Editor::shouldDetectTelephoneNumbers()
      return document().isTelephoneNumberParsingEnabled() && TelephoneNumberDetector::isSupported();
  }
  
-void Editor::scanSelectionForTelephoneNumbers(Timer&)
-{
-    scanSelectionForTelephoneNumbers();
-}
-
  void Editor::scanSelectionForTelephoneNumbers()
  {
      if (!shouldDetectTelephoneNumbers() || !client())
@@ -3374,10 +3369,10 @@ void Editor::updateEditorUINowIfScheduled()
      if (!m_editorUIUpdateTimer.isActive())
          return;
      m_editorUIUpdateTimer.stop();
-    editorUIUpdateTimerFired(m_editorUIUpdateTimer);
+    editorUIUpdateTimerFired();
  }
  
-void Editor::editorUIUpdateTimerFired(Timer&)
+void Editor::editorUIUpdateTimerFired()
  {
      VisibleSelection oldSelection = m_oldSelectionForEditorUIUpdate;
  
diff --git a/Source/WebCore/editing/Editor.h b/Source/WebCore/editing/Editor.h

index 8be1f73b9a043d8dcd4816b809d81e558c0cf707..671f4c3c573b833cd4c0f15960be2274e2d00675 100644 (file)
--- a/Source/WebCore/editing/Editor.h
+++ b/Source/WebCore/editing/Editor.h
@@ -472,7 +472,7 @@ private:
      enum EditorActionSpecifier { CutAction, CopyAction };
      void performCutOrCopy(EditorActionSpecifier);
  
-    void editorUIUpdateTimerFired(Timer&);
+    void editorUIUpdateTimerFired();
  
      Node* findEventTargetFromSelection() const;
  
@@ -510,7 +510,6 @@ private:
  
  #if ENABLE(TELEPHONE_NUMBER_DETECTION) && !PLATFORM(IOS)
      bool shouldDetectTelephoneNumbers();
-    void scanSelectionForTelephoneNumbers(Timer&);
      void scanRangeForTelephoneNumbers(Range&, const StringView&, Vector<RefPtr<Range>>& markedRanges);
  
      Timer m_telephoneNumberDetectionUpdateTimer;
diff --git a/Source/WebCore/editing/FrameSelection.cpp b/Source/WebCore/editing/FrameSelection.cpp

index 8f60d02956d8ac906615da2cae0281d0dd48a256..af4bd178bddf246fe7785e18a870998fc2502c6e 100644 (file)
--- a/Source/WebCore/editing/FrameSelection.cpp
+++ b/Source/WebCore/editing/FrameSelection.cpp
@@ -111,7 +111,7 @@ FrameSelection::FrameSelection(Frame* frame)
      : m_frame(frame)
      , m_xPosForVerticalArrowNavigation(NoXPosForVerticalArrowNavigation())
      , m_granularity(CharacterGranularity)
-    , m_caretBlinkTimer(this, &FrameSelection::caretBlinkTimerFired)
+    , m_caretBlinkTimer(*this, &FrameSelection::caretBlinkTimerFired)
      , m_absCaretBoundsDirty(true)
      , m_caretPaint(true)
      , m_isCaretBlinkingSuspended(false)
@@ -1890,7 +1890,7 @@ void FrameSelection::setCaretVisibility(CaretVisibility visibility)
      updateAppearance();
  }
  
-void FrameSelection::caretBlinkTimerFired(Timer&)
+void FrameSelection::caretBlinkTimerFired()
  {
  #if ENABLE(TEXT_CARET)
      ASSERT(caretIsVisible());
diff --git a/Source/WebCore/editing/FrameSelection.h b/Source/WebCore/editing/FrameSelection.h

index 6a87760e90a1d0801f0777a9cc2ceafcfc2b1a63..e52e79a659f0afe8d961ff1a4443c74d685a5d47 100644 (file)
--- a/Source/WebCore/editing/FrameSelection.h
+++ b/Source/WebCore/editing/FrameSelection.h
@@ -310,7 +310,7 @@ private:
      void setFocusedElementIfNeeded();
      void focusedOrActiveStateChanged();
  
-    void caretBlinkTimerFired(Timer&);
+    void caretBlinkTimerFired();
  
      void setCaretVisibility(CaretVisibility);
      bool recomputeCaretRect();
diff --git a/Source/WebCore/editing/SpellChecker.cpp b/Source/WebCore/editing/SpellChecker.cpp

index ae83212139767066e01b29cf059d894f66e26ec7..7ce296896dc96424b4d305e6643f93a7e61a32b1 100644 (file)
--- a/Source/WebCore/editing/SpellChecker.cpp
+++ b/Source/WebCore/editing/SpellChecker.cpp
@@ -107,7 +107,7 @@ SpellChecker::SpellChecker(Frame& frame)
      : m_frame(frame)
      , m_lastRequestSequence(0)
      , m_lastProcessedSequence(0)
-    , m_timerToProcessQueuedRequest(this, &SpellChecker::timerFiredToProcessQueuedRequest)
+    , m_timerToProcessQueuedRequest(*this, &SpellChecker::timerFiredToProcessQueuedRequest)
  {
  }
  
@@ -127,7 +127,7 @@ TextCheckerClient* SpellChecker::client() const
      return page->editorClient()->textChecker();
  }
  
-void SpellChecker::timerFiredToProcessQueuedRequest(Timer*)
+void SpellChecker::timerFiredToProcessQueuedRequest()
  {
      ASSERT(!m_requestQueue.isEmpty());
      if (m_requestQueue.isEmpty())
diff --git a/Source/WebCore/editing/SpellChecker.h b/Source/WebCore/editing/SpellChecker.h

index 008e328f6448020e2b69de6abd4820778ceebf19..6353f7094830c8f276d193fc253d370eb08281d3 100644 (file)
--- a/Source/WebCore/editing/SpellChecker.h
+++ b/Source/WebCore/editing/SpellChecker.h
@@ -98,7 +98,7 @@ private:
  
      bool canCheckAsynchronously(Range*) const;
      TextCheckerClient* client() const;
-    void timerFiredToProcessQueuedRequest(Timer*);
+    void timerFiredToProcessQueuedRequest();
      void invokeRequest(PassRefPtr<SpellCheckRequest>);
      void enqueueRequest(PassRefPtr<SpellCheckRequest>);
      void didCheckSucceed(int sequence, const Vector<TextCheckingResult>&);
diff --git a/Source/WebCore/html/HTMLFormElement.cpp b/Source/WebCore/html/HTMLFormElement.cpp

index f66e9dd5aec199f3c9370ff8d90b33fbff19491d..e3497ee2758b76e5d1d1b2082e3ecd0b129b50eb 100644 (file)
--- a/Source/WebCore/html/HTMLFormElement.cpp
+++ b/Source/WebCore/html/HTMLFormElement.cpp
@@ -65,7 +65,7 @@ HTMLFormElement::HTMLFormElement(const QualifiedName& tagName, Document& documen
      , m_isInResetFunction(false)
      , m_wasDemoted(false)
  #if ENABLE(REQUEST_AUTOCOMPLETE)
-    , m_requestAutocompleteTimer(this, &HTMLFormElement::requestAutocompleteTimerFired)
+    , m_requestAutocompletetimer(*this, &HTMLFormElement::requestAutocompleteTimerFired)
  #endif
  {
      ASSERT(hasTagName(formTag));
@@ -472,7 +472,7 @@ void HTMLFormElement::finishRequestAutocomplete(AutocompleteResult result)
          m_requestAutocompleteTimer.startOneShot(0);
  }
  
-void HTMLFormElement::requestAutocompleteTimerFired(Timer*)
+void HTMLFormElement::requestAutocompleteTimerFired()
  {
      Vector<RefPtr<Event>> pendingEvents;
      m_pendingAutocompleteEvents.swap(pendingEvents);
diff --git a/Source/WebCore/html/HTMLFormElement.h b/Source/WebCore/html/HTMLFormElement.h

index e545c7742530ff685181fbfbc74cc71fb1988d6e..8cbe9207bc39dc2fa6c9d3e996270de7be56e686 100644 (file)
--- a/Source/WebCore/html/HTMLFormElement.h
+++ b/Source/WebCore/html/HTMLFormElement.h
@@ -194,7 +194,7 @@ private:
      bool m_wasDemoted;
  
  #if ENABLE(REQUEST_AUTOCOMPLETE)
-    void requestAutocompleteTimerFired(Timer*);
+    void requestAutocompleteTimerFired();
  
      Vector<RefPtr<Event>> m_pendingAutocompleteEvents;
      Timer m_requestAutocompleteTimer;
diff --git a/Source/WebCore/html/HTMLMediaElement.cpp b/Source/WebCore/html/HTMLMediaElement.cpp

index ca5f0ae14285d5d35c523868de4006fa42daca48..87dfb1d726d733659e52b3f1106560dc9cb56e35 100644 (file)
--- a/Source/WebCore/html/HTMLMediaElement.cpp
+++ b/Source/WebCore/html/HTMLMediaElement.cpp
@@ -254,11 +254,11 @@ private:
  HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName, Document& document, bool createdByParser)
      : HTMLElement(tagName, document)
      , ActiveDOMObject(&document)
-    , m_loadTimer(this, &HTMLMediaElement::loadTimerFired)
-    , m_progressEventTimer(this, &HTMLMediaElement::progressEventTimerFired)
-    , m_playbackProgressTimer(this, &HTMLMediaElement::playbackProgressTimerFired)
-    , m_scanTimer(this, &HTMLMediaElement::scanTimerFired)
-    , m_seekTimer(this, &HTMLMediaElement::seekTimerFired)
+    , m_loadTimer(*this, &HTMLMediaElement::loadTimerFired)
+    , m_progressEventTimer(*this, &HTMLMediaElement::progressEventTimerFired)
+    , m_playbackProgressTimer(*this, &HTMLMediaElement::playbackProgressTimerFired)
+    , m_scanTimer(*this, &HTMLMediaElement::scanTimerFired)
+    , m_seekTimer(*this, &HTMLMediaElement::seekTimerFired)
      , m_playedTimeRanges()
      , m_asyncEventQueue(*this)
      , m_playbackRate(1.0f)
@@ -757,7 +757,7 @@ void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)
      m_asyncEventQueue.enqueueEvent(event.release());
  }
  
-void HTMLMediaElement::loadTimerFired(Timer&)
+void HTMLMediaElement::loadTimerFired()
  {
      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&)
+void HTMLMediaElement::progressEventTimerFired()
  {
      ASSERT(m_player);
      if (m_networkState != NETWORK_LOADING)
@@ -2360,10 +2360,10 @@ void HTMLMediaElement::seekWithTolerance(const MediaTime& inTime, const MediaTim
      if (fromDOM)
          m_seekTimer.startOneShot(0);
      else
-        seekTimerFired(m_seekTimer);
+        seekTimerFired();
  }
  
-void HTMLMediaElement::seekTimerFired(Timer&)
+void HTMLMediaElement::seekTimerFired()
  {
      if (!m_player) {
          m_seeking = false;
@@ -3107,7 +3107,7 @@ double HTMLMediaElement::nextScanRate()
      return rate;
  }
  
-void HTMLMediaElement::scanTimerFired(Timer&)
+void HTMLMediaElement::scanTimerFired()
  {
      if (m_scanType == Seek) {
          double seekTime = m_scanDirection == Forward ? SeekTime : -SeekTime;
@@ -3129,7 +3129,7 @@ void HTMLMediaElement::startPlaybackProgressTimer()
      m_playbackProgressTimer.startRepeating(maxTimeupdateEventFrequency);
  }
  
-void HTMLMediaElement::playbackProgressTimerFired(Timer&)
+void HTMLMediaElement::playbackProgressTimerFired()
  {
      ASSERT(m_player);
  
diff --git a/Source/WebCore/html/HTMLMediaElement.h b/Source/WebCore/html/HTMLMediaElement.h

index 719d716c87d7ab939ff95518997d8c676f6a9e4e..4829e0d55c319daa16737f08d2dc8da72ce57bdb 100644 (file)
--- a/Source/WebCore/html/HTMLMediaElement.h
+++ b/Source/WebCore/html/HTMLMediaElement.h
@@ -595,11 +595,11 @@ private:
      virtual bool mediaPlayerIsInMediaDocument() const override final;
      virtual void mediaPlayerEngineFailedToLoad() const override final;
  
-    void loadTimerFired(Timer&);
-    void progressEventTimerFired(Timer&);
-    void playbackProgressTimerFired(Timer&);
-    void scanTimerFired(Timer&);
-    void seekTimerFired(Timer&);
+    void loadTimerFired();
+    void progressEventTimerFired();
+    void playbackProgressTimerFired();
+    void scanTimerFired();
+    void seekTimerFired();
      void startPlaybackProgressTimer();
      void startProgressEventTimer();
      void stopPeriodicTimers();
diff --git a/Source/WebCore/html/HTMLPlugInElement.cpp b/Source/WebCore/html/HTMLPlugInElement.cpp

index 5240e9f3267af419603fe942af19a11651ace275..ecbde4b1057a834a09eff91fa83927ec7b030de4 100644 (file)
--- a/Source/WebCore/html/HTMLPlugInElement.cpp
+++ b/Source/WebCore/html/HTMLPlugInElement.cpp
@@ -67,7 +67,7 @@ using namespace HTMLNames;
  HTMLPlugInElement::HTMLPlugInElement(const QualifiedName& tagName, Document& document)
      : HTMLFrameOwnerElement(tagName, document)
      , m_inBeforeLoadEventHandler(false)
-    , m_swapRendererTimer(this, &HTMLPlugInElement::swapRendererTimerFired)
+    , m_swapRendererTimer(*this, &HTMLPlugInElement::swapRendererTimerFired)
  #if ENABLE(NETSCAPE_PLUGIN_API)
      , m_NPObject(0)
  #endif
@@ -300,7 +300,7 @@ RenderPtr<RenderElement> HTMLPlugInElement::createElementRenderer(PassRef<Render
      return createRenderer<RenderEmbeddedObject>(*this, WTF::move(style));
  }
  
-void HTMLPlugInElement::swapRendererTimerFired(Timer&)
+void HTMLPlugInElement::swapRendererTimerFired()
  {
      ASSERT(displayState() == PreparingPluginReplacement || displayState() == DisplayingSnapshot);
      if (userAgentShadowRoot())
diff --git a/Source/WebCore/html/HTMLPlugInElement.h b/Source/WebCore/html/HTMLPlugInElement.h

index d7e367574f41442a5131e288819a030e1ebed291..8c195f84d4c8e6b294db3c2b5352bd1b555d0604 100644 (file)
--- a/Source/WebCore/html/HTMLPlugInElement.h
+++ b/Source/WebCore/html/HTMLPlugInElement.h
@@ -112,7 +112,7 @@ protected:
      bool m_inBeforeLoadEventHandler;
  
  private:
-    void swapRendererTimerFired(Timer&);
+    void swapRendererTimerFired();
      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.
diff --git a/Source/WebCore/html/HTMLPlugInImageElement.cpp b/Source/WebCore/html/HTMLPlugInImageElement.cpp

index 67208855948035981abbe8608d8b91a5ff234c2d..fac66b8ba700c48922aa9c17b753f94eb2611dbe 100644 (file)
--- a/Source/WebCore/html/HTMLPlugInImageElement.cpp
+++ b/Source/WebCore/html/HTMLPlugInImageElement.cpp
@@ -107,8 +107,8 @@ HTMLPlugInImageElement::HTMLPlugInImageElement(const QualifiedName& tagName, Doc
      , m_needsWidgetUpdate(!createdByParser)
      , m_shouldPreferPlugInsForImages(preferPlugInsForImagesOption == ShouldPreferPlugInsForImages)
      , m_needsDocumentActivationCallbacks(false)
-    , m_simulatedMouseClickTimer(this, &HTMLPlugInImageElement::simulatedMouseClickTimerFired, simulatedMouseClickTimerDelay)
-    , m_removeSnapshotTimer(this, &HTMLPlugInImageElement::removeSnapshotTimerFired)
+    , m_simulatedMouseClickTimer(*this, &HTMLPlugInImageElement::simulatedMouseClickTimerFired, simulatedMouseClickTimerDelay)
+    , m_removeSnapshotTimer(*this, &HTMLPlugInImageElement::removeSnapshotTimerFired)
      , m_createdDuringUserGesture(ScriptController::processingUserGesture())
      , m_isRestartedPlugin(false)
      , m_needsCheckForSizeChange(false)
@@ -399,7 +399,7 @@ bool HTMLPlugInImageElement::partOfSnapshotOverlay(Node* node)
      return node && snapshotLabel && (node == snapshotLabel.get() || node->isDescendantOf(snapshotLabel.get()));
  }
  
-void HTMLPlugInImageElement::removeSnapshotTimerFired(Timer&)
+void HTMLPlugInImageElement::removeSnapshotTimerFired()
  {
      m_snapshotImage = nullptr;
      m_isRestartedPlugin = false;
diff --git a/Source/WebCore/html/HTMLPlugInImageElement.h b/Source/WebCore/html/HTMLPlugInImageElement.h

index f17ef6e88ed0054b5ae2e75eac15402438aee8bb..820fb722ad2674450f91bbbe1e7205d492dc3230 100644 (file)
--- a/Source/WebCore/html/HTMLPlugInImageElement.h
+++ b/Source/WebCore/html/HTMLPlugInImageElement.h
@@ -136,7 +136,7 @@ private:
      void simulatedMouseClickTimerFired();
  
      void restartSimilarPlugIns();
-    void removeSnapshotTimerFired(Timer&);
+    void removeSnapshotTimerFired();
      bool isTopLevelFullPagePlugin(const RenderEmbeddedObject&) const;
  
      URL m_loadedUrl;
diff --git a/Source/WebCore/html/HTMLSourceElement.cpp b/Source/WebCore/html/HTMLSourceElement.cpp

index fd196399270fd6b1affa844978ca82ce16e62c73..f0b7e4a43db1653d77cf0f575b8ec89291744ea4 100644 (file)
--- a/Source/WebCore/html/HTMLSourceElement.cpp
+++ b/Source/WebCore/html/HTMLSourceElement.cpp
@@ -40,7 +40,7 @@ using namespace HTMLNames;
  
  inline HTMLSourceElement::HTMLSourceElement(const QualifiedName& tagName, Document& document)
      : HTMLElement(tagName, document)
-    , m_errorEventTimer(this, &HTMLSourceElement::errorEventTimerFired)
+    , m_errorEventTimer(*this, &HTMLSourceElement::errorEventTimerFired)
  {
      LOG(Media, "HTMLSourceElement::HTMLSourceElement - %p", this);
      ASSERT(hasTagName(sourceTag));
@@ -110,7 +110,7 @@ void HTMLSourceElement::cancelPendingErrorEvent()
      m_errorEventTimer.stop();
  }
  
-void HTMLSourceElement::errorEventTimerFired(Timer&)
+void HTMLSourceElement::errorEventTimerFired()
  {
      LOG(Media, "HTMLSourceElement::errorEventTimerFired - %p", this);
      dispatchEvent(Event::create(eventNames().errorEvent, false, true));
diff --git a/Source/WebCore/html/HTMLSourceElement.h b/Source/WebCore/html/HTMLSourceElement.h

index 11c55a0f894d80fd12100dca008b9926bfcd8d3b..4ca528d281b6d5ecb6e302afbea0d5bd0999a224 100644 (file)
--- a/Source/WebCore/html/HTMLSourceElement.h
+++ b/Source/WebCore/html/HTMLSourceElement.h
@@ -52,7 +52,7 @@ private:
      virtual void removedFrom(ContainerNode&) override;
      virtual bool isURLAttribute(const Attribute&) const override;
  
-    void errorEventTimerFired(Timer&);
+    void errorEventTimerFired();
  
      Timer m_errorEventTimer;
  };
diff --git a/Source/WebCore/html/HTMLTrackElement.cpp b/Source/WebCore/html/HTMLTrackElement.cpp

index 7491388aabbf95426eaa1b33bf141e74548246ab..07c2cc86fbffc1524c5c6481ce9a336b9e3de844 100644 (file)
--- a/Source/WebCore/html/HTMLTrackElement.cpp
+++ b/Source/WebCore/html/HTMLTrackElement.cpp
@@ -52,7 +52,7 @@ static String urlForLoggingTrack(const URL& url)
      
  inline HTMLTrackElement::HTMLTrackElement(const QualifiedName& tagName, Document& document)
      : HTMLElement(tagName, document)
-    , m_loadTimer(this, &HTMLTrackElement::loadTimerFired)
+    , m_loadTimer(*this, &HTMLTrackElement::loadTimerFired)
  {
      LOG(Media, "HTMLTrackElement::HTMLTrackElement - %p", this);
      ASSERT(hasTagName(trackTag));
@@ -200,7 +200,7 @@ void HTMLTrackElement::scheduleLoad()
      m_loadTimer.startOneShot(0);
  }
  
-void HTMLTrackElement::loadTimerFired(Timer&)
+void HTMLTrackElement::loadTimerFired()
  {
      if (!fastHasAttribute(srcAttr))
          return;
diff --git a/Source/WebCore/html/HTMLTrackElement.h b/Source/WebCore/html/HTMLTrackElement.h

index 121b9c3605fffcebf4c0571ff3a786ecb4bcc909..44889a5d868f5ecff52d1a9c1767b6e4a06bcb40 100644 (file)
--- a/Source/WebCore/html/HTMLTrackElement.h
+++ b/Source/WebCore/html/HTMLTrackElement.h
@@ -75,7 +75,7 @@ private:
  
      virtual bool isURLAttribute(const Attribute&) const override;
  
-    void loadTimerFired(Timer&);
+    void loadTimerFired();
  
      HTMLMediaElement* mediaElement() const;
  
diff --git a/Source/WebCore/html/MediaController.cpp b/Source/WebCore/html/MediaController.cpp

index 413167448fdffb015919eca275cd0e6ef70e8a76..990daea0b9f015b8d99e7441fde4a5caf443641c 100644 (file)
--- a/Source/WebCore/html/MediaController.cpp
+++ b/Source/WebCore/html/MediaController.cpp
@@ -50,12 +50,12 @@ MediaController::MediaController(ScriptExecutionContext& context)
      , m_muted(false)
      , m_readyState(HAVE_NOTHING)
      , m_playbackState(WAITING)
-    , m_asyncEventTimer(this, &MediaController::asyncEventTimerFired)
-    , m_clearPositionTimer(this, &MediaController::clearPositionTimerFired)
+    , m_asyncEventTimer(*this, &MediaController::asyncEventTimerFired)
+    , m_clearPositionTimer(*this, &MediaController::clearPositionTimerFired)
      , m_closedCaptionsVisible(false)
      , m_clock(Clock::create())
      , m_scriptExecutionContext(context)
-    , m_timeupdateTimer(this, &MediaController::timeupdateTimerFired)
+    , m_timeupdateTimer(*this, &MediaController::timeupdateTimerFired)
      , m_previousTimeupdateTime(0)
  {
  }
@@ -538,7 +538,7 @@ void MediaController::scheduleEvent(const AtomicString& eventName)
          m_asyncEventTimer.startOneShot(0);
  }
  
-void MediaController::asyncEventTimerFired(Timer&)
+void MediaController::asyncEventTimerFired()
  {
      Vector<RefPtr<Event>> pendingEvents;
  
@@ -548,7 +548,7 @@ void MediaController::asyncEventTimerFired(Timer&)
          dispatchEvent(pendingEvents[index].release(), IGNORE_EXCEPTION);
  }
  
-void MediaController::clearPositionTimerFired(Timer&)
+void MediaController::clearPositionTimerFired()
  {
      m_position = MediaPlayer::invalidTime();
  }
@@ -672,7 +672,7 @@ void MediaController::startTimeupdateTimer()
      m_timeupdateTimer.startRepeating(maxTimeupdateEventFrequency);
  }
  
-void MediaController::timeupdateTimerFired(Timer&)
+void MediaController::timeupdateTimerFired()
  {
      scheduleTimeupdateEvent();
  }
diff --git a/Source/WebCore/html/MediaController.h b/Source/WebCore/html/MediaController.h

index 25419cbb83844ba444215374a553f6fecce758e1..1d9c1b3e10054ffaf1193f0a7d36e7a3590afff7 100644 (file)
--- a/Source/WebCore/html/MediaController.h
+++ b/Source/WebCore/html/MediaController.h
@@ -123,11 +123,11 @@ private:
      void updateMediaElements();
      void bringElementUpToSpeed(HTMLMediaElement*);
      void scheduleEvent(const AtomicString& eventName);
-    void asyncEventTimerFired(Timer&);
-    void clearPositionTimerFired(Timer&);
+    void asyncEventTimerFired();
+    void clearPositionTimerFired();
      bool hasEnded() const;
      void scheduleTimeupdateEvent();
-    void timeupdateTimerFired(Timer&);
+    void timeupdateTimerFired();
      void startTimeupdateTimer();
  
      // EventTarget
diff --git a/Source/WebCore/html/MediaDocument.cpp b/Source/WebCore/html/MediaDocument.cpp

index d6569a43baecd3036871211b5f9eaa43953e5db3..d2c7a5f3cfa27b8c376a9fa94ae9ea33a6749432 100644 (file)
--- a/Source/WebCore/html/MediaDocument.cpp
+++ b/Source/WebCore/html/MediaDocument.cpp
@@ -140,7 +140,7 @@ void MediaDocumentParser::appendBytes(DocumentWriter&, const char*, size_t)
      
  MediaDocument::MediaDocument(Frame* frame, const URL& url)
      : HTMLDocument(frame, url, MediaDocumentClass)
-    , m_replaceMediaElementTimer(this, &MediaDocument::replaceMediaElementTimerFired)
+    , m_replaceMediaElementTimer(*this, &MediaDocument::replaceMediaElementTimerFired)
  {
      setCompatibilityMode(DocumentCompatibilityMode::QuirksMode);
      lockCompatibilityMode();
@@ -231,7 +231,7 @@ void MediaDocument::mediaElementSawUnsupportedTracks()
      m_replaceMediaElementTimer.startOneShot(0);
  }
  
-void MediaDocument::replaceMediaElementTimerFired(Timer&)
+void MediaDocument::replaceMediaElementTimerFired()
  {
      HTMLElement* htmlBody = body();
      if (!htmlBody)
diff --git a/Source/WebCore/html/MediaDocument.h b/Source/WebCore/html/MediaDocument.h

index 43b5f46c62dd0f1c9f387336c48e376c2bc24199..9d71ce28df9aef8e51739da93e160ff28444fbc3 100644 (file)
--- a/Source/WebCore/html/MediaDocument.h
+++ b/Source/WebCore/html/MediaDocument.h
@@ -50,7 +50,7 @@ private:
  
      virtual void defaultEventHandler(Event*) override;
  
-    void replaceMediaElementTimerFired(Timer&);
+    void replaceMediaElementTimerFired();
  
      Timer m_replaceMediaElementTimer;
      String m_outgoingReferrer;
diff --git a/Source/WebCore/html/SearchInputType.cpp b/Source/WebCore/html/SearchInputType.cpp

index 0bf9dfc34ab5afd263098032b9c0fdc163137d13..fa68b2434cd580f3a8705bf3cff680748b3c6278 100644 (file)
--- a/Source/WebCore/html/SearchInputType.cpp
+++ b/Source/WebCore/html/SearchInputType.cpp
@@ -48,7 +48,7 @@ SearchInputType::SearchInputType(HTMLInputElement& element)
      : BaseTextInputType(element)
      , m_resultsButton(nullptr)
      , m_cancelButton(nullptr)
-    , m_searchEventTimer(this, &SearchInputType::searchEventTimerFired)
+    , m_searchEventTimer(*this, &SearchInputType::searchEventTimerFired)
  {
  }
  
@@ -173,7 +173,7 @@ void SearchInputType::stopSearchEventTimer()
      m_searchEventTimer.stop();
  }
  
-void SearchInputType::searchEventTimerFired(Timer*)
+void SearchInputType::searchEventTimerFired()
  {
      element().onSearch();
  }
diff --git a/Source/WebCore/html/SearchInputType.h b/Source/WebCore/html/SearchInputType.h

index 883a12b1760bd6ae96ca6896bab2e19b059d9238..15ddf928d3847d60dce3385f9bdd1b2324cbcd33 100644 (file)
--- a/Source/WebCore/html/SearchInputType.h
+++ b/Source/WebCore/html/SearchInputType.h
@@ -61,7 +61,7 @@ private:
      virtual bool sizeShouldIncludeDecoration(int defaultSize, int& preferredSize) const override;
      virtual float decorationWidth() const override;
  
-    void searchEventTimerFired(Timer*);
+    void searchEventTimerFired();
      bool searchEventsShouldBeDispatched() const;
      void startSearchEventTimer();
  
diff --git a/Source/WebCore/html/ValidationMessage.cpp b/Source/WebCore/html/ValidationMessage.cpp

index ab9618d9d898202baa8b7a131dc7ce5efc177076..8fbc0e893eb9642fcedf304c95695fcfdf50f6ec 100644 (file)
--- a/Source/WebCore/html/ValidationMessage.cpp
+++ b/Source/WebCore/html/ValidationMessage.cpp
@@ -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>(this, &ValidationMessage::buildBubbleTree);
+        m_timer = std::make_unique<Timer>(*this, &ValidationMessage::buildBubbleTree);
      else
-        m_timer = std::make_unique<Timer>(this, &ValidationMessage::setMessageDOMAndStartTimer);
+        m_timer = std::make_unique<Timer>(*this, &ValidationMessage::setMessageDOMAndStartTimer);
      m_timer->startOneShot(0);
  }
  
-void ValidationMessage::setMessageDOMAndStartTimer(Timer*)
+void ValidationMessage::setMessageDOMAndStartTimer()
  {
      ASSERT(!validationMessageClient());
      ASSERT(m_messageHeading);
@@ -136,7 +136,7 @@ void ValidationMessage::setMessageDOMAndStartTimer(Timer*)
      if (magnification <= 0)
          m_timer = nullptr;
      else {
-        m_timer = std::make_unique<Timer>(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*)
+void ValidationMessage::buildBubbleTree()
  {
      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>(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*)
+void ValidationMessage::deleteBubbleTree()
  {
      ASSERT(!validationMessageClient());
      if (m_bubble) {
diff --git a/Source/WebCore/html/ValidationMessage.h b/Source/WebCore/html/ValidationMessage.h

index 9d61857c7f469ceb3fea2ddc0d8585844879af92..2820b2f9cc3cf4f129e572efa15b1e354d8a0946 100644 (file)
--- a/Source/WebCore/html/ValidationMessage.h
+++ b/Source/WebCore/html/ValidationMessage.h
@@ -60,9 +60,9 @@ public:
  private:
      ValidationMessageClient* validationMessageClient() const;
      void setMessage(const String&);
-    void setMessageDOMAndStartTimer(Timer* = 0);
-    void buildBubbleTree(Timer*);
-    void deleteBubbleTree(Timer* = 0);
+    void setMessageDOMAndStartTimer();
+    void buildBubbleTree();
+    void deleteBubbleTree();
  
      HTMLFormControlElement* m_element;
      String m_message;
diff --git a/Source/WebCore/html/canvas/WebGLRenderingContext.cpp b/Source/WebCore/html/canvas/WebGLRenderingContext.cpp

index 0be1d40271f5e1f41806c06412d74b78481367d9..e95bd6a9f95ae0e0fb7ae0ff9662d32d571ccdce 100644 (file)
--- a/Source/WebCore/html/canvas/WebGLRenderingContext.cpp
+++ b/Source/WebCore/html/canvas/WebGLRenderingContext.cpp
@@ -467,9 +467,9 @@ WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, Gr
      , ActiveDOMObject(&passedCanvas->document())
      , m_context(0)
      , m_drawingBuffer(0)
-    , m_dispatchContextLostEventTimer(this, &WebGLRenderingContext::dispatchContextLostEvent)
+    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContext::dispatchContextLostEvent)
      , m_restoreAllowed(false)
-    , m_restoreTimer(this, &WebGLRenderingContext::maybeRestoreContext)
+    , m_restoreTimer(*this, &WebGLRenderingContext::maybeRestoreContext)
      , m_generatedImageCache(0)
      , m_contextLost(false)
      , m_contextLostMode(SyntheticLostContext)
@@ -487,9 +487,9 @@ WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, Pa
      , ActiveDOMObject(&passedCanvas->document())
      , m_context(context)
      , m_drawingBuffer(0)
-    , m_dispatchContextLostEventTimer(this, &WebGLRenderingContext::dispatchContextLostEvent)
+    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContext::dispatchContextLostEvent)
      , m_restoreAllowed(false)
-    , m_restoreTimer(this, &WebGLRenderingContext::maybeRestoreContext)
+    , m_restoreTimer(*this, &WebGLRenderingContext::maybeRestoreContext)
      , m_generatedImageCache(4)
      , m_contextLost(false)
      , m_contextLostMode(SyntheticLostContext)
@@ -5923,7 +5923,7 @@ void WebGLRenderingContext::restoreStatesAfterVertexAttrib0Simulation()
      m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(m_boundArrayBuffer.get()));
  }
  
-void WebGLRenderingContext::dispatchContextLostEvent(Timer*)
+void WebGLRenderingContext::dispatchContextLostEvent()
  {
      RefPtr<WebGLContextEvent> event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, "");
      canvas()->dispatchEvent(event);
@@ -5932,7 +5932,7 @@ void WebGLRenderingContext::dispatchContextLostEvent(Timer*)
          m_restoreTimer.startOneShot(0);
  }
  
-void WebGLRenderingContext::maybeRestoreContext(Timer*)
+void WebGLRenderingContext::maybeRestoreContext()
  {
      ASSERT(m_contextLost);
      if (!m_contextLost)
diff --git a/Source/WebCore/html/canvas/WebGLRenderingContext.h b/Source/WebCore/html/canvas/WebGLRenderingContext.h

index 348befb44e3114da6e5b40e0953265f311a3ef70..faf58468063de2dbf80dee4dca2b7df3b8f8cab5 100644 (file)
--- a/Source/WebCore/html/canvas/WebGLRenderingContext.h
+++ b/Source/WebCore/html/canvas/WebGLRenderingContext.h
@@ -761,9 +761,9 @@ private:
      bool simulateVertexAttrib0(GC3Dsizei numVertex);
      void restoreStatesAfterVertexAttrib0Simulation();
  
-    void dispatchContextLostEvent(Timer*);
+    void dispatchContextLostEvent();
      // Helper for restoration after context lost.
-    void maybeRestoreContext(Timer*);
+    void maybeRestoreContext();
  
      // Determine if we are running privileged code in the browser, for example,
      // a Safari or Chrome extension.
diff --git a/Source/WebCore/html/parser/HTMLParserScheduler.cpp b/Source/WebCore/html/parser/HTMLParserScheduler.cpp

index 82781100905ca041454a29b8aa82d08c5a40d05d..0e42fdef0b26c31b52164645c9d991eaeb480568 100644 (file)
--- a/Source/WebCore/html/parser/HTMLParserScheduler.cpp
+++ b/Source/WebCore/html/parser/HTMLParserScheduler.cpp
@@ -88,7 +88,7 @@ HTMLParserScheduler::HTMLParserScheduler(HTMLDocumentParser& parser)
      : m_parser(parser)
      , m_parserTimeLimit(parserTimeLimit(m_parser.document()->page()))
      , m_parserChunkSize(defaultParserChunkSize)
-    , m_continueNextChunkTimer(this, &HTMLParserScheduler::continueNextChunkTimerFired)
+    , m_continueNextChunkTimer(*this, &HTMLParserScheduler::continueNextChunkTimerFired)
      , m_isSuspendedWithActiveTimer(false)
  #if !ASSERT_DISABLED
      , m_suspended(false)
@@ -101,10 +101,9 @@ HTMLParserScheduler::~HTMLParserScheduler()
      m_continueNextChunkTimer.stop();
  }
  
-void HTMLParserScheduler::continueNextChunkTimerFired(Timer& timer)
+void HTMLParserScheduler::continueNextChunkTimerFired()
  {
      ASSERT(!m_suspended);
-    ASSERT_UNUSED(timer, &timer == &m_continueNextChunkTimer);
  
      // FIXME: The timer class should handle timer priorities instead of this code.
      // If a layout is scheduled, wait again to let the layout timer run first.
diff --git a/Source/WebCore/html/parser/HTMLParserScheduler.h b/Source/WebCore/html/parser/HTMLParserScheduler.h

index ab7e2ed81d1d90d720e77a534f1d8b3b20b67f6d..8bfdcc0caf64a51f890514e5990b6b9e01cfda6b 100644 (file)
--- a/Source/WebCore/html/parser/HTMLParserScheduler.h
+++ b/Source/WebCore/html/parser/HTMLParserScheduler.h
@@ -97,7 +97,7 @@ public:
      void resume();
  
  private:
-    void continueNextChunkTimerFired(Timer&);
+    void continueNextChunkTimerFired();
  
      HTMLDocumentParser& m_parser;
  
diff --git a/Source/WebCore/html/shadow/MediaControlElements.cpp b/Source/WebCore/html/shadow/MediaControlElements.cpp

index fc35832359bd9b8c61f84e7d12c4e007936f0d4c..c034141b028b5ad1ff941ef1ba005505ceb692f0 100644 (file)
--- a/Source/WebCore/html/shadow/MediaControlElements.cpp
+++ b/Source/WebCore/html/shadow/MediaControlElements.cpp
@@ -74,7 +74,7 @@ MediaControlPanelElement::MediaControlPanelElement(Document& document)
      , m_isBeingDragged(false)
      , m_isDisplayed(false)
      , m_opaque(true)
-    , m_transitionTimer(this, &MediaControlPanelElement::transitionTimerFired)
+    , m_transitionTimer(*this, &MediaControlPanelElement::transitionTimerFired)
  {
      setPseudo(AtomicString("-webkit-media-controls-panel", AtomicString::ConstructFromLiteral));
  }
@@ -149,7 +149,7 @@ void MediaControlPanelElement::stopTimer()
          m_transitionTimer.stop();
  }
  
-void MediaControlPanelElement::transitionTimerFired(Timer&)
+void MediaControlPanelElement::transitionTimerFired()
  {
      if (!m_opaque)
          hide();
@@ -1073,7 +1073,7 @@ static const AtomicString& getMediaControlCurrentTimeDisplayElementShadowPseudoI
  
  MediaControlTextTrackContainerElement::MediaControlTextTrackContainerElement(Document& document)
      : MediaControlDivElement(document, MediaTextTrackDisplayContainer)
-    , m_updateTimer(this, &MediaControlTextTrackContainerElement::updateTimerFired)
+    , m_updateTimer(*this, &MediaControlTextTrackContainerElement::updateTimerFired)
      , m_fontSize(0)
      , m_fontSizeIsImportant(false)
      , m_updateTextTrackRepresentationStyle(false)
@@ -1243,7 +1243,7 @@ void MediaControlTextTrackContainerElement::updateActiveCuesFontSize()
  
  }
  
-void MediaControlTextTrackContainerElement::updateTimerFired(Timer&)
+void MediaControlTextTrackContainerElement::updateTimerFired()
  {
      if (!document().page())
          return;
diff --git a/Source/WebCore/html/shadow/MediaControlElements.h b/Source/WebCore/html/shadow/MediaControlElements.h

index ccb499683bfc7549a5650ccae15f243c9b66a3bd..e452c325cd2c6949eb4d28322ccc06a2b2c21621 100644 (file)
--- a/Source/WebCore/html/shadow/MediaControlElements.h
+++ b/Source/WebCore/html/shadow/MediaControlElements.h
@@ -65,7 +65,7 @@ private:
  
      void startTimer();
      void stopTimer();
-    void transitionTimerFired(Timer&);
+    void transitionTimerFired();
  
      void setPosition(const LayoutPoint&);
  
@@ -451,7 +451,7 @@ public:
      void exitedFullscreen();
  
  private:
-    void updateTimerFired(Timer&);
+    void updateTimerFired();
      void updateActiveCuesFontSize();
  
      explicit MediaControlTextTrackContainerElement(Document&);
diff --git a/Source/WebCore/html/shadow/MediaControls.cpp b/Source/WebCore/html/shadow/MediaControls.cpp

index 787220fee0bcff71087a2b3ac0d5543c182815c5..3dd6de86da1fccd1fe1a060853d47123a4a70d98 100644 (file)
--- a/Source/WebCore/html/shadow/MediaControls.cpp
+++ b/Source/WebCore/html/shadow/MediaControls.cpp
@@ -48,7 +48,7 @@ MediaControls::MediaControls(Document& document)
      , m_volumeSlider(0)
      , m_toggleClosedCaptionsButton(0)
      , m_fullScreenButton(0)
-    , m_hideFullscreenControlsTimer(this, &MediaControls::hideFullscreenControlsTimerFired)
+    , m_hideFullscreenControlsTimer(*this, &MediaControls::hideFullscreenControlsTimerFired)
      , m_isFullscreen(false)
      , m_isMouseOverControls(false)
  {
@@ -330,7 +330,7 @@ void MediaControls::defaultEventHandler(Event* event)
      }
  }
  
-void MediaControls::hideFullscreenControlsTimerFired(Timer&)
+void MediaControls::hideFullscreenControlsTimerFired()
  {
      if (m_mediaController->paused())
          return;
diff --git a/Source/WebCore/html/shadow/MediaControls.h b/Source/WebCore/html/shadow/MediaControls.h

index a644c8ea927a37139062436e13f394c4590b169b..41aee5387b99788f6481d9d32ca3dde1b65f3082 100644 (file)
--- a/Source/WebCore/html/shadow/MediaControls.h
+++ b/Source/WebCore/html/shadow/MediaControls.h
@@ -97,7 +97,7 @@ class MediaControls : public HTMLDivElement {
      virtual bool willRespondToMouseMoveEvents() override { return true; }
  #endif
  
-    virtual void hideFullscreenControlsTimerFired(Timer&);
+    virtual void hideFullscreenControlsTimerFired();
      virtual void startHideFullscreenControlsTimer();
      virtual void stopHideFullscreenControlsTimer();
  
diff --git a/Source/WebCore/html/shadow/SpinButtonElement.cpp b/Source/WebCore/html/shadow/SpinButtonElement.cpp

index 9836965f71d45e8142f5106c0652b7c2525934c3..cf506a897c5788170588c2d644770b73f3505559 100644 (file)
--- a/Source/WebCore/html/shadow/SpinButtonElement.cpp
+++ b/Source/WebCore/html/shadow/SpinButtonElement.cpp
@@ -49,7 +49,7 @@ inline SpinButtonElement::SpinButtonElement(Document& document, SpinButtonOwner&
      , m_capturing(false)
      , m_upDownState(Indeterminate)
      , m_pressStartingState(Indeterminate)
-    , m_repeatingTimer(this, &SpinButtonElement::repeatingTimerFired)
+    , m_repeatingTimer(*this, &SpinButtonElement::repeatingTimerFired)
  {
      setHasCustomStyleResolveCallbacks();
      setPseudo(AtomicString("-webkit-inner-spin-button", AtomicString::ConstructFromLiteral));
@@ -230,7 +230,7 @@ void SpinButtonElement::step(int amount)
      doStepAction(amount);
  }
      
-void SpinButtonElement::repeatingTimerFired(Timer*)
+void SpinButtonElement::repeatingTimerFired()
  {
      if (m_upDownState != Indeterminate)
          step(m_upDownState == Up ? 1 : -1);
diff --git a/Source/WebCore/html/shadow/SpinButtonElement.h b/Source/WebCore/html/shadow/SpinButtonElement.h

index 18cfa2d5ecb40b66e1dcb2bca3a6bac1f1828343..ae1ef1ec09010b117573a171e132263186179615 100644 (file)
--- a/Source/WebCore/html/shadow/SpinButtonElement.h
+++ b/Source/WebCore/html/shadow/SpinButtonElement.h
@@ -78,7 +78,7 @@ private:
      void doStepAction(int);
      void startRepeatingTimer();
      void stopRepeatingTimer();
-    void repeatingTimerFired(Timer*);
+    void repeatingTimerFired();
      virtual void setHovered(bool = true) override;
      bool shouldRespondToMouseEvents();
      virtual bool isMouseFocusable() const override { return false; }
diff --git a/Source/WebCore/html/track/LoadableTextTrack.cpp b/Source/WebCore/html/track/LoadableTextTrack.cpp

index bdc4dfa0d1ef75fe6a0509c328fc5488b3c189ff..5ff12b76fee4e956b462a08179695d88226c2ea9 100644 (file)
--- a/Source/WebCore/html/track/LoadableTextTrack.cpp
+++ b/Source/WebCore/html/track/LoadableTextTrack.cpp
@@ -43,7 +43,7 @@ namespace WebCore {
  LoadableTextTrack::LoadableTextTrack(HTMLTrackElement* track, const String& kind, const String& label, const String& language)
      : TextTrack(&track->document(), track, kind, emptyString(), label, language, TrackElement)
      , m_trackElement(track)
-    , m_loadTimer(this, &LoadableTextTrack::loadTimerFired)
+    , m_loadTimer(*this, &LoadableTextTrack::loadTimerFired)
      , m_isDefault(false)
  {
  }
@@ -85,7 +85,7 @@ void LoadableTextTrack::setTrackElement(HTMLTrackElement* element)
      m_trackElement = element;
  }
  
-void LoadableTextTrack::loadTimerFired(Timer&)
+void LoadableTextTrack::loadTimerFired()
  {
      if (m_loader)
          m_loader->cancelLoad();
diff --git a/Source/WebCore/html/track/LoadableTextTrack.h b/Source/WebCore/html/track/LoadableTextTrack.h

index aad2a0826fea6b0434bf9f65ea846361112d0bec..17c67dfc3afb93552db3ad267657d6e6ee475ac9 100644 (file)
--- a/Source/WebCore/html/track/LoadableTextTrack.h
+++ b/Source/WebCore/html/track/LoadableTextTrack.h
@@ -70,7 +70,7 @@ private:
  
      LoadableTextTrack(HTMLTrackElement*, const String& kind, const String& label, const String& language);
  
-    void loadTimerFired(Timer&);
+    void loadTimerFired();
  
      HTMLTrackElement* m_trackElement;
      Timer m_loadTimer;
diff --git a/Source/WebCore/html/track/VTTRegion.cpp b/Source/WebCore/html/track/VTTRegion.cpp

index 38a1c6ae1ad23f0aa14d7773d99cf25d6d264089..7a049fc7730db91860a84786c0cc250134b3fc29 100644 (file)
--- a/Source/WebCore/html/track/VTTRegion.cpp
+++ b/Source/WebCore/html/track/VTTRegion.cpp
@@ -83,7 +83,7 @@ VTTRegion::VTTRegion(ScriptExecutionContext& context)
      , m_regionDisplayTree(nullptr)
      , m_track(nullptr)
      , m_currentTop(0)
-    , m_scrollTimer(this, &VTTRegion::scrollTimerFired)
+    , m_scrollTimer(*this, &VTTRegion::scrollTimerFired)
  {
  }
  
@@ -478,7 +478,7 @@ void VTTRegion::stopTimer()
          m_scrollTimer.stop();
  }
  
-void VTTRegion::scrollTimerFired(Timer*)
+void VTTRegion::scrollTimerFired()
  {
      LOG(Media, "VTTRegion::scrollTimerFired");
  
diff --git a/Source/WebCore/html/track/VTTRegion.h b/Source/WebCore/html/track/VTTRegion.h

index 04133851d6c89bcd2671585d43a4ccd59adeae40..ea58b842afd40ecd85741544e334d239d2138109 100644 (file)
--- a/Source/WebCore/html/track/VTTRegion.h
+++ b/Source/WebCore/html/track/VTTRegion.h
@@ -105,7 +105,7 @@ private:
      // The timer is needed to continue processing when cue scrolling ended.
      void startTimer();
      void stopTimer();
-    void scrollTimerFired(Timer*);
+    void scrollTimerFired();
  
      enum RegionSetting {
          None,
diff --git a/Source/WebCore/inspector/InspectorCSSAgent.cpp b/Source/WebCore/inspector/InspectorCSSAgent.cpp

index 41531648414a13121f971a225b3c0fefac823828..f814be44f9e171281ee3cc7fd848980d81a8b097 100644 (file)
--- a/Source/WebCore/inspector/InspectorCSSAgent.cpp
+++ b/Source/WebCore/inspector/InspectorCSSAgent.cpp
@@ -110,7 +110,7 @@ public:
      void scheduleFor(WebKitNamedFlow*, int documentNodeId);
      void unschedule(WebKitNamedFlow*);
      void reset();
-    void timerFired(Timer&);
+    void timerFired();
  
  private:
      InspectorCSSAgent* m_cssAgent;
@@ -120,7 +120,7 @@ private:
  
  ChangeRegionOversetTask::ChangeRegionOversetTask(InspectorCSSAgent* cssAgent)
      : m_cssAgent(cssAgent)
-    , m_timer(this, &ChangeRegionOversetTask::timerFired)
+    , m_timer(*this, &ChangeRegionOversetTask::timerFired)
  {
  }
  
@@ -143,7 +143,7 @@ void ChangeRegionOversetTask::reset()
      m_namedFlows.clear();
  }
  
-void ChangeRegionOversetTask::timerFired(Timer&)
+void ChangeRegionOversetTask::timerFired()
  {
      // 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)
diff --git a/Source/WebCore/inspector/InspectorDOMAgent.cpp b/Source/WebCore/inspector/InspectorDOMAgent.cpp

index 3375473c9b4389c750939692008ad45ea2a0dc0c..8bc4cd7991c888fdf81af8ababa18b9bff76a17f 100644 (file)
--- a/Source/WebCore/inspector/InspectorDOMAgent.cpp
+++ b/Source/WebCore/inspector/InspectorDOMAgent.cpp
@@ -162,7 +162,7 @@ public:
      RevalidateStyleAttributeTask(InspectorDOMAgent*);
      void scheduleFor(Element*);
      void reset() { m_timer.stop(); }
-    void timerFired(Timer&);
+    void timerFired();
  
  private:
      InspectorDOMAgent* m_domAgent;
@@ -172,7 +172,7 @@ private:
  
  RevalidateStyleAttributeTask::RevalidateStyleAttributeTask(InspectorDOMAgent* domAgent)
      : m_domAgent(domAgent)
-    , m_timer(this, &RevalidateStyleAttributeTask::timerFired)
+    , m_timer(*this, &RevalidateStyleAttributeTask::timerFired)
  {
  }
  
@@ -183,7 +183,7 @@ void RevalidateStyleAttributeTask::scheduleFor(Element* element)
          m_timer.startOneShot(0);
  }
  
-void RevalidateStyleAttributeTask::timerFired(Timer&)
+void RevalidateStyleAttributeTask::timerFired()
  {
      // The timer is stopped on m_domAgent destruction, so this method will never be called after m_domAgent has been destroyed.
      Vector<Element*> elements;
diff --git a/Source/WebCore/inspector/InspectorFrontendClientLocal.cpp b/Source/WebCore/inspector/InspectorFrontendClientLocal.cpp

index 6b97823cbdcce6499715ee234aa5fcfab2df73f9..3e70819aee1b3bd1e5d4d5ae1598972b7f7bffbf 100644 (file)
--- a/Source/WebCore/inspector/InspectorFrontendClientLocal.cpp
+++ b/Source/WebCore/inspector/InspectorFrontendClientLocal.cpp
@@ -74,7 +74,7 @@ class InspectorBackendDispatchTask {
  public:
      InspectorBackendDispatchTask(InspectorController* inspectorController)
          : m_inspectorController(inspectorController)
-        , m_timer(this, &InspectorBackendDispatchTask::timerFired)
+        , m_timer(*this, &InspectorBackendDispatchTask::timerFired)
      {
      }
  
@@ -91,7 +91,7 @@ public:
          m_timer.stop();
      }
  
-    void timerFired(Timer&)
+    void timerFired()
      {
          if (!m_messages.isEmpty()) {
              // Dispatch can lead to the timer destruction -> schedule the next shot first.
diff --git a/Source/WebCore/inspector/InspectorOverlay.cpp b/Source/WebCore/inspector/InspectorOverlay.cpp

index 1ed1e974749ba2d9a3b0424e140ea51f67e2d82b..725f698b9ed47631b8bdc219a06b45e5b8f75482 100644 (file)
--- a/Source/WebCore/inspector/InspectorOverlay.cpp
+++ b/Source/WebCore/inspector/InspectorOverlay.cpp
@@ -203,7 +203,7 @@ static void buildQuadHighlight(const FloatQuad& quad, const HighlightConfig& hig
  InspectorOverlay::InspectorOverlay(Page& page, InspectorClient* client)
      : m_page(page)
      , m_client(client)
-    , m_paintRectUpdateTimer(this, &InspectorOverlay::updatePaintRectsTimerFired)
+    , m_paintRectUpdateTimer(*this, &InspectorOverlay::updatePaintRectsTimerFired)
      , m_indicating(false)
      , m_showingPaintRects(false)
  {
@@ -505,7 +505,7 @@ void InspectorOverlay::showPaintRect(const FloatRect& rect)
      forcePaint();
  }
  
-void InspectorOverlay::updatePaintRectsTimerFired(Timer&)
+void InspectorOverlay::updatePaintRectsTimerFired()
  {
      std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
      bool rectsChanged = false;
diff --git a/Source/WebCore/inspector/InspectorOverlay.h b/Source/WebCore/inspector/InspectorOverlay.h

index 8908292c8f660b7c912cd8853814fa986462725b..4efb4585e72aaff2aa6b5928747bf1d85a23111f 100644 (file)
--- a/Source/WebCore/inspector/InspectorOverlay.h
+++ b/Source/WebCore/inspector/InspectorOverlay.h
@@ -139,7 +139,7 @@ private:
      void drawQuadHighlight();
      void drawPausedInDebuggerMessage();
      void drawPaintRects();
-    void updatePaintRectsTimerFired(Timer&);
+    void updatePaintRectsTimerFired();
  
      Page* overlayPage();
  
diff --git a/Source/WebCore/loader/DocumentLoader.cpp b/Source/WebCore/loader/DocumentLoader.cpp

index e3cab78a6d2eb0f7c1a878d605bc1b2fac9bcb8a..f9116c0d4fdaede33f89b61d88b9720107c1274b 100644 (file)
--- a/Source/WebCore/loader/DocumentLoader.cpp
+++ b/Source/WebCore/loader/DocumentLoader.cpp
@@ -134,12 +134,12 @@ DocumentLoader::DocumentLoader(const ResourceRequest& req, const SubstituteData&
      , m_isLoadingMultipartContent(false)
      , m_wasOnloadHandled(false)
      , m_stopRecordingResponses(false)
-    , m_substituteResourceDeliveryTimer(this, &DocumentLoader::substituteResourceDeliveryTimerFired)
+    , m_substituteResourceDeliveryTimer(*this, &DocumentLoader::substituteResourceDeliveryTimerFired)
      , m_didCreateGlobalHistoryEntry(false)
      , m_loadingMainResource(false)
      , m_timeOfLastDataReceived(0.0)
      , m_identifierForLoadWithoutResourceLoader(0)
-    , m_dataLoadTimer(this, &DocumentLoader::handleSubstituteDataLoadNow)
+    , m_dataLoadTimer(*this, &DocumentLoader::handleSubstituteDataLoadNow)
      , m_waitingForContentPolicy(false)
      , m_subresourceLoadersArePageCacheAcceptable(false)
      , m_applicationCacheHost(adoptPtr(new ApplicationCacheHost(*this)))
@@ -466,7 +466,7 @@ bool DocumentLoader::isPostOrRedirectAfterPost(const ResourceRequest& newRequest
      return false;
  }
  
-void DocumentLoader::handleSubstituteDataLoadNow(DocumentLoaderTimer*)
+void DocumentLoader::handleSubstituteDataLoadNow()
  {
      URL url = m_substituteData.responseURL();
      if (url.isEmpty())
@@ -488,7 +488,7 @@ void DocumentLoader::startDataLoadTimer()
  void DocumentLoader::handleSubstituteDataLoadSoon()
  {
      if (!m_deferMainResourceDataLoad || frameLoader()->loadsSynchronously())
-        handleSubstituteDataLoadNow(0);
+        handleSubstituteDataLoadNow();
      else
          startDataLoadTimer();
  }
@@ -1125,7 +1125,7 @@ void DocumentLoader::deliverSubstituteResourcesAfterDelay()
          m_substituteResourceDeliveryTimer.startOneShot(0);
  }
  
-void DocumentLoader::substituteResourceDeliveryTimerFired(Timer&)
+void DocumentLoader::substituteResourceDeliveryTimerFired()
  {
      if (m_pendingSubstituteResources.isEmpty())
          return;
diff --git a/Source/WebCore/loader/DocumentLoader.h b/Source/WebCore/loader/DocumentLoader.h

index 50f04a1ce822ba63f03116736c30508910b0a1fa..7a06ac269c0fae0550b637759ccfa8049494e98e 100644 (file)
--- a/Source/WebCore/loader/DocumentLoader.h
+++ b/Source/WebCore/loader/DocumentLoader.h
@@ -316,11 +316,11 @@ namespace WebCore {
          typedef Timer DocumentLoaderTimer;
  #endif
          void handleSubstituteDataLoadSoon();
-        void handleSubstituteDataLoadNow(DocumentLoaderTimer*);
+        void handleSubstituteDataLoadNow();
          void startDataLoadTimer();
  
          void deliverSubstituteResourcesAfterDelay();
-        void substituteResourceDeliveryTimerFired(Timer&);
+        void substituteResourceDeliveryTimerFired();
  
          void clearMainResource();
  
diff --git a/Source/WebCore/loader/FrameLoader.cpp b/Source/WebCore/loader/FrameLoader.cpp

index f6d8614c067ca4daf2ecf4da077a70c3becd7c73..8e4daa72036762fe39eaeb2baad210b5024b67dc 100644 (file)
--- a/Source/WebCore/loader/FrameLoader.cpp
+++ b/Source/WebCore/loader/FrameLoader.cpp
@@ -236,7 +236,7 @@ FrameLoader::FrameLoader(Frame& frame, FrameLoaderClient& client)
      , m_pageDismissalEventBeingDispatched(NoDismissal)
      , m_isComplete(false)
      , m_needsClear(false)
-    , m_checkTimer(this, &FrameLoader::checkTimerFired)
+    , m_checkTimer(*this, &FrameLoader::checkTimerFired)
      , m_shouldCallCheckCompleted(false)
      , m_shouldCallCheckLoadComplete(false)
      , m_opener(nullptr)
@@ -850,7 +850,7 @@ void FrameLoader::checkCompleted()
          checkLoadComplete();
  }
  
-void FrameLoader::checkTimerFired(Timer&)
+void FrameLoader::checkTimerFired()
  {
      Ref<Frame> protect(m_frame);
  
diff --git a/Source/WebCore/loader/FrameLoader.h b/Source/WebCore/loader/FrameLoader.h

index 1560ca187ad24d455a84f85d01e9706e45827123..6de7d0edb55d107723bc2bfcab8f1b07a1dc09b6 100644 (file)
--- a/Source/WebCore/loader/FrameLoader.h
+++ b/Source/WebCore/loader/FrameLoader.h
@@ -299,7 +299,7 @@ private:
  
      bool allChildrenAreComplete() const; // immediate children, not all descendants
  
-    void checkTimerFired(Timer&);
+    void checkTimerFired();
      
      void loadSameDocumentItem(HistoryItem*);
      void loadDifferentDocumentItem(HistoryItem*, FrameLoadType, FormSubmissionCacheLoadPolicy);
diff --git a/Source/WebCore/loader/ImageLoader.cpp b/Source/WebCore/loader/ImageLoader.cpp

index 602fb9db1c6c19f2937804531f0b6d69e8003cdf..8b556ad32ea82e728f9579c91955c758f2c002f7 100644 (file)
--- a/Source/WebCore/loader/ImageLoader.cpp
+++ b/Source/WebCore/loader/ImageLoader.cpp
@@ -90,7 +90,7 @@ static inline bool pageIsBeingDismissed(Document& document)
  ImageLoader::ImageLoader(Element& element)
      : m_element(element)
      , m_image(0)
-    , m_derefElementTimer(this, &ImageLoader::timerFired)
+    , m_derefElementTimer(*this, &ImageLoader::timerFired)
      , m_hasPendingBeforeLoadEvent(false)
      , m_hasPendingLoadEvent(false)
      , m_hasPendingErrorEvent(false)
@@ -374,7 +374,7 @@ void ImageLoader::updatedHasPendingEvent()
      }   
  }
  
-void ImageLoader::timerFired(Timer&)
+void ImageLoader::timerFired()
  {
      element().deref();
  }
diff --git a/Source/WebCore/loader/ImageLoader.h b/Source/WebCore/loader/ImageLoader.h

index 83ad8dcf0531add8f0b093b44d3aa3e841aa4a2e..cfb48c3e88f452d402f19b70e61edbd9db58fc0b 100644 (file)
--- a/Source/WebCore/loader/ImageLoader.h
+++ b/Source/WebCore/loader/ImageLoader.h
@@ -91,7 +91,7 @@ private:
      void setImageWithoutConsideringPendingLoadEvent(CachedImage*);
      void clearFailedLoadURL();
  
-    void timerFired(Timer&);
+    void timerFired();
  
      Element& m_element;
      CachedResourceHandle<CachedImage> m_image;
diff --git a/Source/WebCore/loader/LinkLoader.cpp b/Source/WebCore/loader/LinkLoader.cpp

index 995fc705500e525cdea48a055f0ee45e4d72920f..ab9ebeaf8c6bf0656efa8b2ea6c360fda4e22c0e 100644 (file)
--- a/Source/WebCore/loader/LinkLoader.cpp
+++ b/Source/WebCore/loader/LinkLoader.cpp
@@ -49,8 +49,8 @@ namespace WebCore {
  
  LinkLoader::LinkLoader(LinkLoaderClient* client)
      : m_client(client)
-    , m_linkLoadTimer(this, &LinkLoader::linkLoadTimerFired)
-    , m_linkLoadingErrorTimer(this, &LinkLoader::linkLoadingErrorTimerFired)
+    , m_linkLoadTimer(*this, &LinkLoader::linkLoadTimerFired)
+    , m_linkLoadingErrorTimer(*this, &LinkLoader::linkLoadingErrorTimerFired)
  {
  }
  
@@ -60,15 +60,13 @@ LinkLoader::~LinkLoader()
          m_cachedLinkResource->removeClient(this);
  }
  
-void LinkLoader::linkLoadTimerFired(Timer& timer)
+void LinkLoader::linkLoadTimerFired()
  {
-    ASSERT_UNUSED(timer, &timer == &m_linkLoadTimer);
      m_client->linkLoaded();
  }
  
-void LinkLoader::linkLoadingErrorTimerFired(Timer& timer)
+void LinkLoader::linkLoadingErrorTimerFired()
  {
-    ASSERT_UNUSED(timer, &timer == &m_linkLoadingErrorTimer);
      m_client->linkLoadingErrored();
  }
  
diff --git a/Source/WebCore/loader/LinkLoader.h b/Source/WebCore/loader/LinkLoader.h

index ad4d579f08cce33753cae705cc9fa9cc36b319b2..740d2bcc93972190beac5d27dea881707671c26a 100644 (file)
--- a/Source/WebCore/loader/LinkLoader.h
+++ b/Source/WebCore/loader/LinkLoader.h
@@ -59,8 +59,8 @@ public:
      bool loadLink(const LinkRelAttribute&, const String& type, const String& sizes, const URL&, Document*);
  
  private:
-    void linkLoadTimerFired(Timer&);
-    void linkLoadingErrorTimerFired(Timer&);
+    void linkLoadTimerFired();
+    void linkLoadingErrorTimerFired();
  
      LinkLoaderClient* m_client;
  
diff --git a/Source/WebCore/loader/NavigationScheduler.cpp b/Source/WebCore/loader/NavigationScheduler.cpp

index ac6e08a87255ad91977c790334e559ee961ec8f2..91cba066d10481174610eb63478c8ae7d89ed92b 100644 (file)
--- a/Source/WebCore/loader/NavigationScheduler.cpp
+++ b/Source/WebCore/loader/NavigationScheduler.cpp
@@ -280,7 +280,7 @@ private:
  
  NavigationScheduler::NavigationScheduler(Frame& frame)
      : m_frame(frame)
-    , m_timer(this, &NavigationScheduler::timerFired)
+    , m_timer(*this, &NavigationScheduler::timerFired)
  {
  }
  
@@ -430,7 +430,7 @@ void NavigationScheduler::scheduleHistoryNavigation(int steps)
      schedule(std::make_unique<ScheduledHistoryNavigation>(steps));
  }
  
-void NavigationScheduler::timerFired(Timer&)
+void NavigationScheduler::timerFired()
  {
      if (!m_frame.page())
          return;
diff --git a/Source/WebCore/loader/NavigationScheduler.h b/Source/WebCore/loader/NavigationScheduler.h

index 356f188fb203b50838e1017a011844856c9eb62b..8522840af3242c27072c0cca43878614b30f17ff 100644 (file)
--- a/Source/WebCore/loader/NavigationScheduler.h
+++ b/Source/WebCore/loader/NavigationScheduler.h
@@ -83,7 +83,7 @@ private:
      bool shouldScheduleNavigation() const;
      bool shouldScheduleNavigation(const URL&) const;
  
-    void timerFired(Timer&);
+    void timerFired();
      void schedule(std::unique_ptr<ScheduledNavigation>);
  
      static LockBackForwardList mustLockBackForwardList(Frame& targetFrame);
diff --git a/Source/WebCore/loader/PingLoader.cpp b/Source/WebCore/loader/PingLoader.cpp

index fb69a75217021b65732bef1413e30be28498d237..5b3b991a8422ef6c4335f3123a173e1b99996153 100644 (file)
--- a/Source/WebCore/loader/PingLoader.cpp
+++ b/Source/WebCore/loader/PingLoader.cpp
@@ -115,7 +115,7 @@ void PingLoader::createPingLoader(Frame& frame, ResourceRequest& request)
  }
  
  PingLoader::PingLoader(Frame& frame, ResourceRequest& request)
-    : m_timeout(this, &PingLoader::timeoutTimerFired)
+    : m_timeout(*this, &PingLoader::timeoutTimerFired)
  {
      unsigned long identifier = frame.page()->progress().createUniqueIdentifier();
      // FIXME: Why activeDocumentLoader? I would have expected documentLoader().
diff --git a/Source/WebCore/loader/PingLoader.h b/Source/WebCore/loader/PingLoader.h

index b7b85efb3b2ff0fffe70a382f33e5ea78c329d65..515d97d74e3e91f8d12af985eaeaa5688d10e1d8 100644 (file)
--- a/Source/WebCore/loader/PingLoader.h
+++ b/Source/WebCore/loader/PingLoader.h
@@ -69,7 +69,7 @@ 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&) { delete this; }
+    void timeoutTimerFired() { delete this; }
  
      RefPtr<ResourceHandle> m_handle;
      Timer m_timeout;
diff --git a/Source/WebCore/loader/ProgressTracker.cpp b/Source/WebCore/loader/ProgressTracker.cpp

index e9e950400ceb6549ec68e3adcd68d1cc7d67a610..04054de4eab3951f95e07e9ded32dc916fd7ee06 100644 (file)
--- a/Source/WebCore/loader/ProgressTracker.cpp
+++ b/Source/WebCore/loader/ProgressTracker.cpp
@@ -85,7 +85,7 @@ ProgressTracker::ProgressTracker(ProgressTrackerClient& client)
      , m_finalProgressChangedSent(false)
      , m_progressValue(0)
      , m_numProgressTrackedFrames(0)
-    , m_progressHeartbeatTimer(this, &ProgressTracker::progressHeartbeatTimerFired)
+    , m_progressHeartbeatTimer(*this, &ProgressTracker::progressHeartbeatTimerFired)
      , m_heartbeatsWithNoProgress(0)
      , m_totalBytesReceivedBeforePreviousHeartbeat(0)
      , m_isMainLoad(false)
@@ -305,7 +305,7 @@ bool ProgressTracker::isMainLoadProgressing() const
      return m_progressValue && m_progressValue < finalProgressValue && m_heartbeatsWithNoProgress < loadStalledHeartbeatCount;
  }
  
-void ProgressTracker::progressHeartbeatTimerFired(Timer&)
+void ProgressTracker::progressHeartbeatTimerFired()
  {
      if (m_totalBytesReceived < m_totalBytesReceivedBeforePreviousHeartbeat + minumumBytesPerHeartbeatForProgress)
          ++m_heartbeatsWithNoProgress;
diff --git a/Source/WebCore/loader/ProgressTracker.h b/Source/WebCore/loader/ProgressTracker.h

index 8a39a11517def548a6b44ee9613eddb01c28b732..7d9dca4c14a42b163eb71a787637cea2cceafbac 100644 (file)
--- a/Source/WebCore/loader/ProgressTracker.h
+++ b/Source/WebCore/loader/ProgressTracker.h
@@ -66,7 +66,7 @@ private:
      void reset();
      void finalProgressComplete();
  
-    void progressHeartbeatTimerFired(Timer&);
+    void progressHeartbeatTimerFired();
      
      static unsigned long s_uniqueIdentifier;
      
diff --git a/Source/WebCore/loader/ResourceLoadScheduler.cpp b/Source/WebCore/loader/ResourceLoadScheduler.cpp

index 6d8b9e7fe496ba955a18887fe9b605d706c28e94..d2233d025b53542ecf42bc34633458ac4f8ccc66 100644 (file)
--- a/Source/WebCore/loader/ResourceLoadScheduler.cpp
+++ b/Source/WebCore/loader/ResourceLoadScheduler.cpp
@@ -101,7 +101,7 @@ ResourceLoadScheduler* resourceLoadScheduler()
  
  ResourceLoadScheduler::ResourceLoadScheduler()
      : m_nonHTTPProtocolHost(new HostInformation(String(), maxRequestsInFlightForNonHTTPProtocols))
-    , m_requestTimer(this, &ResourceLoadScheduler::requestTimerFired)
+    , m_requestTimer(*this, &ResourceLoadScheduler::requestTimerFired)
      , m_suspendPendingRequestsCount(0)
      , m_isSerialLoadingEnabled(false)
  {
@@ -332,7 +332,7 @@ void ResourceLoadScheduler::scheduleServePendingRequests()
          m_requestTimer.startOneShot(0);
  }
  
-void ResourceLoadScheduler::requestTimerFired(Timer&)
+void ResourceLoadScheduler::requestTimerFired()
  {
      LOG(ResourceLoading, "ResourceLoadScheduler::requestTimerFired\n");
      servePendingRequests();
diff --git a/Source/WebCore/loader/ResourceLoadScheduler.h b/Source/WebCore/loader/ResourceLoadScheduler.h

index 5b3742f3931f09fc35a916b651b2619941ae334d..37034384d7799a8fed508717608e23c48bbd3b99 100644 (file)
--- a/Source/WebCore/loader/ResourceLoadScheduler.h
+++ b/Source/WebCore/loader/ResourceLoadScheduler.h
@@ -84,7 +84,7 @@ protected:
  private:
      void scheduleLoad(ResourceLoader*);
      void scheduleServePendingRequests();
-    void requestTimerFired(Timer&);
+    void requestTimerFired();
  
      bool isSuspendingPendingRequests() const { return !!m_suspendPendingRequestsCount; }
  
diff --git a/Source/WebCore/loader/TextTrackLoader.cpp b/Source/WebCore/loader/TextTrackLoader.cpp

index ed0cb75b7b1682e3bd5e8de144e3fe216b539cae..994cedd96841277025189595d5c6d869cd608373 100644 (file)
--- a/Source/WebCore/loader/TextTrackLoader.cpp
+++ b/Source/WebCore/loader/TextTrackLoader.cpp
@@ -46,7 +46,7 @@ namespace WebCore {
  TextTrackLoader::TextTrackLoader(TextTrackLoaderClient& client, ScriptExecutionContext* context)
      : m_client(client)
      , m_scriptExecutionContext(context)
-    , m_cueLoadTimer(this, &TextTrackLoader::cueLoadTimerFired)
+    , m_cueLoadTimer(*this, &TextTrackLoader::cueLoadTimerFired)
      , m_state(Idle)
      , m_parseOffset(0)
      , m_newCuesAvailable(false)
@@ -59,10 +59,8 @@ TextTrackLoader::~TextTrackLoader()
          m_resource->removeClient(this);
  }
  
-void TextTrackLoader::cueLoadTimerFired(Timer* timer)
+void TextTrackLoader::cueLoadTimerFired()
  {
-    ASSERT_UNUSED(timer, timer == &m_cueLoadTimer);
-    
      if (m_newCuesAvailable) {
          m_newCuesAvailable = false;
          m_client.newCuesAvailable(this);
diff --git a/Source/WebCore/loader/TextTrackLoader.h b/Source/WebCore/loader/TextTrackLoader.h

index 82754dfe5010298a1f7044d2d5cdbff490ae171b..768cbe94ddf3c23f436bc073c70bf26aa14bdec6 100644 (file)
--- a/Source/WebCore/loader/TextTrackLoader.h
+++ b/Source/WebCore/loader/TextTrackLoader.h
@@ -79,7 +79,7 @@ private:
      virtual void fileFailedToParse() override;
      
      void processNewCueData(CachedResource*);
-    void cueLoadTimerFired(Timer*);
+    void cueLoadTimerFired();
      void corsPolicyPreventedLoad();
  
      enum State { Idle, Loading, Finished, Failed };
diff --git a/Source/WebCore/loader/cache/CachedResource.cpp b/Source/WebCore/loader/cache/CachedResource.cpp

index d3f886e8c0e5212e7a5b9f47dfec61789d257786..02d3fe86bca6eabb8a91284d7ad08e4f5e2b558a 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResource.cpp
+++ b/Source/WebCore/loader/cache/CachedResource.cpp
@@ -110,7 +110,7 @@ DEFINE_DEBUG_ONLY_GLOBAL(RefCountedLeakCounter, cachedResourceLeakCounter, ("Cac
  
  CachedResource::CachedResource(const ResourceRequest& request, Type type, SessionID sessionID)
      : m_resourceRequest(request)
-    , m_decodedDataDeletionTimer(this, &CachedResource::decodedDataDeletionTimerFired, deadDecodedDataDeletionIntervalForResourceType(type))
+    , m_decodedDataDeletionTimer(*this, &CachedResource::decodedDataDeletionTimerFired, deadDecodedDataDeletionIntervalForResourceType(type))
      , m_sessionID(sessionID)
      , m_loadPriority(defaultPriorityForResourceType(type))
      , m_responseTimestamp(currentTime())
@@ -726,7 +726,7 @@ void CachedResource::setLoadPriority(ResourceLoadPriority loadPriority)
  inline CachedResource::Callback::Callback(CachedResource& resource, CachedResourceClient& client)
      : m_resource(resource)
      , m_client(client)
-    , m_timer(this, &Callback::timerFired)
+    , m_timer(*this, &Callback::timerFired)
  {
      m_timer.startOneShot(0);
  }
@@ -737,7 +737,7 @@ inline void CachedResource::Callback::cancel()
          m_timer.stop();
  }
  
-void CachedResource::Callback::timerFired(Timer&)
+void CachedResource::Callback::timerFired()
  {
      m_resource.didAddClient(&m_client);
  }
diff --git a/Source/WebCore/loader/cache/CachedResource.h b/Source/WebCore/loader/cache/CachedResource.h

index 5a247d548508c1d9003b7abfe50e549a79a7cac8..d86a1d4c3bb4fbe2cfc811b84847b59f0444a018 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResource.h
+++ b/Source/WebCore/loader/cache/CachedResource.h
@@ -352,7 +352,7 @@ public:
      void cancel();
  
  private:
-    void timerFired(Timer&);
+    void timerFired();
  
      CachedResource& m_resource;
      CachedResourceClient& m_client;
diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp

index 405902c01f786ce9f86abdad7956b1aa8ed36490..3692f8efc96aec850d7da28d862c5bbeb27adc67 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
@@ -117,7 +117,7 @@ CachedResourceLoader::CachedResourceLoader(DocumentLoader* documentLoader)
      : m_document(0)
      , m_documentLoader(documentLoader)
      , m_requestCount(0)
-    , m_garbageCollectDocumentResourcesTimer(this, &CachedResourceLoader::garbageCollectDocumentResourcesTimerFired)
+    , m_garbageCollectDocumentResourcesTimer(*this, &CachedResourceLoader::garbageCollectDocumentResourcesTimerFired)
      , m_autoLoadImages(true)
      , m_imagesEnabled(true)
      , m_allowStaleResources(false)
@@ -798,9 +798,8 @@ 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& timer)
+void CachedResourceLoader::garbageCollectDocumentResourcesTimerFired()
  {
-    ASSERT_UNUSED(timer, &timer == &m_garbageCollectDocumentResourcesTimer);
      garbageCollectDocumentResources();
  }
  
diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.h b/Source/WebCore/loader/cache/CachedResourceLoader.h

index aeba2544f1f59ce6ad904326f120055152d27c55..7958e62eaf2cb3d1f321591a65c62d905b34b2ac 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResourceLoader.h
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.h
@@ -152,7 +152,7 @@ private:
      bool shouldContinueAfterNotifyingLoadedFromMemoryCache(const CachedResourceRequest&, CachedResource*);
      bool checkInsecureContent(CachedResource::Type, const URL&) const;
  
-    void garbageCollectDocumentResourcesTimerFired(Timer&);
+    void garbageCollectDocumentResourcesTimerFired();
      void performPostLoadActions();
  
      bool clientDefersImage(const URL&) const;
diff --git a/Source/WebCore/loader/icon/IconDatabase.cpp b/Source/WebCore/loader/icon/IconDatabase.cpp

index f10c413d34a1815d426b70dfa0eba1a9cde666ae..9838ea65558bcea6c29b4d47cf16574446ad347b 100644 (file)
--- a/Source/WebCore/loader/icon/IconDatabase.cpp
+++ b/Source/WebCore/loader/icon/IconDatabase.cpp
@@ -786,7 +786,7 @@ size_t IconDatabase::iconRecordCountWithData()
  }
  
  IconDatabase::IconDatabase()
-    : m_syncTimer(this, &IconDatabase::syncTimerFired)
+    : m_syncTimer(*this, &IconDatabase::syncTimerFired)
      , m_syncThreadRunning(false)
      , m_scheduleOrDeferSyncTimerRequested(false)
      , m_isEnabled(false)
@@ -855,7 +855,7 @@ void IconDatabase::scheduleOrDeferSyncTimer()
      });
  }
  
-void IconDatabase::syncTimerFired(Timer&)
+void IconDatabase::syncTimerFired()
  {
      ASSERT_NOT_SYNC_THREAD();
      wakeSyncThread();
diff --git a/Source/WebCore/loader/icon/IconDatabase.h b/Source/WebCore/loader/icon/IconDatabase.h

index c7d92f2dd921f7e39498f85742470075bfae03be..71b17edc79bd550f66e5aebc5ac89f282035057c 100644 (file)
--- a/Source/WebCore/loader/icon/IconDatabase.h
+++ b/Source/WebCore/loader/icon/IconDatabase.h
@@ -115,7 +115,7 @@ private:
  
      void wakeSyncThread();
      void scheduleOrDeferSyncTimer();
-    void syncTimerFired(Timer&);
+    void syncTimerFired();
      
      Timer m_syncTimer;
      ThreadIdentifier m_syncThread;
diff --git a/Source/WebCore/page/AutoscrollController.cpp b/Source/WebCore/page/AutoscrollController.cpp

index b1dcff25bdc301013d729bf9e861c5aa858569ca..a67419ba37435f9804be0d388596e5380e37aa98 100644 (file)
--- a/Source/WebCore/page/AutoscrollController.cpp
+++ b/Source/WebCore/page/AutoscrollController.cpp
@@ -56,7 +56,7 @@ static Frame* getMainFrame(Frame* frame)
  #endif
  
  AutoscrollController::AutoscrollController()
-    : m_autoscrollTimer(this, &AutoscrollController::autoscrollTimerFired)
+    : m_autoscrollTimer(*this, &AutoscrollController::autoscrollTimerFired)
      , m_autoscrollRenderer(0)
      , m_autoscrollType(NoAutoscroll)
      , m_dragAndDropAutoscrollStartTime(0)
@@ -231,7 +231,7 @@ bool AutoscrollController::panScrollInProgress() const
  }
  #endif
  
-void AutoscrollController::autoscrollTimerFired(Timer&)
+void AutoscrollController::autoscrollTimerFired()
  {
      if (!m_autoscrollRenderer) {
          stopAutoscrollTimer();
diff --git a/Source/WebCore/page/AutoscrollController.h b/Source/WebCore/page/AutoscrollController.h

index a060f9a4d4eeeffd6a2a104f28074628ada7c2fe..20e709cc0224e7fb0d2a42133192c708abc5a9be 100644 (file)
--- a/Source/WebCore/page/AutoscrollController.h
+++ b/Source/WebCore/page/AutoscrollController.h
@@ -69,7 +69,7 @@ public:
  #endif
  
  private:
-    void autoscrollTimerFired(Timer&);
+    void autoscrollTimerFired();
      void startAutoscrollTimer();
  #if ENABLE(PAN_SCROLLING)
      void updatePanScrollState(FrameView*, const IntPoint&);
diff --git a/Source/WebCore/page/CaptionUserPreferences.cpp b/Source/WebCore/page/CaptionUserPreferences.cpp

index 9ec05d7451e88adb420b343a25193cd861ad9e35..340fd7e2fca8410e4abd73c15b41c368e1160e03 100644 (file)
--- a/Source/WebCore/page/CaptionUserPreferences.cpp
+++ b/Source/WebCore/page/CaptionUserPreferences.cpp
@@ -42,7 +42,7 @@ namespace WebCore {
  CaptionUserPreferences::CaptionUserPreferences(PageGroup& group)
      : m_pageGroup(group)
      , m_displayMode(ForcedOnly)
-    , m_timer(this, &CaptionUserPreferences::timerFired)
+    , m_timer(*this, &CaptionUserPreferences::timerFired)
      , m_testingMode(false)
      , m_havePreferences(false)
  {
@@ -52,7 +52,7 @@ CaptionUserPreferences::~CaptionUserPreferences()
  {
  }
  
-void CaptionUserPreferences::timerFired(Timer&)
+void CaptionUserPreferences::timerFired()
  {
      captionPreferencesChanged();
  }
diff --git a/Source/WebCore/page/CaptionUserPreferences.h b/Source/WebCore/page/CaptionUserPreferences.h

index 6f02b57d03ceee51ab28fccb3f42d7a117269ec2..dfe6d49f330b4bcdbe59502b3d67e354eeeae5df 100644 (file)
--- a/Source/WebCore/page/CaptionUserPreferences.h
+++ b/Source/WebCore/page/CaptionUserPreferences.h
@@ -97,7 +97,7 @@ protected:
      void updateCaptionStyleSheetOveride();
  
  private:
-    void timerFired(Timer&);
+    void timerFired();
      void notify();
  
      PageGroup& m_pageGroup;
diff --git a/Source/WebCore/page/CaptionUserPreferencesMediaAF.cpp b/Source/WebCore/page/CaptionUserPreferencesMediaAF.cpp

index 3bb7628abaf2c078543ea349245710aeaf31567a..a48c4b4f5186aee4d2d47694a9b714c1c4eff10a 100644 (file)
--- a/Source/WebCore/page/CaptionUserPreferencesMediaAF.cpp
+++ b/Source/WebCore/page/CaptionUserPreferencesMediaAF.cpp
@@ -141,7 +141,7 @@ static void userCaptionPreferencesChangedNotificationCallback(CFNotificationCent
  CaptionUserPreferencesMediaAF::CaptionUserPreferencesMediaAF(PageGroup& group)
      : CaptionUserPreferences(group)
  #if HAVE(MEDIA_ACCESSIBILITY_FRAMEWORK)
-    , m_updateStyleSheetTimer(this, &CaptionUserPreferencesMediaAF::updateTimerFired)
+    , m_updateStyleSheetTimer(*this, &CaptionUserPreferencesMediaAF::updateTimerFired)
      , m_listeningForPreferenceChanges(false)
  #endif
  {
@@ -224,7 +224,7 @@ bool CaptionUserPreferencesMediaAF::userPrefersSubtitles() const
      return !(captioningMediaCharacteristics && CFArrayGetCount(captioningMediaCharacteristics.get()));
  }
  
-void CaptionUserPreferencesMediaAF::updateTimerFired(Timer&)
+void CaptionUserPreferencesMediaAF::updateTimerFired()
  {
      updateCaptionStyleSheetOveride();
  }
diff --git a/Source/WebCore/page/CaptionUserPreferencesMediaAF.h b/Source/WebCore/page/CaptionUserPreferencesMediaAF.h

index 8b0bbc734c4ae7dd944288cb2b4cdd669a78c76b..43fc9331a888c6cc7bc802da34683afc8a4736b5 100644 (file)
--- a/Source/WebCore/page/CaptionUserPreferencesMediaAF.h
+++ b/Source/WebCore/page/CaptionUserPreferencesMediaAF.h
@@ -68,7 +68,7 @@ public:
  
  private:
  #if HAVE(MEDIA_ACCESSIBILITY_FRAMEWORK)
-    void updateTimerFired(Timer&);
+    void updateTimerFired();
  
      String captionsWindowCSS() const;
      String captionsBackgroundCSS() const;
diff --git a/Source/WebCore/page/DeviceController.cpp b/Source/WebCore/page/DeviceController.cpp

index 6a0e0117bb6c7c916795cad5f5d4109a121b0092..bd5ba1923e759dc6bb9431eed42fa73abcfb9f7b 100644 (file)
--- a/Source/WebCore/page/DeviceController.cpp
+++ b/Source/WebCore/page/DeviceController.cpp
@@ -35,7 +35,7 @@ namespace WebCore {
  
  DeviceController::DeviceController(DeviceClient* client)
      : m_client(client)
-    , m_timer(this, &DeviceController::fireDeviceEvent)
+    , m_timer(*this, &DeviceController::fireDeviceEvent)
  {
      ASSERT(m_client);
  }
@@ -84,9 +84,8 @@ void DeviceController::dispatchDeviceEvent(PassRefPtr<Event> prpEvent)
      }
  }
  
-void DeviceController::fireDeviceEvent(Timer& timer)
+void DeviceController::fireDeviceEvent()
  {
-    ASSERT_UNUSED(timer, &timer == &m_timer);
      ASSERT(hasLastData());
  
      m_timer.stop();
diff --git a/Source/WebCore/page/DeviceController.h b/Source/WebCore/page/DeviceController.h

index c46403d4f427a75fe9828edaae76d6cfc78dce34..fdf5d1d96d1577676ca909f91893c57f9808a5cf 100644 (file)
--- a/Source/WebCore/page/DeviceController.h
+++ b/Source/WebCore/page/DeviceController.h
@@ -56,7 +56,7 @@ public:
      virtual PassRefPtr<Event> getLastEvent() { return 0; }
  
  protected:
-    void fireDeviceEvent(Timer&);
+    void fireDeviceEvent();
  
      HashCountedSet<RefPtr<DOMWindow>> m_listeners;
      HashCountedSet<RefPtr<DOMWindow>> m_lastEventListeners;
diff --git a/Source/WebCore/page/EventHandler.cpp b/Source/WebCore/page/EventHandler.cpp

index d09dd603593f0dc3423d08147bf5c96d9c894397..cf943da133f270d66b82c2328b2f35c710df11eb 100644 (file)
--- a/Source/WebCore/page/EventHandler.cpp
+++ b/Source/WebCore/page/EventHandler.cpp
@@ -376,17 +376,17 @@ EventHandler::EventHandler(Frame& frame)
  #endif
      , m_mouseDownWasSingleClickInSelection(false)
      , m_selectionInitiationState(HaveNotStartedSelection)
-    , m_hoverTimer(this, &EventHandler::hoverTimerFired)
+    , m_hoverTimer(*this, &EventHandler::hoverTimerFired)
  #if ENABLE(CURSOR_SUPPORT)
-    , m_cursorUpdateTimer(this, &EventHandler::cursorUpdateTimerFired)
+    , m_cursorUpdateTimer(*this, &EventHandler::cursorUpdateTimerFired)
  #endif
-    , m_longMousePressTimer(this, &EventHandler::recognizeLongMousePress)
+    , m_longMousePressTimer(*this, &EventHandler::recognizeLongMousePress)
      , m_didRecognizeLongMousePress(false)
      , m_autoscrollController(std::make_unique<AutoscrollController>())
      , m_mouseDownMayStartAutoscroll(false)
      , m_mouseDownWasInSubframe(false)
  #if !ENABLE(IOS_TOUCH_EVENTS)
-    , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)
+    , m_fakeMouseMoveEventTimer(*this, &EventHandler::fakeMouseMoveEventTimerFired)
  #endif
      , m_svgPan(false)
      , m_resizeLayer(0)
@@ -420,7 +420,7 @@ EventHandler::EventHandler(Frame& frame)
      , m_didLongPressInvokeContextMenu(false)
      , m_isHandlingWheelEvent(false)
  #if ENABLE(CURSOR_VISIBILITY)
-    , m_autoHideCursorTimer(this, &EventHandler::autoHideCursorTimerFired)
+    , m_autoHideCursorTimer(*this, &EventHandler::autoHideCursorTimerFired)
  #endif
  {
  }
@@ -1310,7 +1310,7 @@ bool EventHandler::useHandCursor(Node* node, bool isOverLink, bool shiftKey)
      return ((isOverLink || isSubmitImage(node)) && (!editable || editableLinkEnabled));
  }
  
-void EventHandler::cursorUpdateTimerFired(Timer&)
+void EventHandler::cursorUpdateTimerFired()
  {
      ASSERT(m_frame.document());
      updateCursor();
@@ -1553,9 +1553,8 @@ void EventHandler::cancelAutoHideCursorTimer()
          m_autoHideCursorTimer.stop();
  }
  
-void EventHandler::autoHideCursorTimerFired(Timer& timer)
+void EventHandler::autoHideCursorTimerFired()
  {
-    ASSERT_UNUSED(timer, &timer == &m_autoHideCursorTimer);
      m_currentMouseCursor = noneCursor();
      FrameView* view = m_frame.view();
      if (view && view->isActive())
@@ -1576,10 +1575,8 @@ void EventHandler::beginTrackingPotentialLongMousePress(const HitTestResult& hit
      page->chrome().didBeginTrackingPotentialLongMousePress(m_mouseDownPos, hitTestResult);
  }
      
-void EventHandler::recognizeLongMousePress(Timer& timer)
+void EventHandler::recognizeLongMousePress()
  {
-    ASSERT_UNUSED(timer, &timer == &m_longMousePressTimer);
-
      Page* page = m_frame.page();
      if (!page)
          return;
@@ -2944,9 +2941,8 @@ void EventHandler::cancelFakeMouseMoveEvent()
      m_fakeMouseMoveEventTimer.stop();
  }
  
-void EventHandler::fakeMouseMoveEventTimerFired(Timer& timer)
+void EventHandler::fakeMouseMoveEventTimerFired()
  {
-    ASSERT_UNUSED(timer, &timer == &m_fakeMouseMoveEventTimer);
      ASSERT(!m_mousePressed);
  
      if (!m_frame.settings().deviceSupportsMouse())
@@ -2980,7 +2976,7 @@ void EventHandler::resizeLayerDestroyed()
      m_resizeLayer = 0;
  }
  
-void EventHandler::hoverTimerFired(Timer&)
+void EventHandler::hoverTimerFired()
  {
      m_hoverTimer.stop();
  
diff --git a/Source/WebCore/page/EventHandler.h b/Source/WebCore/page/EventHandler.h

index 59dfe0a24eade3cfeee7169531b0301e83b52877..880d6294f548c4fcf12614d3bbe7f04c13729dfb 100644 (file)
--- a/Source/WebCore/page/EventHandler.h
+++ b/Source/WebCore/page/EventHandler.h
@@ -326,9 +326,9 @@ private:
  
      OptionalCursor selectCursor(const HitTestResult&, bool shiftKey);
  
-    void hoverTimerFired(Timer&);
+    void hoverTimerFired();
  #if ENABLE(CURSOR_SUPPORT)
-    void cursorUpdateTimerFired(Timer&);
+    void cursorUpdateTimerFired();
  #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&);
+    void fakeMouseMoveEventTimerFired();
      void cancelFakeMouseMoveEvent();
  #endif
  
@@ -437,11 +437,11 @@ private:
  #if ENABLE(CURSOR_VISIBILITY)
      void startAutoHideCursorTimer();
      void cancelAutoHideCursorTimer();
-    void autoHideCursorTimerFired(Timer&);
+    void autoHideCursorTimerFired();
  #endif
  
      void beginTrackingPotentialLongMousePress(const HitTestResult&);
-    void recognizeLongMousePress(Timer&);
+    void recognizeLongMousePress();
      void cancelTrackingPotentialLongMousePress();
      bool longMousePressHysteresisExceeded();
      void clearLongMousePressState();
diff --git a/Source/WebCore/page/EventSource.cpp b/Source/WebCore/page/EventSource.cpp

index 635c8ead0abfb660ac6643947e42fae73449715a..71ad82c56bbdb233f2e854820c66a8f0cf9e17bb 100644 (file)
--- a/Source/WebCore/page/EventSource.cpp
+++ b/Source/WebCore/page/EventSource.cpp
@@ -65,7 +65,7 @@ inline EventSource::EventSource(ScriptExecutionContext& context, const URL& url,
      , m_withCredentials(false)
      , m_state(CONNECTING)
      , m_decoder(TextResourceDecoder::create("text/plain", "UTF-8"))
-    , m_connectTimer(this, &EventSource::connectTimerFired)
+    , m_connectTimer(*this, &EventSource::connectTimerFired)
      , m_discardTrailingNewline(false)
      , m_requestInFlight(false)
      , m_reconnectDelay(defaultReconnectDelay)
@@ -170,7 +170,7 @@ void EventSource::scheduleReconnect()
      dispatchEvent(Event::create(eventNames().errorEvent, false, false));
  }
  
-void EventSource::connectTimerFired(Timer&)
+void EventSource::connectTimerFired()
  {
      connect();
  }
diff --git a/Source/WebCore/page/EventSource.h b/Source/WebCore/page/EventSource.h

index a4525f423cfc2e125e3cf5f3e93497753cf37cf4..fac7332e527df5e7bd2eebac32d81f4e2e8ae16f 100644 (file)
--- a/Source/WebCore/page/EventSource.h
+++ b/Source/WebCore/page/EventSource.h
@@ -97,7 +97,7 @@ private:
      void networkRequestEnded();
      void scheduleInitialConnect();
      void scheduleReconnect();
-    void connectTimerFired(Timer&);
+    void connectTimerFired();
      void abortConnectionAttempt();
      void parseEventStream();
      void parseEventStreamLine(unsigned pos, int fieldLength, int lineLength);
diff --git a/Source/WebCore/page/FocusController.cpp b/Source/WebCore/page/FocusController.cpp

index 7a5f5d4ad126832efc4e997a86598298f3041626..dbc793a8b80bde116ed48f96a7cd1c89888f5626 100644 (file)
--- a/Source/WebCore/page/FocusController.cpp
+++ b/Source/WebCore/page/FocusController.cpp
@@ -164,7 +164,7 @@ FocusController::FocusController(Page& page, ViewState::Flags viewState)
      : m_page(page)
      , m_isChangingFocusedFrame(false)
      , m_viewState(viewState)
-    , m_focusRepaintTimer(this, &FocusController::focusRepaintTimerFired)
+    , m_focusRepaintTimer(*this, &FocusController::focusRepaintTimerFired)
  {
  }
  
@@ -912,7 +912,7 @@ void FocusController::setFocusedElementNeedsRepaint()
      m_focusRepaintTimer.startOneShot(0.033);
  }
  
-void FocusController::focusRepaintTimerFired(Timer&)
+void FocusController::focusRepaintTimerFired()
  {
      Document* focusedDocument = focusedOrMainFrame().document();
      if (!focusedDocument)
diff --git a/Source/WebCore/page/FocusController.h b/Source/WebCore/page/FocusController.h

index 36f12008497ca5e8f7199755bc353ac64f939c97..2fb1fa5402c56e9d1a8338d9fcb20ea6c8cc26dc 100644 (file)
--- a/Source/WebCore/page/FocusController.h
+++ b/Source/WebCore/page/FocusController.h
@@ -120,7 +120,7 @@ private:
      bool advanceFocusDirectionallyInContainer(Node* container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*);
      void findFocusCandidateInContainer(Node* container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*, FocusCandidate& closest);
  
-    void focusRepaintTimerFired(Timer&);
+    void focusRepaintTimerFired();
  
      Page& m_page;
      RefPtr<Frame> m_focusedFrame;
diff --git a/Source/WebCore/page/Frame.cpp b/Source/WebCore/page/Frame.cpp

index 9c376a9053d9062dd03dc3f4225030907bc252ee..498bd6d78191df176671a1d3d0c1217958325447 100644 (file)
--- a/Source/WebCore/page/Frame.cpp
+++ b/Source/WebCore/page/Frame.cpp
@@ -162,7 +162,7 @@ Frame::Frame(Page& page, HTMLFrameOwnerElement* ownerElement, FrameLoaderClient&
      , m_eventHandler(std::make_unique<EventHandler>(*this))
      , m_animationController(std::make_unique<AnimationController>(*this))
  #if PLATFORM(IOS)
-    , m_overflowAutoScrollTimer(this, &Frame::overflowAutoScrollTimerFired)
+    , m_overflowAutoScrollTimer(*this, &Frame::overflowAutoScrollTimerFired)
      , m_selectionChangeCallbacksDisabled(false)
      , m_timersPausedCount(0)
  #endif
@@ -516,7 +516,7 @@ void Frame::scrollOverflowLayer(RenderLayer* layer, const IntRect& visibleRect,
      selection().updateAppearance();
  }
  
-void Frame::overflowAutoScrollTimerFired(Timer*)
+void Frame::overflowAutoScrollTimerFired()
  {
      if (!eventHandler().mousePressed() || checkOverflowScroll(PerformOverflowScroll) == OverflowScrollNone) {
          if (m_overflowAutoScrollTimer.isActive())
diff --git a/Source/WebCore/page/Frame.h b/Source/WebCore/page/Frame.h

index be74942597aa30d0fee391d8e57f25e0ab406c63..ea16aade0e0697dc743fcc0b608c6ab27cead476 100644 (file)
--- a/Source/WebCore/page/Frame.h
+++ b/Source/WebCore/page/Frame.h
@@ -295,7 +295,7 @@ namespace WebCore {
          bool hitTestResultAtViewportLocation(const FloatPoint& viewportLocation, HitTestResult&, IntPoint& center);
          Node* qualifyingNodeAtViewportLocation(const FloatPoint& viewportLocation, FloatPoint& adjustedViewportLocation, NodeQualifier, bool shouldApproximate);
  
-        void overflowAutoScrollTimerFired(Timer*);
+        void overflowAutoScrollTimerFired();
          void startOverflowAutoScroll(const IntPoint&);
          int checkOverflowScroll(OverflowScrollAction);
  
diff --git a/Source/WebCore/page/FrameView.cpp b/Source/WebCore/page/FrameView.cpp

index 4a6cdb7a062b8a89bbc1ae04200dee4954f57005..834e9e8fffde5b744ac07f5d9b56761a5e811b09 100644 (file)
--- a/Source/WebCore/page/FrameView.cpp
+++ b/Source/WebCore/page/FrameView.cpp
@@ -163,12 +163,12 @@ Pagination::Mode paginationModeForRenderStyle(const RenderStyle& style)
  FrameView::FrameView(Frame& frame)
      : m_frame(&frame)
      , m_canHaveScrollbars(true)
-    , m_layoutTimer(this, &FrameView::layoutTimerFired)
+    , m_layoutTimer(*this, &FrameView::layoutTimerFired)
      , m_layoutRoot(0)
      , m_layoutPhase(OutsideLayout)
      , m_inSynchronousPostLayout(false)
-    , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
-    , m_updateEmbeddedObjectsTimer(this, &FrameView::updateEmbeddedObjectsTimerFired)
+    , m_postLayoutTasksTimer(*this, &FrameView::postLayoutTimerFired)
+    , m_updateEmbeddedObjectsTimer(*this, &FrameView::updateEmbeddedObjectsTimerFired)
      , m_isTransparent(false)
      , m_baseBackgroundColor(Color::white)
      , m_mediaType("screen")
@@ -177,14 +177,14 @@ FrameView::FrameView(Frame& frame)
      , m_wasScrolledByUser(false)
      , m_inProgrammaticScroll(false)
      , m_safeToPropagateScrollToParent(true)
-    , m_delayedScrollEventTimer(this, &FrameView::delayedScrollEventTimerFired)
+    , m_delayedScrollEventTimer(*this, &FrameView::delayedScrollEventTimerFired)
      , m_isTrackingRepaints(false)
      , m_shouldUpdateWhileOffscreen(true)
      , m_exposedRect(FloatRect::infiniteRect())
      , m_deferSetNeedsLayouts(0)
      , m_setNeedsLayoutWasDeferred(false)
      , m_speculativeTilingEnabled(false)
-    , m_speculativeTilingEnableTimer(this, &FrameView::speculativeTilingEnableTimerFired)
+    , m_speculativeTilingEnableTimer(*this, &FrameView::speculativeTilingEnableTimerFired)
  #if PLATFORM(IOS)
      , m_useCustomFixedPositionLayoutRect(false)
      , m_useCustomSizeForResizeEvent(false)
@@ -1743,7 +1743,7 @@ IntPoint FrameView::maximumScrollPosition() const
      return maximumOffset;
  }
  
-void FrameView::delayedScrollEventTimerFired(Timer&)
+void FrameView::delayedScrollEventTimerFired()
  {
      sendScrollEvent();
  }
@@ -2406,7 +2406,7 @@ void FrameView::enableSpeculativeTilingIfNeeded()
      m_speculativeTilingEnableTimer.startOneShot(speculativeTilingEnableDelay);
  }
  
-void FrameView::speculativeTilingEnableTimerFired(Timer&)
+void FrameView::speculativeTilingEnableTimerFired()
  {
      if (m_speculativeTilingEnabled)
          return;
@@ -2414,7 +2414,7 @@ void FrameView::speculativeTilingEnableTimerFired(Timer&)
      adjustTiledBackingCoverage();
  }
  
-void FrameView::layoutTimerFired(Timer&)
+void FrameView::layoutTimerFired()
  {
  #ifdef INSTRUMENT_LAYOUT_SCHEDULING
      if (!frame().document()->ownerElement())
@@ -2856,7 +2856,7 @@ bool FrameView::updateEmbeddedObjects()
      return m_embeddedObjectsToUpdate->isEmpty();
  }
  
-void FrameView::updateEmbeddedObjectsTimerFired(Timer*)
+void FrameView::updateEmbeddedObjectsTimerFired()
  {
      RefPtr<FrameView> protect(this);
      m_updateEmbeddedObjectsTimer.stop();
@@ -2871,7 +2871,7 @@ void FrameView::flushAnyPendingPostLayoutTasks()
      if (m_postLayoutTasksTimer.isActive())
          performPostLayoutTasks();
      if (m_updateEmbeddedObjectsTimer.isActive())
-        updateEmbeddedObjectsTimerFired(nullptr);
+        updateEmbeddedObjectsTimerFired();
  }
  
  void FrameView::performPostLayoutTasks()
@@ -3009,7 +3009,7 @@ void FrameView::willEndLiveResize()
      adjustTiledBackingCoverage();
  }
  
-void FrameView::postLayoutTimerFired(Timer&)
+void FrameView::postLayoutTimerFired()
  {
      performPostLayoutTasks();
  }
diff --git a/Source/WebCore/page/FrameView.h b/Source/WebCore/page/FrameView.h

index bc18fe19ae1327219943f117912edf064f3328b2..f5b5e5d107162ff4d7f2283cf5130c82378182cb 100644 (file)
--- a/Source/WebCore/page/FrameView.h
+++ b/Source/WebCore/page/FrameView.h
@@ -106,7 +106,7 @@ public:
  
      void layout(bool allowSubtree = true);
      WEBCORE_EXPORT bool didFirstLayout() const;
-    void layoutTimerFired(Timer&);
+    void layoutTimerFired();
      void scheduleRelayout();
      void scheduleRelayoutOfSubtree(RenderElement&);
      void unscheduleRelayout();
@@ -241,7 +241,7 @@ public:
      virtual bool isRubberBandInProgress() const override;
      WEBCORE_EXPORT virtual IntPoint minimumScrollPosition() const override;
      WEBCORE_EXPORT virtual IntPoint maximumScrollPosition() const override;
-    void delayedScrollEventTimerFired(Timer&);
+    void delayedScrollEventTimerFired();
  
      void resumeVisibleImageAnimationsIncludingSubframes();
  
@@ -303,7 +303,7 @@ public:
  
      void restoreScrollbar();
  
-    void postLayoutTimerFired(Timer&);
+    void postLayoutTimerFired();
  
      void registerThrottledDOMTimer(DOMTimer*);
      void unregisterThrottledDOMTimer(DOMTimer*);
@@ -613,9 +613,9 @@ private:
      virtual void notifyPageThatContentAreaWillPaint() const override;
  
      void enableSpeculativeTilingIfNeeded();
-    void speculativeTilingEnableTimerFired(Timer&);
+    void speculativeTilingEnableTimerFired();
  
-    void updateEmbeddedObjectsTimerFired(Timer*);
+    void updateEmbeddedObjectsTimerFired();
      bool updateEmbeddedObjects();
      void updateEmbeddedObject(RenderEmbeddedObject&);
      void scrollToAnchor();
diff --git a/Source/WebCore/page/PageOverlay.cpp b/Source/WebCore/page/PageOverlay.cpp

index 254d89b67f33d0e4c914c2b286e824c5cfd8933a..3bbd849de7d58fce8de89d7c6adf0aecc97568da 100644 (file)
--- a/Source/WebCore/page/PageOverlay.cpp
+++ b/Source/WebCore/page/PageOverlay.cpp
@@ -54,7 +54,7 @@ PassRefPtr<PageOverlay> PageOverlay::create(Client& client, OverlayType overlayT
  PageOverlay::PageOverlay(Client& client, OverlayType overlayType)
      : m_client(client)
      , m_page(nullptr)
-    , m_fadeAnimationTimer(this, &PageOverlay::fadeAnimationTimerFired)
+    , m_fadeAnimationTimer(*this, &PageOverlay::fadeAnimationTimerFired)
      , m_fadeAnimationStartTime(0)
      , m_fadeAnimationDuration(fadeAnimationDuration)
      , m_fadeAnimationType(NoAnimation)
@@ -232,7 +232,7 @@ void PageOverlay::startFadeAnimation()
      m_fadeAnimationTimer.startRepeating(1 / fadeAnimationFrameRate);
  }
  
-void PageOverlay::fadeAnimationTimerFired(Timer&)
+void PageOverlay::fadeAnimationTimerFired()
  {
      float animationProgress = (currentTime() - m_fadeAnimationStartTime) / m_fadeAnimationDuration;
  
diff --git a/Source/WebCore/page/PageOverlay.h b/Source/WebCore/page/PageOverlay.h

index e8da7797236f250b77a242b9883a6a2b8cc88fdd..87f56e02b84e749d05ffa1ad68f0620bd3cd9fd8 100644 (file)
--- a/Source/WebCore/page/PageOverlay.h
+++ b/Source/WebCore/page/PageOverlay.h
@@ -115,7 +115,7 @@ private:
      explicit PageOverlay(Client&, OverlayType);
  
      void startFadeAnimation();
-    void fadeAnimationTimerFired(Timer&);
+    void fadeAnimationTimerFired();
  
      Client& m_client;
      Page* m_page;
diff --git a/Source/WebCore/page/Settings.cpp b/Source/WebCore/page/Settings.cpp

index 7d75e027e89e663a61c22a31ea52d169ff441f4c..47bca705a4ea2fad729d488e8d4285886c9ea0fe 100644 (file)
--- a/Source/WebCore/page/Settings.cpp
+++ b/Source/WebCore/page/Settings.cpp
@@ -195,7 +195,7 @@ Settings::Settings(Page* page)
  #endif
      , m_scrollingPerformanceLoggingEnabled(false)
      , m_timeWithoutMouseMovementBeforeHidingControls(3)
-    , m_setImageLoadingSettingsTimer(this, &Settings::imageLoadingSettingsTimerFired)
+    , m_setImageLoadingSettingsTimer(*this, &Settings::imageLoadingSettingsTimerFired)
  #if ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
      , m_hiddenPageDOMTimerThrottlingEnabled(false)
  #endif
@@ -396,7 +396,7 @@ void Settings::setLoadsImagesAutomatically(bool loadsImagesAutomatically)
      m_setImageLoadingSettingsTimer.startOneShot(0);
  }
  
-void Settings::imageLoadingSettingsTimerFired(Timer*)
+void Settings::imageLoadingSettingsTimerFired()
  {
      setImageLoadingSettings(m_page);
  }
diff --git a/Source/WebCore/page/Settings.h b/Source/WebCore/page/Settings.h

index 5157ad355e8d02ec82be485a112524092f9abe2b..cbc28ac7fb67205f80be87a7df6d30e03bc38597 100644 (file)
--- a/Source/WebCore/page/Settings.h
+++ b/Source/WebCore/page/Settings.h
@@ -322,7 +322,7 @@ private:
      double m_timeWithoutMouseMovementBeforeHidingControls;
  
      Timer m_setImageLoadingSettingsTimer;
-    void imageLoadingSettingsTimerFired(Timer*);
+    void imageLoadingSettingsTimerFired();
  
  #if ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
      bool m_hiddenPageDOMTimerThrottlingEnabled : 1;
diff --git a/Source/WebCore/page/animation/AnimationController.cpp b/Source/WebCore/page/animation/AnimationController.cpp

index dc9a4a797a7e4b43aadb44339b1f1ab6429efca7..73ba3613c4cd5c8c6a8a65ced4649d218389c347 100644 (file)
--- a/Source/WebCore/page/animation/AnimationController.cpp
+++ b/Source/WebCore/page/animation/AnimationController.cpp
@@ -52,8 +52,8 @@ static const double cAnimationTimerDelay = 0.025;
  static const double cBeginAnimationUpdateTimeNotSet = -1;
  
  AnimationControllerPrivate::AnimationControllerPrivate(Frame& frame)
-    : m_animationTimer(this, &AnimationControllerPrivate::animationTimerFired)
-    , m_updateStyleIfNeededDispatcher(this, &AnimationControllerPrivate::updateStyleIfNeededDispatcherFired)
+    : m_animationTimer(*this, &AnimationControllerPrivate::animationTimerFired)
+    , m_updateStyleIfNeededDispatcher(*this, &AnimationControllerPrivate::updateStyleIfNeededDispatcherFired)
      , m_frame(frame)
      , m_beginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet)
      , m_animationsWaitingForStyle()
@@ -159,7 +159,7 @@ void AnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/
      m_animationTimer.startOneShot(timeToNextService);
  }
  
-void AnimationControllerPrivate::updateStyleIfNeededDispatcherFired(Timer&)
+void AnimationControllerPrivate::updateStyleIfNeededDispatcherFired()
  {
      fireEventsAndUpdateStyle();
  }
@@ -226,7 +226,7 @@ void AnimationControllerPrivate::animationFrameCallbackFired()
  }
  #endif
  
-void AnimationControllerPrivate::animationTimerFired(Timer&)
+void AnimationControllerPrivate::animationTimerFired()
  {
      // Make sure animationUpdateTime is updated, so that it is current even if no
      // styleChange has happened (e.g. accelerated animations)
diff --git a/Source/WebCore/page/animation/AnimationControllerPrivate.h b/Source/WebCore/page/animation/AnimationControllerPrivate.h

index 5a454f8ca4e4589488cfb1eecf8c79584f45a420..ef1edd3fe228bd960afd9bc5daf5f5ae668c80b2 100644 (file)
--- a/Source/WebCore/page/animation/AnimationControllerPrivate.h
+++ b/Source/WebCore/page/animation/AnimationControllerPrivate.h
@@ -68,7 +68,7 @@ public:
      CompositeAnimation& ensureCompositeAnimation(RenderElement&);
      bool clear(RenderElement&);
  
-    void updateStyleIfNeededDispatcherFired(Timer&);
+    void updateStyleIfNeededDispatcherFired();
      void startUpdateStyleIfNeededDispatcher();
      void addEventToDispatch(PassRefPtr<Element> element, const AtomicString& eventType, const String& name, double elapsedTime);
      void addElementChangeToDispatch(PassRef<Element>);
@@ -114,7 +114,7 @@ public:
      void setAllowsNewAnimationsWhileSuspended(bool);
  
  private:
-    void animationTimerFired(Timer&);
+    void animationTimerFired();
  
      void styleAvailable();
      void fireEventsAndUpdateStyle();
diff --git a/Source/WebCore/page/mac/ServicesOverlayController.h b/Source/WebCore/page/mac/ServicesOverlayController.h

index 8aaf912e03256899af9ed766ad1205d2a68150a2..581f1df676cd2e397c45ee7b7d64c1c403d9011b 100644 (file)
--- a/Source/WebCore/page/mac/ServicesOverlayController.h
+++ b/Source/WebCore/page/mac/ServicesOverlayController.h
@@ -123,7 +123,7 @@ private:
  
      bool mouseIsOverHighlight(Highlight&, bool& mouseIsOverButton) const;
      std::chrono::milliseconds remainingTimeUntilHighlightShouldBeShown(Highlight*) const;
-    void determineActiveHighlightTimerFired(Timer&);
+    void determineActiveHighlightTimerFired();
  
      static bool highlightsAreEquivalent(const Highlight* a, const Highlight* b);
  
diff --git a/Source/WebCore/page/mac/ServicesOverlayController.mm b/Source/WebCore/page/mac/ServicesOverlayController.mm

index 0098c76313f4cc660e968a90d3e938a8b1bbc9de..843b8bf5f3bfd31b1798aa940f94ceac14719f67 100644 (file)
--- a/Source/WebCore/page/mac/ServicesOverlayController.mm
+++ b/Source/WebCore/page/mac/ServicesOverlayController.mm
@@ -225,7 +225,7 @@ ServicesOverlayController::ServicesOverlayController(MainFrame& mainFrame)
      : m_mainFrame(mainFrame)
      , m_servicesOverlay(nullptr)
      , m_isTextOnly(false)
-    , m_determineActiveHighlightTimer(this, &ServicesOverlayController::determineActiveHighlightTimerFired)
+    , m_determineActiveHighlightTimer(*this, &ServicesOverlayController::determineActiveHighlightTimerFired)
  {
  }
  
@@ -450,7 +450,7 @@ std::chrono::milliseconds ServicesOverlayController::remainingTimeUntilHighlight
      return std::chrono::duration_cast<std::chrono::milliseconds>(remainingDelay);
  }
  
-void ServicesOverlayController::determineActiveHighlightTimerFired(Timer&)
+void ServicesOverlayController::determineActiveHighlightTimerFired()
  {
      bool mouseIsOverButton;
      determineActiveHighlight(mouseIsOverButton);
diff --git a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp

index acd2df225eb3fcd4f80c60dc97a6f1ee710f591f..1f82303d6e4ab6ed2ff735e12e11b3a722a648e6 100644 (file)
--- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
+++ b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
@@ -45,7 +45,7 @@ namespace WebCore {
  
  AsyncScrollingCoordinator::AsyncScrollingCoordinator(Page* page)
      : ScrollingCoordinator(page)
-    , m_updateNodeScrollPositionTimer(this, &AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired)
+    , m_updateNodeScrollPositionTimer(*this, &AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired)
      , m_scrollingStateTree(ScrollingStateTree::create(this))
  {
  }
@@ -213,7 +213,7 @@ void AsyncScrollingCoordinator::scheduleUpdateScrollPositionAfterAsyncScroll(Scr
      m_updateNodeScrollPositionTimer.startOneShot(0);
  }
  
-void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired(Timer*)
+void AsyncScrollingCoordinator::updateScrollPositionAfterAsyncScrollTimerFired()
  {
      updateScrollPositionAfterAsyncScroll(m_scheduledScrollUpdate.nodeID, m_scheduledScrollUpdate.scrollPosition, m_scheduledScrollUpdate.isProgrammaticScroll, m_scheduledScrollUpdate.updateLayerPositionAction);
  }
diff --git a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h

index 3f4d7bc92f9e5bd1e5f8464ef756214912f0ac41..7ec75f7cf77c083ddf3ad6b8d5588881d4665725 100644 (file)
--- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
+++ b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
@@ -105,7 +105,7 @@ private:
      void ensureRootStateNodeForFrameView(FrameView*);
      void updateMainFrameScrollLayerPosition();
  
-    void updateScrollPositionAfterAsyncScrollTimerFired(Timer*);
+    void updateScrollPositionAfterAsyncScrollTimerFired();
      
      FrameView* frameViewForScrollingNode(ScrollingNodeID) const;
  
diff --git a/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.h b/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.h

index 011fe8e2382b392261d6d6f031d73f5115f58bee..ccc1080464b72f1c90ede8fa2baa72c68f1f65ae 100644 (file)
--- a/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.h
+++ b/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.h
@@ -53,7 +53,7 @@ public:
  private:
      virtual void scheduleTreeStateCommit() override;
  
-    void scrollingStateTreeCommitterTimerFired(Timer*);
+    void scrollingStateTreeCommitterTimerFired();
      void commitTreeState();
  
      Timer m_scrollingStateTreeCommitterTimer;
diff --git a/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.mm b/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.mm

index 8927e9923aae7868cf9027d4f9ce2f20ea1c4643..303b9b2021bd4495ef6cc254a28646cde4c7783e 100644 (file)
--- a/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.mm
+++ b/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.mm
@@ -52,7 +52,7 @@ PassRefPtr<ScrollingCoordinator> ScrollingCoordinator::create(Page* page)
  
  ScrollingCoordinatorIOS::ScrollingCoordinatorIOS(Page* page)
      : AsyncScrollingCoordinator(page)
-    , m_scrollingStateTreeCommitterTimer(this, &ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired)
+    , m_scrollingStateTreeCommitterTimer(*this, &ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired)
  {
      setScrollingTree(ScrollingTreeIOS::create(this));
  }
@@ -91,7 +91,7 @@ void ScrollingCoordinatorIOS::scheduleTreeStateCommit()
      m_scrollingStateTreeCommitterTimer.startOneShot(0);
  }
  
-void ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired(Timer*)
+void ScrollingCoordinatorIOS::scrollingStateTreeCommitterTimerFired()
  {
      commitTreeState();
  }
diff --git a/Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.h b/Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.h

index f71ecc3469e2c0ad077629cf8d50cbfaf85ee690..fc829a4d5985e96c85a7a11c5815eb234be69809 100644 (file)
--- a/Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.h
+++ b/Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.h
@@ -53,7 +53,7 @@ public:
  private:
      virtual void scheduleTreeStateCommit() override;
  
-    void scrollingStateTreeCommitterTimerFired(Timer*);
+    void scrollingStateTreeCommitterTimerFired();
      void commitTreeState();
      
      void updateTiledScrollingIndicator();
diff --git a/Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.mm b/Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.mm

index 0bc51997d0e211e1b2c758f1699380d8c03ec176..fc84caba9e77e9f945bfa7c8b0d718614d238678 100644 (file)
--- a/Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.mm
+++ b/Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.mm
@@ -54,7 +54,7 @@ PassRefPtr<ScrollingCoordinator> ScrollingCoordinator::create(Page* page)
  
  ScrollingCoordinatorMac::ScrollingCoordinatorMac(Page* page)
      : AsyncScrollingCoordinator(page)
-    , m_scrollingStateTreeCommitterTimer(this, &ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired)
+    , m_scrollingStateTreeCommitterTimer(*this, &ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired)
  {
      setScrollingTree(ScrollingTreeMac::create(this));
  }
@@ -106,7 +106,7 @@ void ScrollingCoordinatorMac::scheduleTreeStateCommit()
      m_scrollingStateTreeCommitterTimer.startOneShot(0);
  }
  
-void ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired(Timer*)
+void ScrollingCoordinatorMac::scrollingStateTreeCommitterTimerFired()
  {
      commitTreeState();
  }
diff --git a/Source/WebCore/platform/HysteresisActivity.h b/Source/WebCore/platform/HysteresisActivity.h

index ca90834e895462c2b3a02038db824e0577ed1732..a3c922f6de973a762a02bb5de00f04cb49bf40b4 100644 (file)
--- a/Source/WebCore/platform/HysteresisActivity.h
+++ b/Source/WebCore/platform/HysteresisActivity.h
@@ -45,7 +45,7 @@ public:
          : m_delegate(delegate)
          , m_hysteresisSeconds(hysteresisSeconds)
          , m_active(false)
-        , m_timer(this, &HysteresisActivity<Delegate>::hysteresisTimerFired)
+        , m_timer(*this, &HysteresisActivity<Delegate>::hysteresisTimerFired)
      {
      }
  
@@ -88,7 +88,7 @@ public:
      }
      
  private:
-    void hysteresisTimerFired(Timer&)
+    void hysteresisTimerFired()
      {
          m_delegate.stopped();
          m_timer.stop();
diff --git a/Source/WebCore/platform/ScrollAnimator.cpp b/Source/WebCore/platform/ScrollAnimator.cpp

index ea3c3977b581d870eec23186ef046a3ef6253a5f..2c4321b393573518c31f011b2670e736040fadcb 100644 (file)
--- a/Source/WebCore/platform/ScrollAnimator.cpp
+++ b/Source/WebCore/platform/ScrollAnimator.cpp
@@ -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>(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>(this, &ScrollAnimator::verticalScrollSnapTimerFired);
+        m_verticalScrollSnapTimer = std::make_unique<Timer>(*this, &ScrollAnimator::verticalScrollSnapTimerFired);
      } else if (m_verticalScrollSnapAnimator) {
          m_verticalScrollSnapAnimator = nullptr;
          m_verticalScrollSnapTimer = nullptr;
@@ -219,12 +219,12 @@ void ScrollAnimator::stopScrollSnapTimer(ScrollEventAxis axis)
          scrollSnapTimer->stop();
  }
  
-void ScrollAnimator::horizontalScrollSnapTimerFired(Timer&)
+void ScrollAnimator::horizontalScrollSnapTimerFired()
  {
      m_horizontalScrollSnapAnimator->scrollSnapAnimationUpdate();
  }
  
-void ScrollAnimator::verticalScrollSnapTimerFired(Timer&)
+void ScrollAnimator::verticalScrollSnapTimerFired()
  {
      m_verticalScrollSnapAnimator->scrollSnapAnimationUpdate();
  }
diff --git a/Source/WebCore/platform/ScrollAnimator.h b/Source/WebCore/platform/ScrollAnimator.h

index eb150fcdfb50671a73fed4e6771f5d9a89148b0d..ee6c3b5cc5ca2c21eade7835ad5c83a530e99e1b 100644 (file)
--- a/Source/WebCore/platform/ScrollAnimator.h
+++ b/Source/WebCore/platform/ScrollAnimator.h
@@ -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&);
-    void verticalScrollSnapTimerFired(Timer&);
+    void horizontalScrollSnapTimerFired();
+    void verticalScrollSnapTimerFired();
  #endif
  
      ScrollableArea* m_scrollableArea;
diff --git a/Source/WebCore/platform/Scrollbar.cpp b/Source/WebCore/platform/Scrollbar.cpp

index c63fb015989528125dca18717a86c52952e33edf..a5f742085a2235a57c8cfbef708499d906c34528 100644 (file)
--- a/Source/WebCore/platform/Scrollbar.cpp
+++ b/Source/WebCore/platform/Scrollbar.cpp
@@ -76,7 +76,7 @@ Scrollbar::Scrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orient
      , m_draggingDocument(false)
      , m_documentDragPos(0)
      , m_enabled(true)
-    , m_scrollTimer(this, &Scrollbar::autoscrollTimerFired)
+    , m_scrollTimer(*this, &Scrollbar::autoscrollTimerFired)
      , m_overlapsResizer(false)
      , m_suppressInvalidation(false)
      , m_isAlphaLocked(false)
@@ -185,7 +185,7 @@ void Scrollbar::paint(GraphicsContext* context, const IntRect& damageRect)
          Widget::paint(context, damageRect);
  }
  
-void Scrollbar::autoscrollTimerFired(Timer&)
+void Scrollbar::autoscrollTimerFired()
  {
      autoscrollPressedPart(theme()->autoscrollTimerDelay());
  }
diff --git a/Source/WebCore/platform/Scrollbar.h b/Source/WebCore/platform/Scrollbar.h

index 731de5d3fe33b3c83ee27600a72438cada670516..1fc34ed0f5085a852bb1845ff4d92e5a1d586826 100644 (file)
--- a/Source/WebCore/platform/Scrollbar.h
+++ b/Source/WebCore/platform/Scrollbar.h
@@ -165,7 +165,7 @@ protected:
      virtual void updateThumbPosition();
      virtual void updateThumbProportion();
  
-    void autoscrollTimerFired(Timer&);
+    void autoscrollTimerFired();
      void startTimerIfNeeded(double delay);
      void stopTimerIfNeeded();
      void autoscrollPressedPart(double delay);
diff --git a/Source/WebCore/platform/Timer.h b/Source/WebCore/platform/Timer.h

index eac883f41102ab0179552a242dbf05061434609b..f4c3d1157b5973786f91c4a226c35c667d186b70 100644 (file)
--- a/Source/WebCore/platform/Timer.h
+++ b/Source/WebCore/platform/Timer.h
@@ -115,18 +115,6 @@ private:
  
  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)))
-    {
-    }
-
-    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))
@@ -161,8 +149,8 @@ inline bool TimerBase::isActive() const
  class DeferrableOneShotTimer : protected TimerBase {
  public:
      template<typename TimerFiredClass>
-    DeferrableOneShotTimer(TimerFiredClass* object, void (TimerFiredClass::*function)(), std::chrono::milliseconds delay)
-        : DeferrableOneShotTimer(std::bind(function, object), delay)
+    DeferrableOneShotTimer(TimerFiredClass& object, void (TimerFiredClass::*function)(), std::chrono::milliseconds delay)
+        : DeferrableOneShotTimer(std::bind(function, &object), delay)
      {
      }
  
diff --git a/Source/WebCore/platform/audio/MediaSession.cpp b/Source/WebCore/platform/audio/MediaSession.cpp

index 8021c4bdd870ccef4bfc6de7bd002b697d616272..c78b92192a6b29cd9354cb83edda58819d7af71f 100644 (file)
--- a/Source/WebCore/platform/audio/MediaSession.cpp
+++ b/Source/WebCore/platform/audio/MediaSession.cpp
@@ -59,7 +59,7 @@ std::unique_ptr<MediaSession> MediaSession::create(MediaSessionClient& client)
  
  MediaSession::MediaSession(MediaSessionClient& client)
      : m_client(client)
-    , m_clientDataBufferingTimer(this, &MediaSession::clientDataBufferingTimerFired)
+    , m_clientDataBufferingTimer(*this, &MediaSession::clientDataBufferingTimerFired)
      , m_state(Idle)
      , m_stateToRestore(Idle)
      , m_notifyingClient(false)
@@ -180,7 +180,7 @@ void MediaSession::visibilityChanged()
          m_clientDataBufferingTimer.startOneShot(kClientDataBufferingTimerThrottleDelay);
  }
  
-void MediaSession::clientDataBufferingTimerFired(Timer &)
+void MediaSession::clientDataBufferingTimerFired()
  {
      updateClientDataBuffering();
  }
diff --git a/Source/WebCore/platform/audio/MediaSession.h b/Source/WebCore/platform/audio/MediaSession.h

index be0729810082f5acdfb7cab4a309f16d4a954912..995456231bb8e66e015ce6de67fff759c11003d8 100644 (file)
--- a/Source/WebCore/platform/audio/MediaSession.h
+++ b/Source/WebCore/platform/audio/MediaSession.h
@@ -115,7 +115,7 @@ protected:
      MediaSessionClient& client() const { return m_client; }
  
  private:
-    void clientDataBufferingTimerFired(Timer&);
+    void clientDataBufferingTimerFired();
      void updateClientDataBuffering();
  
      MediaSessionClient& m_client;
diff --git a/Source/WebCore/platform/graphics/BitmapImage.cpp b/Source/WebCore/platform/graphics/BitmapImage.cpp

index e8bf55438a24879186429de60a33450920bcf6f7..8790aa44e41451ef25207bc0e850b89adc151d37 100644 (file)
--- a/Source/WebCore/platform/graphics/BitmapImage.cpp
+++ b/Source/WebCore/platform/graphics/BitmapImage.cpp
@@ -540,7 +540,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>(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.
@@ -641,7 +641,7 @@ void BitmapImage::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect,
  }
  
  
-void BitmapImage::advanceAnimation(Timer&)
+void BitmapImage::advanceAnimation()
  {
      internalAdvanceAnimation(false);
      // At this point the image region has been marked dirty, and if it's
diff --git a/Source/WebCore/platform/graphics/BitmapImage.h b/Source/WebCore/platform/graphics/BitmapImage.h

index 32712be62d6be0179139fc0ff1c4b6059bb2f550..8246f47c36eef55a46705d00acd8a3f963d9cd68 100644 (file)
--- a/Source/WebCore/platform/graphics/BitmapImage.h
+++ b/Source/WebCore/platform/graphics/BitmapImage.h
@@ -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&);
+    void advanceAnimation();
  
      // 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
diff --git a/Source/WebCore/platform/graphics/MediaPlayer.cpp b/Source/WebCore/platform/graphics/MediaPlayer.cpp

index fd31e7a28f4dcca7ecedae3f34ec8032019c85d3..f11365e13d3a5267bc65eaa57cd8ad604fde96bd 100644 (file)
--- a/Source/WebCore/platform/graphics/MediaPlayer.cpp
+++ b/Source/WebCore/platform/graphics/MediaPlayer.cpp
@@ -307,7 +307,7 @@ static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current)
  
  MediaPlayer::MediaPlayer(MediaPlayerClient& client)
      : m_client(client)
-    , m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
+    , m_reloadTimer(*this, &MediaPlayer::reloadTimerFired)
      , m_private(createNullMediaPlayer(this))
      , m_currentMediaEngine(0)
      , m_preload(Auto)
@@ -955,7 +955,7 @@ unsigned MediaPlayer::videoDecodedByteCount() const
      return m_private->videoDecodedByteCount();
  }
  
-void MediaPlayer::reloadTimerFired(Timer&)
+void MediaPlayer::reloadTimerFired()
  {
      m_private->cancelLoad();
      loadWithNextMediaEngine(m_currentMediaEngine);
diff --git a/Source/WebCore/platform/graphics/MediaPlayer.h b/Source/WebCore/platform/graphics/MediaPlayer.h

index d4b89c15122728911b1f080045442dc25f13b487..43d96531c2f73ce31dd5ee6de52f3d31c1ad4598 100644 (file)
--- a/Source/WebCore/platform/graphics/MediaPlayer.h
+++ b/Source/WebCore/platform/graphics/MediaPlayer.h
@@ -580,7 +580,7 @@ private:
      MediaPlayer(MediaPlayerClient&);
      MediaPlayerFactory* nextBestMediaEngine(MediaPlayerFactory*) const;
      void loadWithNextMediaEngine(MediaPlayerFactory*);
-    void reloadTimerFired(Timer&);
+    void reloadTimerFired();
  
      static void initializeMediaEngines();
  
diff --git a/Source/WebCore/platform/graphics/ShadowBlur.cpp b/Source/WebCore/platform/graphics/ShadowBlur.cpp

index 66df6bf2bc141e6e3a4fce722b457205990e9187..4fbd999d6f7949049660f9ad7e8f79468cbac820 100644 (file)
--- a/Source/WebCore/platform/graphics/ShadowBlur.cpp
+++ b/Source/WebCore/platform/graphics/ShadowBlur.cpp
@@ -57,7 +57,7 @@ class ScratchBuffer {
      WTF_MAKE_FAST_ALLOCATED;
  public:
      ScratchBuffer()
-        : m_purgeTimer(this, &ScratchBuffer::timerFired)
+        : m_purgeTimer(*this, &ScratchBuffer::timerFired)
          , m_lastWasInset(false)
  #if !ASSERT_DISABLED
          , m_bufferInUse(false)
@@ -130,7 +130,7 @@ public:
      static ScratchBuffer& shared();
  
  private:
-    void timerFired(Timer*)
+    void timerFired()
      {
          clearScratchBuffer();
      }
diff --git a/Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h b/Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h

index 471740dae89a59656658c9875f326b83880329d4..be3dac74c9e8e1005321d5926afa7f955e418f95 100644 (file)
--- a/Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h
+++ b/Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h
@@ -84,7 +84,7 @@ public:
  private:
      MediaSelectionGroupAVFObjC(AVPlayerItem*, AVMediaSelectionGroup*);
  
-    void selectionTimerFired(Timer&);
+    void selectionTimerFired();
  
      RetainPtr<AVPlayerItem> m_playerItem;
      RetainPtr<AVMediaSelectionGroup> m_mediaSelectionGroup;
diff --git a/Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm b/Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm

index b7fde8ebbb02bc204d71f2931762c2ffc28558b4..e7a16bf8ee9aa1ee33da0f22bb7661e2a589ac21 100644 (file)
--- a/Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm
+++ b/Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm
@@ -89,7 +89,7 @@ MediaSelectionGroupAVFObjC::MediaSelectionGroupAVFObjC(AVPlayerItem *item, AVMed
      : m_playerItem(item)
      , m_mediaSelectionGroup(group)
      , m_selectedOption(nullptr)
-    , m_selectionTimer(this, &MediaSelectionGroupAVFObjC::selectionTimerFired)
+    , m_selectionTimer(*this, &MediaSelectionGroupAVFObjC::selectionTimerFired)
  {
      updateOptions();
  }
@@ -141,7 +141,7 @@ void MediaSelectionGroupAVFObjC::setSelectedOption(MediaSelectionOptionAVFObjC*
      m_selectionTimer.startOneShot(0);
  }
  
-void MediaSelectionGroupAVFObjC::selectionTimerFired(Timer&)
+void MediaSelectionGroupAVFObjC::selectionTimerFired()
  {
      [m_playerItem selectMediaOption:(m_selectedOption ? m_selectedOption->avMediaSelectionOption() : nil) inMediaSelectionGroup:m_mediaSelectionGroup.get()];
  }
diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h

index f72acc997db9aa643de9b56974ed711d242f0949..e60176db5fed86da00d378e0f901f625f168c9e5 100644 (file)
--- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h
+++ b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h
@@ -168,7 +168,7 @@ private:
      void ensureLayer();
      void destroyLayer();
      bool shouldBePlaying() const;
-    void seekTimerFired(Timer&);
+    void seekTimerFired();
  
      friend class MediaSourcePrivateAVFObjC;
  
diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm

index 52d8a2e0eb0404cdc779f87d74931462e8c855f1..625c715188340e80e83dae2c6a2abdc83341727a 100644 (file)
--- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm
+++ b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm
@@ -144,7 +144,7 @@ MediaPlayerPrivateMediaSourceAVFObjC::MediaPlayerPrivateMediaSourceAVFObjC(Media
      : m_player(player)
      , m_weakPtrFactory(this)
      , m_synchronizer(adoptNS([[getAVSampleBufferRenderSynchronizerClass() alloc] init]))
-    , m_seekTimer(this, &MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired)
+    , m_seekTimer(*this, &MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired)
      , m_session(nullptr)
      , m_networkState(MediaPlayer::Empty)
      , m_readyState(MediaPlayer::HaveNothing)
@@ -423,7 +423,7 @@ void MediaPlayerPrivateMediaSourceAVFObjC::seekWithTolerance(const MediaTime& ti
      m_seekTimer.startOneShot(0);
  }
  
-void MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired(Timer&)
+void MediaPlayerPrivateMediaSourceAVFObjC::seekTimerFired()
  {
      seekInternal();
  }
diff --git a/Source/WebCore/platform/graphics/ca/LayerPool.cpp b/Source/WebCore/platform/graphics/ca/LayerPool.cpp

index 6f4be1d9dc68e5e422eb12bbbec9a3a013e58441..344e96435c01aa40f53148007f5e79ab9a48080e 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/LayerPool.cpp
+++ b/Source/WebCore/platform/graphics/ca/LayerPool.cpp
@@ -37,7 +37,7 @@ static const double capacityDecayTime = 5;
  LayerPool::LayerPool()
      : m_totalBytes(0)
      , m_maxBytesForPool(48 * 1024 * 1024)
-    , m_pruneTimer(this, &LayerPool::pruneTimerFired)
+    , m_pruneTimer(*this, &LayerPool::pruneTimerFired)
      , m_lastAddTime(0)
  {
      allLayerPools().add(this);
@@ -113,7 +113,7 @@ void LayerPool::schedulePrune()
      m_pruneTimer.startOneShot(1);
  }
  
-void LayerPool::pruneTimerFired(Timer&)
+void LayerPool::pruneTimerFired()
  {
      unsigned shrinkTo = decayedCapacity();
      while (m_totalBytes > shrinkTo) {
diff --git a/Source/WebCore/platform/graphics/ca/LayerPool.h b/Source/WebCore/platform/graphics/ca/LayerPool.h

index 8bcbe560fcaa86081a2cd1d625b78a27ab6ec820..b37f72c10bcb35435282885a41ae8fa6d6dfaaa1 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/LayerPool.h
+++ b/Source/WebCore/platform/graphics/ca/LayerPool.h
@@ -61,7 +61,7 @@ private:
  
      bool canReuseLayerWithSize(const IntSize& size) const { return m_maxBytesForPool && !size.isEmpty(); }
      void schedulePrune();
-    void pruneTimerFired(Timer&);
+    void pruneTimerFired();
  
      typedef enum { LeaveUnchanged, MarkAsUsed } AccessType;
      LayerList& listOfLayersWithSize(const IntSize&, AccessType = LeaveUnchanged);
diff --git a/Source/WebCore/platform/graphics/ca/TileController.cpp b/Source/WebCore/platform/graphics/ca/TileController.cpp

index f4ca9103db1862aea88cd0f334b0db01884e26d1..3df803c8aad700a433247ae5ca6d16cfb31e8c15 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/TileController.cpp
+++ b/Source/WebCore/platform/graphics/ca/TileController.cpp
@@ -44,7 +44,7 @@ TileController::TileController(PlatformCALayer* rootPlatformLayer)
      : m_tileCacheLayer(rootPlatformLayer)
      , m_tileGrid(std::make_unique<TileGrid>(*this))
      , m_tileSize(defaultTileWidth, defaultTileHeight)
-    , m_tileRevalidationTimer(this, &TileController::tileRevalidationTimerFired)
+    , m_tileRevalidationTimer(*this, &TileController::tileRevalidationTimerFired)
      , m_zoomedOutContentsScale(0)
      , m_deviceScaleFactor(owningGraphicsLayer()->platformCALayerDeviceScaleFactor())
      , m_tileCoverage(CoverageForVisibleArea)
@@ -340,7 +340,7 @@ bool TileController::shouldTemporarilyRetainTileCohorts() const
      return owningGraphicsLayer()->platformCALayerShouldTemporarilyRetainTileCohorts(m_tileCacheLayer);
  }
  
-void TileController::tileRevalidationTimerFired(Timer*)
+void TileController::tileRevalidationTimerFired()
  {
      if (!owningGraphicsLayer())
          return;
diff --git a/Source/WebCore/platform/graphics/ca/TileController.h b/Source/WebCore/platform/graphics/ca/TileController.h

index 4ae1a1b8126b041e68eadd38ae04bc69667a52ff..822d2c48ac310d0ff2782c56004cccf9df58b5ce 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/TileController.h
+++ b/Source/WebCore/platform/graphics/ca/TileController.h
@@ -156,7 +156,7 @@ private:
      virtual float zoomedOutContentsScale() const override;
  
  
-    void tileRevalidationTimerFired(Timer*);
+    void tileRevalidationTimerFired();
  
      void setNeedsRevalidateTiles();
  
diff --git a/Source/WebCore/platform/graphics/ca/TileGrid.cpp b/Source/WebCore/platform/graphics/ca/TileGrid.cpp

index a77643ba040625c629e8aa2c49ea7a4352946684..d51e0b3ef972213f71455f2ba45fda81f2787fc3 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/TileGrid.cpp
+++ b/Source/WebCore/platform/graphics/ca/TileGrid.cpp
@@ -43,7 +43,7 @@ TileGrid::TileGrid(TileController& controller)
      : m_controller(controller)
      , m_containerLayer(*controller.rootLayer().createCompatibleLayer(PlatformCALayer::LayerTypeLayer, nullptr))
      , m_scale(1)
-    , m_cohortRemovalTimer(this, &TileGrid::cohortRemovalTimerFired)
+    , m_cohortRemovalTimer(*this, &TileGrid::cohortRemovalTimerFired)
  {
  #ifndef NDEBUG
      m_containerLayer.get().setName("TileGrid Container Layer");
@@ -476,7 +476,7 @@ double TileGrid::TileCohortInfo::timeUntilExpiration()
      return creationTime - timeThreshold;
  }
  
-void TileGrid::cohortRemovalTimerFired(Timer*)
+void TileGrid::cohortRemovalTimerFired()
  {
      if (m_cohortList.isEmpty()) {
          m_cohortRemovalTimer.stop();
diff --git a/Source/WebCore/platform/graphics/ca/TileGrid.h b/Source/WebCore/platform/graphics/ca/TileGrid.h

index 56f528de7a378e4d24a0293c4cfe0eea2c1f29b9..c59ae0992efb32eb59384991d37e6e7e6ba1e451 100644 (file)
--- a/Source/WebCore/platform/graphics/ca/TileGrid.h
+++ b/Source/WebCore/platform/graphics/ca/TileGrid.h
@@ -123,7 +123,7 @@ private:
      void removeTilesInCohort(TileCohort);
  
      void scheduleCohortRemoval();
-    void cohortRemovalTimerFired(Timer*);
+    void cohortRemovalTimerFired();
      TileCohort nextTileCohort() const;
      void startedNewCohort(TileCohort);
      TileCohort newestTileCohort() const;
diff --git a/Source/WebCore/platform/graphics/cg/IOSurfacePool.cpp b/Source/WebCore/platform/graphics/cg/IOSurfacePool.cpp

index 5285dce6e7f477c17ed95704a58a2cc1072ddc5f..2ea8dcfc21546685f455affd61aa557a0ef6ef48 100644 (file)
--- a/Source/WebCore/platform/graphics/cg/IOSurfacePool.cpp
+++ b/Source/WebCore/platform/graphics/cg/IOSurfacePool.cpp
@@ -52,7 +52,7 @@ const size_t maximumInUseBytes = defaultMaximumBytesCached / 2;
  namespace WebCore {
  
  IOSurfacePool::IOSurfacePool()
-    : m_collectionTimer(this, &IOSurfacePool::collectionTimerFired)
+    : m_collectionTimer(*this, &IOSurfacePool::collectionTimerFired)
      , m_bytesCached(0)
      , m_inUseBytesCached(0)
      , m_maximumBytesCached(defaultMaximumBytesCached)
@@ -292,7 +292,7 @@ bool IOSurfacePool::markOlderSurfacesPurgeable()
      return markedAllSurfaces;
  }
  
-void IOSurfacePool::collectionTimerFired(Timer&)
+void IOSurfacePool::collectionTimerFired()
  {
      collectInUseSurfaces();
      bool markedAllSurfaces = markOlderSurfacesPurgeable();
diff --git a/Source/WebCore/platform/graphics/cg/IOSurfacePool.h b/Source/WebCore/platform/graphics/cg/IOSurfacePool.h

index ba441168cfd756a155cd6ce6072f56751daf73bf..98ea9e995ba978a2d47f91a32f156ebeaaaf4125 100644 (file)
--- a/Source/WebCore/platform/graphics/cg/IOSurfacePool.h
+++ b/Source/WebCore/platform/graphics/cg/IOSurfacePool.h
@@ -87,7 +87,7 @@ private:
      void tryEvictOldestCachedSurface();
  
      void scheduleCollectionTimer();
-    void collectionTimerFired(Timer&);
+    void collectionTimerFired();
      void collectInUseSurfaces();
      bool markOlderSurfacesPurgeable();
  
diff --git a/Source/WebCore/platform/graphics/cg/SubimageCacheWithTimer.cpp b/Source/WebCore/platform/graphics/cg/SubimageCacheWithTimer.cpp

index 86714e32881cc3c88e523337ef69fced93d7354f..b3981797a3f043718ee32135e5377f62dae7c56d 100644 (file)
--- a/Source/WebCore/platform/graphics/cg/SubimageCacheWithTimer.cpp
+++ b/Source/WebCore/platform/graphics/cg/SubimageCacheWithTimer.cpp
@@ -61,7 +61,7 @@ struct SubimageCacheAdder {
  };
  
  SubimageCacheWithTimer::SubimageCacheWithTimer()
-    : m_timer(this, &SubimageCacheWithTimer::invalidateCacheTimerFired, subimageCacheClearDelay)
+    : m_timer(*this, &SubimageCacheWithTimer::invalidateCacheTimerFired, subimageCacheClearDelay)
  {
  }
  
diff --git a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h b/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h

index ea35e2000b8ecdec2908bb17c5acee15f14f4e48..11b6a06b4d529e4b64612ffc1e8b6aa53741de6a 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h
+++ b/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h
@@ -158,7 +158,7 @@ private:
      void updateStates();
      void doSeek();
      void cancelSeek();
-    void seekTimerFired(Timer&);
+    void seekTimerFired();
      MediaTime maxMediaTimeLoaded() const;
      void disableUnsupportedTracks();
      
diff --git a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm b/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm

index 56b3d2f60a1bd21357cc3aacc7c25568247c9ad8..25f680868e9743cb0aedc967010b0f4d7c3b9d56 100644 (file)
--- a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm
+++ b/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm
@@ -183,7 +183,7 @@ MediaPlayerPrivateQTKit::MediaPlayerPrivateQTKit(MediaPlayer* player)
      : m_player(player)
      , m_objcObserver(adoptNS([[WebCoreMovieObserver alloc] initWithCallback:this]))
      , m_seekTo(MediaTime::invalidTime())
-    , m_seekTimer(this, &MediaPlayerPrivateQTKit::seekTimerFired)
+    , m_seekTimer(*this, &MediaPlayerPrivateQTKit::seekTimerFired)
      , m_networkState(MediaPlayer::Empty)
      , m_readyState(MediaPlayer::HaveNothing)
      , m_rect()
@@ -678,7 +678,7 @@ void MediaPlayerPrivateQTKit::cancelSeek()
      m_seekTimer.stop();
  }
  
-void MediaPlayerPrivateQTKit::seekTimerFired(Timer&)
+void MediaPlayerPrivateQTKit::seekTimerFired()
  {        
      if (!metaDataAvailable() || !seeking() || currentMediaTime() == m_seekTo) {
          cancelSeek();
diff --git a/Source/WebCore/platform/ios/LegacyTileCache.h b/Source/WebCore/platform/ios/LegacyTileCache.h

index f8759a442f62ae784c5407bb23409415bc84e800..4f3a542810420df7621faa761aa33755996c5475 100644 (file)
--- a/Source/WebCore/platform/ios/LegacyTileCache.h
+++ b/Source/WebCore/platform/ios/LegacyTileCache.h
@@ -169,7 +169,7 @@ private:
      void createTilesInActiveGrid(SynchronousTileCreationMode);
      void scheduleLayerFlushForPendingRepaint();
  
-    void tileCreationTimerFired(Timer*);
+    void tileCreationTimerFired();
  
      void drawReplacementImage(LegacyTileLayer*, CGContextRef, CGImageRef);
      void drawWindowContent(LegacyTileLayer*, CGContextRef, CGRect dirtyRect);
diff --git a/Source/WebCore/platform/ios/LegacyTileCache.mm b/Source/WebCore/platform/ios/LegacyTileCache.mm

index 7fa8a6efd905fe8e2f05f9af0482cc5bcd7cfe01..32e973689570b40cd4d1cf5f77d967cc811f3219 100644 (file)
--- a/Source/WebCore/platform/ios/LegacyTileCache.mm
+++ b/Source/WebCore/platform/ios/LegacyTileCache.mm
@@ -83,7 +83,7 @@ LegacyTileCache::LegacyTileCache(WAKWindow* window)
      , m_didCallWillStartScrollingOrZooming(false)
      , m_zoomedOutTileGrid(PassOwnPtr<LegacyTileGrid>())
      , m_zoomedInTileGrid(PassOwnPtr<LegacyTileGrid>())
-    , m_tileCreationTimer(this, &LegacyTileCache::tileCreationTimerFired)
+    , m_tileCreationTimer(*this, &LegacyTileCache::tileCreationTimerFired)
      , m_currentScale(1.f)
      , m_pendingScale(0)
      , m_pendingZoomedOutScale(0)
@@ -415,7 +415,7 @@ void LegacyTileCache::finishedCreatingTiles(bool didCreateTiles, bool createMore
          m_tileCreationTimer.startOneShot(0);
  }
  
-void LegacyTileCache::tileCreationTimerFired(Timer*)
+void LegacyTileCache::tileCreationTimerFired()
  {
      if (isTileCreationSuspended())
          return;
diff --git a/Source/WebCore/platform/mac/HIDGamepadProvider.cpp b/Source/WebCore/platform/mac/HIDGamepadProvider.cpp

index c491cddbda4165cb7659ed7bfc566a54874c89f8..24f1b08475c75c4913463941fa0e5fa2b01c5dbb 100644 (file)
--- a/Source/WebCore/platform/mac/HIDGamepadProvider.cpp
+++ b/Source/WebCore/platform/mac/HIDGamepadProvider.cpp
@@ -81,8 +81,8 @@ HIDGamepadProvider& HIDGamepadProvider::shared()
  
  HIDGamepadProvider::HIDGamepadProvider()
      : m_shouldDispatchCallbacks(false)
-    , m_connectionDelayTimer(this, &HIDGamepadProvider::connectionDelayTimerFired)
-    , m_inputNotificationTimer(this, &HIDGamepadProvider::inputNotificationTimerFired)
+    , m_connectionDelayTimer(*this, &HIDGamepadProvider::connectionDelayTimerFired)
+    , m_inputNotificationTimer(*this, &HIDGamepadProvider::inputNotificationTimerFired)
  {
      m_manager = adoptCF(IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone));
  
@@ -108,7 +108,7 @@ unsigned HIDGamepadProvider::indexForNewlyConnectedDevice()
      return index;
  }
  
-void HIDGamepadProvider::connectionDelayTimerFired(Timer&)
+void HIDGamepadProvider::connectionDelayTimerFired()
  {
      m_shouldDispatchCallbacks = true;
  }
@@ -228,7 +228,7 @@ void HIDGamepadProvider::valuesChanged(IOHIDValueRef value)
          m_inputNotificationTimer.startOneShot(InputNotificationDelay);
  }
  
-void HIDGamepadProvider::inputNotificationTimerFired(Timer&)
+void HIDGamepadProvider::inputNotificationTimerFired()
  {
      if (!m_shouldDispatchCallbacks)
          return;
diff --git a/Source/WebCore/platform/mac/HIDGamepadProvider.h b/Source/WebCore/platform/mac/HIDGamepadProvider.h

index ffe75adf04e9ecae52387f2c766c99b1b918d5b5..80e30eecb0531659560210f3becc7d86ec2529cd 100644 (file)
--- a/Source/WebCore/platform/mac/HIDGamepadProvider.h
+++ b/Source/WebCore/platform/mac/HIDGamepadProvider.h
@@ -64,8 +64,8 @@ private:
      void openAndScheduleManager();
      void closeAndUnscheduleManager();
  
-    void connectionDelayTimerFired(Timer&);
-    void inputNotificationTimerFired(Timer&);
+    void connectionDelayTimerFired();
+    void inputNotificationTimerFired();
  
      unsigned indexForNewlyConnectedDevice();
  
diff --git a/Source/WebCore/platform/mac/ScrollAnimatorMac.h b/Source/WebCore/platform/mac/ScrollAnimatorMac.h

index b06cdee9f6b9a951dfebc2c6ebbbcf458498cb4c..99a1bb9a5d0455cbb9fb89fc30c3297bcca233b2 100644 (file)
--- a/Source/WebCore/platform/mac/ScrollAnimatorMac.h
+++ b/Source/WebCore/platform/mac/ScrollAnimatorMac.h
@@ -78,10 +78,10 @@ private:
      RetainPtr<WebScrollbarPainterDelegate> m_horizontalScrollbarPainterDelegate;
      RetainPtr<WebScrollbarPainterDelegate> m_verticalScrollbarPainterDelegate;
  
-    void initialScrollbarPaintTimerFired(Timer&);
+    void initialScrollbarPaintTimerFired();
      Timer m_initialScrollbarPaintTimer;
  
-    void sendContentAreaScrolledTimerFired(Timer&);
+    void sendContentAreaScrolledTimerFired();
      Timer m_sendContentAreaScrolledTimer;
      FloatSize m_contentAreaScrolledTimerScrollDelta;
  
@@ -155,7 +155,7 @@ private:
      virtual void adjustScrollPositionToBoundsIfNecessary() override;
  
      bool pinnedInDirection(float deltaX, float deltaY);
-    void snapRubberBandTimerFired(Timer&);
+    void snapRubberBandTimerFired();
  
      bool isAlreadyPinnedInDirectionOfGesture(const PlatformWheelEvent&, ScrollEventAxis);
  
diff --git a/Source/WebCore/platform/mac/ScrollAnimatorMac.mm b/Source/WebCore/platform/mac/ScrollAnimatorMac.mm

index 6afce1c58ad73057af255a26ad00866b07264ced..0a3610ef5abb358c806798713455c0431de44e4e 100644 (file)
--- a/Source/WebCore/platform/mac/ScrollAnimatorMac.mm
+++ b/Source/WebCore/platform/mac/ScrollAnimatorMac.mm
@@ -641,11 +641,11 @@ PassOwnPtr<ScrollAnimator> ScrollAnimator::create(ScrollableArea* scrollableArea
  
  ScrollAnimatorMac::ScrollAnimatorMac(ScrollableArea* scrollableArea)
      : ScrollAnimator(scrollableArea)
-    , m_initialScrollbarPaintTimer(this, &ScrollAnimatorMac::initialScrollbarPaintTimerFired)
-    , m_sendContentAreaScrolledTimer(this, &ScrollAnimatorMac::sendContentAreaScrolledTimerFired)
+    , m_initialScrollbarPaintTimer(*this, &ScrollAnimatorMac::initialScrollbarPaintTimerFired)
+    , m_sendContentAreaScrolledTimer(*this, &ScrollAnimatorMac::sendContentAreaScrolledTimerFired)
  #if ENABLE(RUBBER_BANDING)
      , m_scrollElasticityController(this)
-    , m_snapRubberBandTimer(this, &ScrollAnimatorMac::snapRubberBandTimerFired)
+    , m_snapRubberBandTimer(*this, &ScrollAnimatorMac::snapRubberBandTimerFired)
  #endif
      , m_haveScrolledSincePageLoad(false)
      , m_needsScrollerStyleUpdate(false)
@@ -1258,7 +1258,7 @@ void ScrollAnimatorMac::stopSnapRubberbandTimer()
      m_snapRubberBandTimer.stop();
  }
  
-void ScrollAnimatorMac::snapRubberBandTimerFired(Timer&)
+void ScrollAnimatorMac::snapRubberBandTimerFired()
  {
      m_scrollElasticityController.snapRubberBandTimerFired();
  }
@@ -1339,7 +1339,7 @@ void ScrollAnimatorMac::stopScrollbarPaintTimer()
      m_initialScrollbarPaintTimer.stop();
  }
  
-void ScrollAnimatorMac::initialScrollbarPaintTimerFired(Timer&)
+void ScrollAnimatorMac::initialScrollbarPaintTimerFired()
  {
      // 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.
@@ -1363,7 +1363,7 @@ void ScrollAnimatorMac::sendContentAreaScrolled(const FloatSize& delta)
          [m_scrollbarPainterController contentAreaScrolled];
  }
  
-void ScrollAnimatorMac::sendContentAreaScrolledTimerFired(Timer&)
+void ScrollAnimatorMac::sendContentAreaScrolledTimerFired()
  {
      sendContentAreaScrolled(m_contentAreaScrolledTimerScrollDelta);
      m_contentAreaScrolledTimerScrollDelta = FloatSize();
diff --git a/Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp b/Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp

index 3a7a1e720db807dff7b67dc9b387175940dfd6ca..af0a834c320422b3e1fa430ee1e2672d8d6101c2 100644 (file)
--- a/Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp
+++ b/Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp
@@ -32,7 +32,7 @@ namespace WebCore {
  
  DeviceOrientationClientMock::DeviceOrientationClientMock()
      : m_controller(0)
-    , m_timer(this, &DeviceOrientationClientMock::timerFired)
+    , m_timer(*this, &DeviceOrientationClientMock::timerFired)
      , m_isUpdating(false)
  {
  }
@@ -62,9 +62,8 @@ void DeviceOrientationClientMock::setOrientation(PassRefPtr<DeviceOrientationDat
          m_timer.startOneShot(0);
  }
  
-void DeviceOrientationClientMock::timerFired(Timer& timer)
+void DeviceOrientationClientMock::timerFired()
  {
-    ASSERT_UNUSED(timer, &timer == &m_timer);
      m_timer.stop();
      m_controller->didChangeDeviceOrientation(m_orientation.get());
  }
diff --git a/Source/WebCore/platform/mock/DeviceOrientationClientMock.h b/Source/WebCore/platform/mock/DeviceOrientationClientMock.h

index 6948b925a372aa850b5d6716172b940149a6cac3..33adbe72f82c613726fb8ac438832b8fe3e6bd2f 100644 (file)
--- a/Source/WebCore/platform/mock/DeviceOrientationClientMock.h
+++ b/Source/WebCore/platform/mock/DeviceOrientationClientMock.h
@@ -54,7 +54,7 @@ public:
      WEBCORE_EXPORT void setOrientation(PassRefPtr<DeviceOrientationData>);
  
  private:
-    void timerFired(Timer&);
+    void timerFired();
  
      RefPtr<DeviceOrientationData> m_orientation;
      DeviceOrientationController* m_controller;
diff --git a/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp b/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp

index eecba7746a63eb5fe9d2517c72f287c2a0f7fdac..3838372c5778ec272c8b55f8315065384d9cf874 100644 (file)
--- a/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp
+++ b/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp
@@ -33,7 +33,7 @@ namespace WebCore {
  
  PlatformSpeechSynthesizerMock::PlatformSpeechSynthesizerMock(PlatformSpeechSynthesizerClient* client)
      : PlatformSpeechSynthesizer(client)
-    , m_speakingFinishedTimer(this, &PlatformSpeechSynthesizerMock::speakingFinished)
+    , m_speakingFinishedTimer(*this, &PlatformSpeechSynthesizerMock::speakingFinished)
  {
  }
      
@@ -41,7 +41,7 @@ PlatformSpeechSynthesizerMock::~PlatformSpeechSynthesizerMock()
  {
  }
  
-void PlatformSpeechSynthesizerMock::speakingFinished(Timer*)
+void PlatformSpeechSynthesizerMock::speakingFinished()
  {
      ASSERT(m_utterance.get());
      RefPtr<PlatformSpeechSynthesisUtterance> protect(m_utterance);
diff --git a/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.h b/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.h

index 82940a8eccc0d75b0ef1a56cee0defd490024675..8d97488b02d0d213b8556e5334b57a28b2937e03 100644 (file)
--- a/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.h
+++ b/Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.h
@@ -45,7 +45,7 @@ public:
      
  private:
      virtual void initializeVoiceList();
-    void speakingFinished(Timer*);
+    void speakingFinished();
      
      Timer m_speakingFinishedTimer;
      RefPtr<PlatformSpeechSynthesisUtterance> m_utterance;
diff --git a/Source/WebCore/platform/network/DNSResolveQueue.cpp b/Source/WebCore/platform/network/DNSResolveQueue.cpp

index 6c1032788e9975ba7efb99af4fa05b273a18eab6..85ea6671c020797419a5d4ac346e5c8533b85bc2 100644 (file)
--- a/Source/WebCore/platform/network/DNSResolveQueue.cpp
+++ b/Source/WebCore/platform/network/DNSResolveQueue.cpp
@@ -58,7 +58,7 @@ DNSResolveQueue& DNSResolveQueue::shared()
  }
  
  DNSResolveQueue::DNSResolveQueue()
-    : m_timer(this, &DNSResolveQueue::timerFired)
+    : m_timer(*this, &DNSResolveQueue::timerFired)
      , m_requestsInFlight(0)
      , m_cachedProxyEnabledStatus(false)
      , m_lastProxyEnabledStatusCheckTime(0)
@@ -98,7 +98,7 @@ void DNSResolveQueue::add(const String& hostname)
      }
  }
  
-void DNSResolveQueue::timerFired(Timer&)
+void DNSResolveQueue::timerFired()
  {
      if (isUsingProxy()) {
          m_names.clear();
diff --git a/Source/WebCore/platform/network/DNSResolveQueue.h b/Source/WebCore/platform/network/DNSResolveQueue.h

index ad6f18bfb0b824c0181358c5f1f601d785319d99..cd9ba0fc0e2a56ef4daa4fb966d7c9e432940cbf 100644 (file)
--- a/Source/WebCore/platform/network/DNSResolveQueue.h
+++ b/Source/WebCore/platform/network/DNSResolveQueue.h
@@ -55,7 +55,7 @@ private:
      bool platformProxyIsEnabledInSystemPreferences();
      void platformResolve(const String&);
  
-    void timerFired(Timer&);
+    void timerFired();
  
      Timer m_timer;
  
diff --git a/Source/WebCore/platform/network/NetworkStateNotifier.h b/Source/WebCore/platform/network/NetworkStateNotifier.h

index 113544bdf1717c750ec009c618f36760abcf99cb..e22a4a0081112d2aad609ea8cefc58372a198b10 100644 (file)
--- a/Source/WebCore/platform/network/NetworkStateNotifier.h
+++ b/Source/WebCore/platform/network/NetworkStateNotifier.h
@@ -73,7 +73,7 @@ private:
      void updateState();
  
  #if PLATFORM(MAC)
-    void networkStateChangeTimerFired(Timer&);
+    void networkStateChangeTimerFired();
  
      static void dynamicStoreCallback(SCDynamicStoreRef, CFArrayRef changedKeys, void *info); 
  
diff --git a/Source/WebCore/platform/network/ResourceHandle.cpp b/Source/WebCore/platform/network/ResourceHandle.cpp

index 3ae5200e9d046b31d4aee6dc11c90912522a4327..d6c315fab4958eb01c41fab28785802f297b0847 100644 (file)
--- a/Source/WebCore/platform/network/ResourceHandle.cpp
+++ b/Source/WebCore/platform/network/ResourceHandle.cpp
@@ -108,7 +108,7 @@ void ResourceHandle::scheduleFailure(FailureType type)
      d->m_failureTimer.startOneShot(0);
  }
  
-void ResourceHandle::failureTimerFired(Timer&)
+void ResourceHandle::failureTimerFired()
  {
      if (!client())
          return;
diff --git a/Source/WebCore/platform/network/ResourceHandle.h b/Source/WebCore/platform/network/ResourceHandle.h

index 607f38d35875d01a8b952860e4bb4214ff759261..6073f102505eb5844036d8522cdfa281b12b7f13 100644 (file)
--- a/Source/WebCore/platform/network/ResourceHandle.h
+++ b/Source/WebCore/platform/network/ResourceHandle.h
@@ -240,7 +240,7 @@ public:
      WEBCORE_EXPORT ResourceRequest& firstRequest();
      const String& lastHTTPMethod() const;
  
-    void failureTimerFired(Timer&);
+    void failureTimerFired();
  
      NetworkingContext* context() const;
  
diff --git a/Source/WebCore/platform/network/ResourceHandleInternal.h b/Source/WebCore/platform/network/ResourceHandleInternal.h

index 1aa4cd5b27fcfc38db6657649ceb0758cd415fc9..c58c347afde4fcd20cf7aaca78d2ce432b38965b 100644 (file)
--- a/Source/WebCore/platform/network/ResourceHandleInternal.h
+++ b/Source/WebCore/platform/network/ResourceHandleInternal.h
@@ -119,7 +119,7 @@ namespace WebCore {
              , m_currentMacChallenge(nil)
  #endif
              , m_scheduledFailureType(ResourceHandle::NoFailure)
-            , m_failureTimer(loader, &ResourceHandle::failureTimerFired)
+            , m_failureTimer(*loader, &ResourceHandle::failureTimerFired)
          {
              const URL& url = m_firstRequest.url();
              m_user = url.user();
diff --git a/Source/WebCore/platform/network/mac/NetworkStateNotifierMac.cpp b/Source/WebCore/platform/network/mac/NetworkStateNotifierMac.cpp

index 00538bf32ab12423b424ce2b97eff564964e9772..55ade218c13888c0cc26ebecb79263dca700916d 100644 (file)
--- a/Source/WebCore/platform/network/mac/NetworkStateNotifierMac.cpp
+++ b/Source/WebCore/platform/network/mac/NetworkStateNotifierMac.cpp
@@ -81,7 +81,7 @@ void NetworkStateNotifier::dynamicStoreCallback(SCDynamicStoreRef, CFArrayRef, v
      notifier->m_networkStateChangeTimer.startOneShot(StateChangeTimerInterval);
  }
  
-void NetworkStateNotifier::networkStateChangeTimerFired(Timer&)
+void NetworkStateNotifier::networkStateChangeTimerFired()
  {
      bool oldOnLine = m_isOnLine;
      
@@ -95,7 +95,7 @@ void NetworkStateNotifier::networkStateChangeTimerFired(Timer&)
  
  NetworkStateNotifier::NetworkStateNotifier()
      : m_isOnLine(false)
-    , m_networkStateChangeTimer(this, &NetworkStateNotifier::networkStateChangeTimerFired)
+    , m_networkStateChangeTimer(*this, &NetworkStateNotifier::networkStateChangeTimerFired)
  {
      SCDynamicStoreContext context = { 0, this, 0, 0, 0 };
      
diff --git a/Source/WebCore/rendering/ImageQualityController.cpp b/Source/WebCore/rendering/ImageQualityController.cpp

index 27c051c15decf38f85b973a10a8b47aa5ddd029d..c4a6e43c6722f410f7bf90d108b8c560c320009c 100644 (file)
--- a/Source/WebCore/rendering/ImageQualityController.cpp
+++ b/Source/WebCore/rendering/ImageQualityController.cpp
@@ -39,7 +39,7 @@ static const double cLowQualityTimeThreshold = 0.500; // 500 ms
  
  ImageQualityController::ImageQualityController(const RenderView& renderView)
      : m_renderView(renderView)
-    , m_timer(this, &ImageQualityController::highQualityRepaintTimerFired)
+    , m_timer(*this, &ImageQualityController::highQualityRepaintTimerFired)
      , m_animatedResizeIsActive(false)
      , m_liveResizeOptimizationIsActive(false)
  {
@@ -74,7 +74,7 @@ void ImageQualityController::removeObject(RenderBoxModelObject* object)
      }
  }
  
-void ImageQualityController::highQualityRepaintTimerFired(Timer&)
+void ImageQualityController::highQualityRepaintTimerFired()
  {
      if (m_renderView.documentBeingDestroyed())
          return;
diff --git a/Source/WebCore/rendering/ImageQualityController.h b/Source/WebCore/rendering/ImageQualityController.h

index a5b6f01a6dfd1c3997403d916bd27e4806e83557..dcee0f96f88c8ac2a1b1336085beb4ea7c304caa 100644 (file)
--- a/Source/WebCore/rendering/ImageQualityController.h
+++ b/Source/WebCore/rendering/ImageQualityController.h
@@ -52,7 +52,7 @@ private:
  
      void removeLayer(RenderBoxModelObject*, LayerSizeMap* innerMap, const void* layer);
      void set(RenderBoxModelObject*, LayerSizeMap* innerMap, const void* layer, const LayoutSize&);
-    void highQualityRepaintTimerFired(Timer&);
+    void highQualityRepaintTimerFired();
      void restartTimer();
      void removeObject(RenderBoxModelObject*);
  
diff --git a/Source/WebCore/rendering/RenderButton.cpp b/Source/WebCore/rendering/RenderButton.cpp

index 9ef4e11bf2f81091ce5c84803e48d7b3f68a8250..b8361dd140f00697f5a330b4e5453e39cc5165b7 100644 (file)
--- a/Source/WebCore/rendering/RenderButton.cpp
+++ b/Source/WebCore/rendering/RenderButton.cpp
@@ -116,7 +116,7 @@ void RenderButton::styleDidChange(StyleDifference diff, const RenderStyle* oldSt
      if (!m_default && theme().isDefault(*this)) {
          if (theme().defaultButtonHasAnimation()) {
              if (!m_timer)
-                m_timer = std::make_unique<Timer>(this, &RenderButton::timerFired);
+                m_timer = std::make_unique<Timer>(*this, &RenderButton::timerFired);
              m_timer->startRepeating(0.03);
          }
          m_default = true;
@@ -187,7 +187,7 @@ LayoutRect RenderButton::controlClipRect(const LayoutPoint& additionalOffset) co
      return LayoutRect(additionalOffset.x() + borderLeft(), additionalOffset.y() + borderTop(), width() - borderLeft() - borderRight(), height() - borderTop() - borderBottom());
  }
  
-void RenderButton::timerFired(Timer&)
+void RenderButton::timerFired()
  {
      // FIXME Bug 25110: Ideally we would stop our timer when our Document
      // enters the page cache. But we currently have no way of being notified
diff --git a/Source/WebCore/rendering/RenderButton.h b/Source/WebCore/rendering/RenderButton.h

index 0dbf51f682356479b62da1349d2a4d9cea030b57..06136b8c9e0c9869994bc05cbd79964e3bb9bcd1 100644 (file)
author	andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Fri, 21 Nov 2014 20:10:13 +0000 (20:10 +0000)
committer	andersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Fri, 21 Nov 2014 20:10:13 +0000 (20:10 +0000)
Source/WTF/ChangeLog		patch \| blob \| history
Source/WTF/wtf/RunLoopTimer.h		patch \| blob \| history
Source/WebCore/ChangeLog		patch \| blob \| history
Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp		patch \| blob \| history
Source/WebCore/Modules/encryptedmedia/MediaKeySession.h		patch \| blob \| history
Source/WebCore/Modules/geolocation/Geolocation.cpp		patch \| blob \| history
Source/WebCore/Modules/geolocation/Geolocation.h		patch \| blob \| history
Source/WebCore/Modules/indexeddb/IDBTransactionBackend.cpp		patch \| blob \| history
Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h		patch \| blob \| history
Source/WebCore/Modules/mediasource/SourceBuffer.cpp		patch \| blob \| history
Source/WebCore/Modules/mediasource/SourceBuffer.h		patch \| blob \| history
Source/WebCore/Modules/mediastream/MediaStream.cpp		patch \| blob \| history
Source/WebCore/Modules/mediastream/MediaStream.h		patch \| blob \| history
Source/WebCore/Modules/mediastream/RTCDTMFSender.cpp		patch \| blob \| history
Source/WebCore/Modules/mediastream/RTCDTMFSender.h		patch \| blob \| history
Source/WebCore/Modules/mediastream/RTCDataChannel.cpp		patch \| blob \| history
Source/WebCore/Modules/mediastream/RTCDataChannel.h		patch \| blob \| history
Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp		patch \| blob \| history
Source/WebCore/Modules/mediastream/RTCPeerConnection.h		patch \| blob \| history
Source/WebCore/Modules/notifications/Notification.cpp		patch \| blob \| history
Source/WebCore/Modules/notifications/Notification.h		patch \| blob \| history
Source/WebCore/Modules/notifications/NotificationCenter.cpp		patch \| blob \| history
Source/WebCore/Modules/notifications/NotificationCenter.h		patch \| blob \| history
Source/WebCore/Modules/websockets/WebSocketChannel.cpp		patch \| blob \| history
Source/WebCore/Modules/websockets/WebSocketChannel.h		patch \| blob \| history
Source/WebCore/accessibility/AXObjectCache.cpp		patch \| blob \| history
Source/WebCore/accessibility/AXObjectCache.h		patch \| blob \| history
Source/WebCore/bindings/js/GCController.cpp		patch \| blob \| history
Source/WebCore/bindings/js/GCController.h		patch \| blob \| history
Source/WebCore/css/CSSFontFaceSource.h		patch \| blob \| history
Source/WebCore/css/CSSFontSelector.cpp		patch \| blob \| history
Source/WebCore/css/CSSFontSelector.h		patch \| blob \| history
Source/WebCore/css/CSSImageGeneratorValue.cpp		patch \| blob \| history
Source/WebCore/css/FontLoader.cpp		patch \| blob \| history
Source/WebCore/css/FontLoader.h		patch \| blob \| history
Source/WebCore/css/StyleResolver.cpp		patch \| blob \| history
Source/WebCore/css/StyleResolver.h		patch \| blob \| history
Source/WebCore/dom/Document.cpp		patch \| blob \| history
Source/WebCore/dom/Document.h		patch \| blob \| history
Source/WebCore/dom/EventSender.h		patch \| blob \| history
Source/WebCore/dom/ScriptRunner.cpp		patch \| blob \| history
Source/WebCore/dom/ScriptRunner.h		patch \| blob \| history
Source/WebCore/dom/ScriptedAnimationController.cpp		patch \| blob \| history
Source/WebCore/dom/ScriptedAnimationController.h		patch \| blob \| history
Source/WebCore/dom/StyledElement.cpp		patch \| blob \| history
Source/WebCore/editing/AlternativeTextController.cpp		patch \| blob \| history
Source/WebCore/editing/AlternativeTextController.h		patch \| blob \| history
Source/WebCore/editing/Editor.cpp		patch \| blob \| history
Source/WebCore/editing/Editor.h		patch \| blob \| history
Source/WebCore/editing/FrameSelection.cpp		patch \| blob \| history
Source/WebCore/editing/FrameSelection.h		patch \| blob \| history
Source/WebCore/editing/SpellChecker.cpp		patch \| blob \| history
Source/WebCore/editing/SpellChecker.h		patch \| blob \| history
Source/WebCore/html/HTMLFormElement.cpp		patch \| blob \| history
Source/WebCore/html/HTMLFormElement.h		patch \| blob \| history
Source/WebCore/html/HTMLMediaElement.cpp		patch \| blob \| history
Source/WebCore/html/HTMLMediaElement.h		patch \| blob \| history
Source/WebCore/html/HTMLPlugInElement.cpp		patch \| blob \| history
Source/WebCore/html/HTMLPlugInElement.h		patch \| blob \| history
Source/WebCore/html/HTMLPlugInImageElement.cpp		patch \| blob \| history
Source/WebCore/html/HTMLPlugInImageElement.h		patch \| blob \| history
Source/WebCore/html/HTMLSourceElement.cpp		patch \| blob \| history
Source/WebCore/html/HTMLSourceElement.h		patch \| blob \| history
Source/WebCore/html/HTMLTrackElement.cpp		patch \| blob \| history
Source/WebCore/html/HTMLTrackElement.h		patch \| blob \| history
Source/WebCore/html/MediaController.cpp		patch \| blob \| history
Source/WebCore/html/MediaController.h		patch \| blob \| history
Source/WebCore/html/MediaDocument.cpp		patch \| blob \| history
Source/WebCore/html/MediaDocument.h		patch \| blob \| history
Source/WebCore/html/SearchInputType.cpp		patch \| blob \| history
Source/WebCore/html/SearchInputType.h		patch \| blob \| history
Source/WebCore/html/ValidationMessage.cpp		patch \| blob \| history
Source/WebCore/html/ValidationMessage.h		patch \| blob \| history
Source/WebCore/html/canvas/WebGLRenderingContext.cpp		patch \| blob \| history
Source/WebCore/html/canvas/WebGLRenderingContext.h		patch \| blob \| history
Source/WebCore/html/parser/HTMLParserScheduler.cpp		patch \| blob \| history
Source/WebCore/html/parser/HTMLParserScheduler.h		patch \| blob \| history
Source/WebCore/html/shadow/MediaControlElements.cpp		patch \| blob \| history
Source/WebCore/html/shadow/MediaControlElements.h		patch \| blob \| history
Source/WebCore/html/shadow/MediaControls.cpp		patch \| blob \| history
Source/WebCore/html/shadow/MediaControls.h		patch \| blob \| history
Source/WebCore/html/shadow/SpinButtonElement.cpp		patch \| blob \| history
Source/WebCore/html/shadow/SpinButtonElement.h		patch \| blob \| history
Source/WebCore/html/track/LoadableTextTrack.cpp		patch \| blob \| history
Source/WebCore/html/track/LoadableTextTrack.h		patch \| blob \| history
Source/WebCore/html/track/VTTRegion.cpp		patch \| blob \| history
Source/WebCore/html/track/VTTRegion.h		patch \| blob \| history
Source/WebCore/inspector/InspectorCSSAgent.cpp		patch \| blob \| history
Source/WebCore/inspector/InspectorDOMAgent.cpp		patch \| blob \| history
Source/WebCore/inspector/InspectorFrontendClientLocal.cpp		patch \| blob \| history
Source/WebCore/inspector/InspectorOverlay.cpp		patch \| blob \| history
Source/WebCore/inspector/InspectorOverlay.h		patch \| blob \| history
Source/WebCore/loader/DocumentLoader.cpp		patch \| blob \| history
Source/WebCore/loader/DocumentLoader.h		patch \| blob \| history
Source/WebCore/loader/FrameLoader.cpp		patch \| blob \| history
Source/WebCore/loader/FrameLoader.h		patch \| blob \| history
Source/WebCore/loader/ImageLoader.cpp		patch \| blob \| history
Source/WebCore/loader/ImageLoader.h		patch \| blob \| history
Source/WebCore/loader/LinkLoader.cpp		patch \| blob \| history
Source/WebCore/loader/LinkLoader.h		patch \| blob \| history
Source/WebCore/loader/NavigationScheduler.cpp		patch \| blob \| history
Source/WebCore/loader/NavigationScheduler.h		patch \| blob \| history
Source/WebCore/loader/PingLoader.cpp		patch \| blob \| history
Source/WebCore/loader/PingLoader.h		patch \| blob \| history
Source/WebCore/loader/ProgressTracker.cpp		patch \| blob \| history
Source/WebCore/loader/ProgressTracker.h		patch \| blob \| history
Source/WebCore/loader/ResourceLoadScheduler.cpp		patch \| blob \| history
Source/WebCore/loader/ResourceLoadScheduler.h		patch \| blob \| history
Source/WebCore/loader/TextTrackLoader.cpp		patch \| blob \| history
Source/WebCore/loader/TextTrackLoader.h		patch \| blob \| history
Source/WebCore/loader/cache/CachedResource.cpp		patch \| blob \| history
Source/WebCore/loader/cache/CachedResource.h		patch \| blob \| history
Source/WebCore/loader/cache/CachedResourceLoader.cpp		patch \| blob \| history
Source/WebCore/loader/cache/CachedResourceLoader.h		patch \| blob \| history
Source/WebCore/loader/icon/IconDatabase.cpp		patch \| blob \| history
Source/WebCore/loader/icon/IconDatabase.h		patch \| blob \| history
Source/WebCore/page/AutoscrollController.cpp		patch \| blob \| history
Source/WebCore/page/AutoscrollController.h		patch \| blob \| history
Source/WebCore/page/CaptionUserPreferences.cpp		patch \| blob \| history
Source/WebCore/page/CaptionUserPreferences.h		patch \| blob \| history
Source/WebCore/page/CaptionUserPreferencesMediaAF.cpp		patch \| blob \| history
Source/WebCore/page/CaptionUserPreferencesMediaAF.h		patch \| blob \| history
Source/WebCore/page/DeviceController.cpp		patch \| blob \| history
Source/WebCore/page/DeviceController.h		patch \| blob \| history
Source/WebCore/page/EventHandler.cpp		patch \| blob \| history
Source/WebCore/page/EventHandler.h		patch \| blob \| history
Source/WebCore/page/EventSource.cpp		patch \| blob \| history
Source/WebCore/page/EventSource.h		patch \| blob \| history
Source/WebCore/page/FocusController.cpp		patch \| blob \| history
Source/WebCore/page/FocusController.h		patch \| blob \| history
Source/WebCore/page/Frame.cpp		patch \| blob \| history
Source/WebCore/page/Frame.h		patch \| blob \| history
Source/WebCore/page/FrameView.cpp		patch \| blob \| history
Source/WebCore/page/FrameView.h		patch \| blob \| history
Source/WebCore/page/PageOverlay.cpp		patch \| blob \| history
Source/WebCore/page/PageOverlay.h		patch \| blob \| history
Source/WebCore/page/Settings.cpp		patch \| blob \| history
Source/WebCore/page/Settings.h		patch \| blob \| history
Source/WebCore/page/animation/AnimationController.cpp		patch \| blob \| history
Source/WebCore/page/animation/AnimationControllerPrivate.h		patch \| blob \| history
Source/WebCore/page/mac/ServicesOverlayController.h		patch \| blob \| history
Source/WebCore/page/mac/ServicesOverlayController.mm		patch \| blob \| history
Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp		patch \| blob \| history
Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h		patch \| blob \| history
Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.h		patch \| blob \| history
Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.mm		patch \| blob \| history
Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.h		patch \| blob \| history
Source/WebCore/page/scrolling/mac/ScrollingCoordinatorMac.mm		patch \| blob \| history
Source/WebCore/platform/HysteresisActivity.h		patch \| blob \| history
Source/WebCore/platform/ScrollAnimator.cpp		patch \| blob \| history
Source/WebCore/platform/ScrollAnimator.h		patch \| blob \| history
Source/WebCore/platform/Scrollbar.cpp		patch \| blob \| history
Source/WebCore/platform/Scrollbar.h		patch \| blob \| history
Source/WebCore/platform/Timer.h		patch \| blob \| history
Source/WebCore/platform/audio/MediaSession.cpp		patch \| blob \| history
Source/WebCore/platform/audio/MediaSession.h		patch \| blob \| history
Source/WebCore/platform/graphics/BitmapImage.cpp		patch \| blob \| history
Source/WebCore/platform/graphics/BitmapImage.h		patch \| blob \| history
Source/WebCore/platform/graphics/MediaPlayer.cpp		patch \| blob \| history
Source/WebCore/platform/graphics/MediaPlayer.h		patch \| blob \| history
Source/WebCore/platform/graphics/ShadowBlur.cpp		patch \| blob \| history
Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.h		patch \| blob \| history
Source/WebCore/platform/graphics/avfoundation/MediaSelectionGroupAVFObjC.mm		patch \| blob \| history
Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h		patch \| blob \| history
Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm		patch \| blob \| history
Source/WebCore/platform/graphics/ca/LayerPool.cpp		patch \| blob \| history
Source/WebCore/platform/graphics/ca/LayerPool.h		patch \| blob \| history
Source/WebCore/platform/graphics/ca/TileController.cpp		patch \| blob \| history
Source/WebCore/platform/graphics/ca/TileController.h		patch \| blob \| history
Source/WebCore/platform/graphics/ca/TileGrid.cpp		patch \| blob \| history
Source/WebCore/platform/graphics/ca/TileGrid.h		patch \| blob \| history
Source/WebCore/platform/graphics/cg/IOSurfacePool.cpp		patch \| blob \| history
Source/WebCore/platform/graphics/cg/IOSurfacePool.h		patch \| blob \| history
Source/WebCore/platform/graphics/cg/SubimageCacheWithTimer.cpp		patch \| blob \| history
Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h		patch \| blob \| history
Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm		patch \| blob \| history
Source/WebCore/platform/ios/LegacyTileCache.h		patch \| blob \| history
Source/WebCore/platform/ios/LegacyTileCache.mm		patch \| blob \| history
Source/WebCore/platform/mac/HIDGamepadProvider.cpp		patch \| blob \| history
Source/WebCore/platform/mac/HIDGamepadProvider.h		patch \| blob \| history
Source/WebCore/platform/mac/ScrollAnimatorMac.h		patch \| blob \| history
Source/WebCore/platform/mac/ScrollAnimatorMac.mm		patch \| blob \| history
Source/WebCore/platform/mock/DeviceOrientationClientMock.cpp		patch \| blob \| history
Source/WebCore/platform/mock/DeviceOrientationClientMock.h		patch \| blob \| history
Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp		patch \| blob \| history
Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.h		patch \| blob \| history
Source/WebCore/platform/network/DNSResolveQueue.cpp		patch \| blob \| history
Source/WebCore/platform/network/DNSResolveQueue.h		patch \| blob \| history
Source/WebCore/platform/network/NetworkStateNotifier.h		patch \| blob \| history
Source/WebCore/platform/network/ResourceHandle.cpp		patch \| blob \| history
Source/WebCore/platform/network/ResourceHandle.h		patch \| blob \| history
Source/WebCore/platform/network/ResourceHandleInternal.h		patch \| blob \| history
Source/WebCore/platform/network/mac/NetworkStateNotifierMac.cpp		patch \| blob \| history
Source/WebCore/rendering/ImageQualityController.cpp		patch \| blob \| history
Source/WebCore/rendering/ImageQualityController.h		patch \| blob \| history
Source/WebCore/rendering/RenderButton.cpp		patch \| blob \| history
Source/WebCore/rendering/RenderButton.h		patch \| blob \| history
Source/WebCore/rendering/RenderLayerCompositor.cpp		patch \| blob \| history
Source/WebCore/rendering/RenderLayerCompositor.h		patch \| blob \| history
Source/WebCore/rendering/RenderMarquee.cpp		patch \| blob \| history
Source/WebCore/rendering/RenderMarquee.h		patch \| blob \| history
Source/WebCore/rendering/RenderNamedFlowThread.cpp		patch \| blob \| history
Source/WebCore/rendering/RenderNamedFlowThread.h		patch \| blob \| history
Source/WebCore/rendering/RenderProgress.cpp		patch \| blob \| history
Source/WebCore/rendering/RenderProgress.h		patch \| blob \| history
Source/WebCore/rendering/RenderView.cpp		patch \| blob \| history
Source/WebCore/rendering/RenderView.h		patch \| blob \| history
Source/WebCore/replay/EventLoopInputDispatcher.cpp		patch \| blob \| history
Source/WebCore/replay/EventLoopInputDispatcher.h		patch \| blob \| history
Source/WebCore/storage/StorageAreaImpl.cpp		patch \| blob \| history
Source/WebCore/storage/StorageAreaImpl.h		patch \| blob \| history
Source/WebCore/storage/StorageAreaSync.cpp		patch \| blob \| history
Source/WebCore/storage/StorageAreaSync.h		patch \| blob \| history
Source/WebCore/svg/SVGElement.cpp		patch \| blob \| history
Source/WebCore/svg/SVGElement.h		patch \| blob \| history
Source/WebCore/svg/SVGScriptElement.cpp		patch \| blob \| history
Source/WebCore/svg/SVGStyleElement.cpp		patch \| blob \| history
Source/WebCore/svg/SVGUseElement.cpp		patch \| blob \| history
Source/WebCore/svg/animation/SMILTimeContainer.cpp		patch \| blob \| history
Source/WebCore/svg/animation/SMILTimeContainer.h		patch \| blob \| history
Source/WebCore/xml/XMLHttpRequestProgressEventThrottle.cpp		patch \| blob \| history
Source/WebCore/xml/XMLHttpRequestProgressEventThrottle.h		patch \| blob \| history
Source/WebKit/mac/ChangeLog		patch \| blob \| history
Source/WebKit/mac/Plugins/Hosted/NetscapePluginInstanceProxy.h		patch \| blob \| history
Source/WebKit/mac/Plugins/Hosted/NetscapePluginInstanceProxy.mm		patch \| blob \| history
Source/WebKit/mac/Plugins/WebNetscapePluginStream.h		patch \| blob \| history
Source/WebKit/mac/Plugins/WebNetscapePluginStream.mm		patch \| blob \| history
Source/WebKit/win/ChangeLog		patch \| blob \| history
Source/WebKit/win/FullscreenVideoController.cpp		patch \| blob \| history
Source/WebKit/win/FullscreenVideoController.h		patch \| blob \| history
Source/WebKit2/ChangeLog		patch \| blob \| history
Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp		patch \| blob \| history
Source/WebKit2/NetworkProcess/NetworkResourceLoader.h		patch \| blob \| history
Source/WebKit2/Shared/WebMemorySampler.cpp		patch \| blob \| history
Source/WebKit2/Shared/WebMemorySampler.h		patch \| blob \| history
Source/WebKit2/Shared/mac/RemoteLayerBackingStoreCollection.h		patch \| blob \| history
Source/WebKit2/Shared/mac/RemoteLayerBackingStoreCollection.mm		patch \| blob \| history
Source/WebKit2/WebProcess/Plugins/PluginView.cpp		patch \| blob \| history
Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.h		patch \| blob \| history
Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerTreeDrawingArea.mm		patch \| blob \| history
Source/WebKit2/WebProcess/WebProcess.cpp		patch \| blob \| history
Source/WebKit2/WebProcess/WebProcess.h		patch \| blob \| history