<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[197690] trunk/Source</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/197690">197690</a></dd>
<dt>Author</dt> <dd>barraclough@apple.com</dd>
<dt>Date</dt> <dd>2016-03-07 10:41:56 -0800 (Mon, 07 Mar 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Convert DOMTimer to std::chrono::milliseconds
https://bugs.webkit.org/show_bug.cgi?id=155085
Reviewed by Andreas Kling.
DOMTimer currently uses a mix of millisecond (was int, now std::chrono) and second (as double)
time values. Constant conversion back and forth is a complete mess. Stop that.
Source/WebCore:
* dom/Document.cpp:
(WebCore::Document::minimumTimerInterval):
(WebCore::Document::timerAlignmentInterval):
* dom/Document.h:
- double -> std::chrono::milliseconds
* dom/ScriptExecutionContext.cpp:
(WebCore::ScriptExecutionContext::adjustMinimumTimerInterval):
(WebCore::ScriptExecutionContext::minimumTimerInterval):
(WebCore::ScriptExecutionContext::timerAlignmentInterval):
* dom/ScriptExecutionContext.h:
- double -> std::chrono::milliseconds
* page/DOMTimer.cpp:
(WebCore::DOMTimer::updateTimerIntervalIfNecessary):
(WebCore::DOMTimer::intervalClampedToMinimum):
(WebCore::DOMTimer::alignedFireTime):
* page/DOMTimer.h:
- double -> std::chrono::milliseconds
* page/Page.cpp:
(WebCore::Page::setTimerThrottlingState):
(WebCore::Page::setTimerAlignmentIntervalIncreaseLimit):
(WebCore::Page::updateDOMTimerAlignmentInterval):
* page/Page.h:
- double -> std::chrono::milliseconds
* page/Settings.cpp:
(WebCore::Settings::setNeedsAdobeFrameReloadingQuirk):
(WebCore::Settings::setMinimumDOMTimerInterval):
* page/Settings.h:
- double -> std::chrono::milliseconds
* page/SuspendableTimer.h:
(WebCore::SuspendableTimer::startRepeating):
(WebCore::SuspendableTimer::startOneShot):
(WebCore::SuspendableTimer::repeatIntervalMS):
(WebCore::SuspendableTimer::augmentFireInterval):
(WebCore::SuspendableTimer::augmentRepeatInterval):
- added std::chrono::milliseconds interface.
* platform/Timer.cpp:
(WebCore::TimerBase::setNextFireTime):
- restructured for new alignedFireTime signatured, moved zero-delay handling to here.
This change made because inside alignedFireTime fireTime will have already been truncated.
* platform/Timer.h:
(WebCore::TimerBase::msToSeconds):
(WebCore::TimerBase::secondsToMS):
- internal helper functions to bridge std::chrono::milliseconds to internal double.
(WebCore::TimerBase::startRepeating):
(WebCore::TimerBase::startOneShot):
(WebCore::TimerBase::repeatIntervalMS):
(WebCore::TimerBase::augmentFireInterval):
(WebCore::TimerBase::augmentRepeatInterval):
- expanded std::chrono::milliseconds interface.
(WebCore::TimerBase::alignedFireTime):
- changed to std::chrono::milliseconds, made return value Optional (null means no alignment).
* testing/InternalSettings.cpp:
(WebCore::InternalSettings::setMinimumTimerInterval):
* testing/InternalSettings.h:
- double -> std::chrono::milliseconds
Source/WebKit/win:
* WebView.cpp:
(WebView::setMinimumTimerInterval):
- Convert double argument into std::chrono::milliseconds.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoredomDocumentcpp">trunk/Source/WebCore/dom/Document.cpp</a></li>
<li><a href="#trunkSourceWebCoredomDocumenth">trunk/Source/WebCore/dom/Document.h</a></li>
<li><a href="#trunkSourceWebCoredomScriptExecutionContextcpp">trunk/Source/WebCore/dom/ScriptExecutionContext.cpp</a></li>
<li><a href="#trunkSourceWebCoredomScriptExecutionContexth">trunk/Source/WebCore/dom/ScriptExecutionContext.h</a></li>
<li><a href="#trunkSourceWebCorepageDOMTimercpp">trunk/Source/WebCore/page/DOMTimer.cpp</a></li>
<li><a href="#trunkSourceWebCorepageDOMTimerh">trunk/Source/WebCore/page/DOMTimer.h</a></li>
<li><a href="#trunkSourceWebCorepagePagecpp">trunk/Source/WebCore/page/Page.cpp</a></li>
<li><a href="#trunkSourceWebCorepagePageh">trunk/Source/WebCore/page/Page.h</a></li>
<li><a href="#trunkSourceWebCorepageSettingscpp">trunk/Source/WebCore/page/Settings.cpp</a></li>
<li><a href="#trunkSourceWebCorepageSettingsh">trunk/Source/WebCore/page/Settings.h</a></li>
<li><a href="#trunkSourceWebCorepageSuspendableTimerh">trunk/Source/WebCore/page/SuspendableTimer.h</a></li>
<li><a href="#trunkSourceWebCoreplatformTimercpp">trunk/Source/WebCore/platform/Timer.cpp</a></li>
<li><a href="#trunkSourceWebCoreplatformTimerh">trunk/Source/WebCore/platform/Timer.h</a></li>
<li><a href="#trunkSourceWebCoretestingInternalSettingscpp">trunk/Source/WebCore/testing/InternalSettings.cpp</a></li>
<li><a href="#trunkSourceWebCoretestingInternalSettingsh">trunk/Source/WebCore/testing/InternalSettings.h</a></li>
<li><a href="#trunkSourceWebKitwinChangeLog">trunk/Source/WebKit/win/ChangeLog</a></li>
<li><a href="#trunkSourceWebKitwinWebViewcpp">trunk/Source/WebKit/win/WebView.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/ChangeLog 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -1,3 +1,69 @@
</span><ins>+2016-03-06 Gavin Barraclough <barraclough@apple.com>
+
+ Convert DOMTimer to std::chrono::milliseconds
+ https://bugs.webkit.org/show_bug.cgi?id=155085
+
+ Reviewed by Andreas Kling.
+
+ DOMTimer currently uses a mix of millisecond (was int, now std::chrono) and second (as double)
+ time values. Constant conversion back and forth is a complete mess. Stop that.
+
+ * dom/Document.cpp:
+ (WebCore::Document::minimumTimerInterval):
+ (WebCore::Document::timerAlignmentInterval):
+ * dom/Document.h:
+ - double -> std::chrono::milliseconds
+ * dom/ScriptExecutionContext.cpp:
+ (WebCore::ScriptExecutionContext::adjustMinimumTimerInterval):
+ (WebCore::ScriptExecutionContext::minimumTimerInterval):
+ (WebCore::ScriptExecutionContext::timerAlignmentInterval):
+ * dom/ScriptExecutionContext.h:
+ - double -> std::chrono::milliseconds
+ * page/DOMTimer.cpp:
+ (WebCore::DOMTimer::updateTimerIntervalIfNecessary):
+ (WebCore::DOMTimer::intervalClampedToMinimum):
+ (WebCore::DOMTimer::alignedFireTime):
+ * page/DOMTimer.h:
+ - double -> std::chrono::milliseconds
+ * page/Page.cpp:
+ (WebCore::Page::setTimerThrottlingState):
+ (WebCore::Page::setTimerAlignmentIntervalIncreaseLimit):
+ (WebCore::Page::updateDOMTimerAlignmentInterval):
+ * page/Page.h:
+ - double -> std::chrono::milliseconds
+ * page/Settings.cpp:
+ (WebCore::Settings::setNeedsAdobeFrameReloadingQuirk):
+ (WebCore::Settings::setMinimumDOMTimerInterval):
+ * page/Settings.h:
+ - double -> std::chrono::milliseconds
+ * page/SuspendableTimer.h:
+ (WebCore::SuspendableTimer::startRepeating):
+ (WebCore::SuspendableTimer::startOneShot):
+ (WebCore::SuspendableTimer::repeatIntervalMS):
+ (WebCore::SuspendableTimer::augmentFireInterval):
+ (WebCore::SuspendableTimer::augmentRepeatInterval):
+ - added std::chrono::milliseconds interface.
+ * platform/Timer.cpp:
+ (WebCore::TimerBase::setNextFireTime):
+ - restructured for new alignedFireTime signatured, moved zero-delay handling to here.
+ This change made because inside alignedFireTime fireTime will have already been truncated.
+ * platform/Timer.h:
+ (WebCore::TimerBase::msToSeconds):
+ (WebCore::TimerBase::secondsToMS):
+ - internal helper functions to bridge std::chrono::milliseconds to internal double.
+ (WebCore::TimerBase::startRepeating):
+ (WebCore::TimerBase::startOneShot):
+ (WebCore::TimerBase::repeatIntervalMS):
+ (WebCore::TimerBase::augmentFireInterval):
+ (WebCore::TimerBase::augmentRepeatInterval):
+ - expanded std::chrono::milliseconds interface.
+ (WebCore::TimerBase::alignedFireTime):
+ - changed to std::chrono::milliseconds, made return value Optional (null means no alignment).
+ * testing/InternalSettings.cpp:
+ (WebCore::InternalSettings::setMinimumTimerInterval):
+ * testing/InternalSettings.h:
+ - double -> std::chrono::milliseconds
+
</ins><span class="cx"> 2016-03-07 Andreas Kling <akling@apple.com>
</span><span class="cx">
</span><span class="cx"> Make RenderStyle copy-on-write a bit less.
</span></span></pre></div>
<a id="trunkSourceWebCoredomDocumentcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Document.cpp (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Document.cpp 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/dom/Document.cpp 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -2915,7 +2915,7 @@
</span><span class="cx"> write("\n", ownerDocument);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-double Document::minimumTimerInterval() const
</del><ins>+std::chrono::milliseconds Document::minimumTimerInterval() const
</ins><span class="cx"> {
</span><span class="cx"> auto* page = this->page();
</span><span class="cx"> if (!page)
</span><span class="lines">@@ -2932,9 +2932,9 @@
</span><span class="cx"> didChangeTimerAlignmentInterval();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-double Document::timerAlignmentInterval(bool hasReachedMaxNestingLevel) const
</del><ins>+std::chrono::milliseconds Document::timerAlignmentInterval(bool hasReachedMaxNestingLevel) const
</ins><span class="cx"> {
</span><del>- double alignmentInterval = ScriptExecutionContext::timerAlignmentInterval(hasReachedMaxNestingLevel);
</del><ins>+ auto alignmentInterval = ScriptExecutionContext::timerAlignmentInterval(hasReachedMaxNestingLevel);
</ins><span class="cx">
</span><span class="cx"> // Apply Document-level DOMTimer throttling only if timers have reached their maximum nesting level as the Page may still be visible.
</span><span class="cx"> if (m_isTimerThrottlingEnabled && hasReachedMaxNestingLevel)
</span></span></pre></div>
<a id="trunkSourceWebCoredomDocumenth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Document.h (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Document.h 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/dom/Document.h 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -1355,9 +1355,9 @@
</span><span class="cx">
</span><span class="cx"> void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<Inspector::ScriptCallStack>&&, JSC::ExecState* = nullptr, unsigned long requestIdentifier = 0) final;
</span><span class="cx">
</span><del>- double minimumTimerInterval() const final;
</del><ins>+ std::chrono::milliseconds minimumTimerInterval() const final;
</ins><span class="cx">
</span><del>- double timerAlignmentInterval(bool hasReachedMaxNestingLevel) const final;
</del><ins>+ std::chrono::milliseconds timerAlignmentInterval(bool hasReachedMaxNestingLevel) const final;
</ins><span class="cx">
</span><span class="cx"> void updateTitleFromTitleElement();
</span><span class="cx"> void updateTitle(const StringWithDirection&);
</span></span></pre></div>
<a id="trunkSourceWebCoredomScriptExecutionContextcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/ScriptExecutionContext.cpp (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/ScriptExecutionContext.cpp 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/dom/ScriptExecutionContext.cpp 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -426,7 +426,7 @@
</span><span class="cx"> return *m_publicURLManager;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void ScriptExecutionContext::adjustMinimumTimerInterval(double oldMinimumTimerInterval)
</del><ins>+void ScriptExecutionContext::adjustMinimumTimerInterval(std::chrono::milliseconds oldMinimumTimerInterval)
</ins><span class="cx"> {
</span><span class="cx"> if (minimumTimerInterval() != oldMinimumTimerInterval) {
</span><span class="cx"> for (auto& timer : m_timeouts.values())
</span><span class="lines">@@ -434,7 +434,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-double ScriptExecutionContext::minimumTimerInterval() const
</del><ins>+std::chrono::milliseconds ScriptExecutionContext::minimumTimerInterval() const
</ins><span class="cx"> {
</span><span class="cx"> // The default implementation returns the DOMTimer's default
</span><span class="cx"> // minimum timer interval. FIXME: to make it work with dedicated
</span><span class="lines">@@ -450,7 +450,7 @@
</span><span class="cx"> timer->didChangeAlignmentInterval();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-double ScriptExecutionContext::timerAlignmentInterval(bool) const
</del><ins>+std::chrono::milliseconds ScriptExecutionContext::timerAlignmentInterval(bool) const
</ins><span class="cx"> {
</span><span class="cx"> return DOMTimer::defaultAlignmentInterval();
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCoredomScriptExecutionContexth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/ScriptExecutionContext.h (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/ScriptExecutionContext.h 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/dom/ScriptExecutionContext.h 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -170,11 +170,11 @@
</span><span class="cx"> WEBCORE_EXPORT JSC::VM& vm();
</span><span class="cx">
</span><span class="cx"> // Interval is in seconds.
</span><del>- void adjustMinimumTimerInterval(double oldMinimumTimerInterval);
- virtual double minimumTimerInterval() const;
</del><ins>+ void adjustMinimumTimerInterval(std::chrono::milliseconds oldMinimumTimerInterval);
+ virtual std::chrono::milliseconds minimumTimerInterval() const;
</ins><span class="cx">
</span><span class="cx"> void didChangeTimerAlignmentInterval();
</span><del>- virtual double timerAlignmentInterval(bool hasReachedMaxNestingLevel) const;
</del><ins>+ virtual std::chrono::milliseconds timerAlignmentInterval(bool hasReachedMaxNestingLevel) const;
</ins><span class="cx">
</span><span class="cx"> virtual EventQueue& eventQueue() const = 0;
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorepageDOMTimercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/DOMTimer.cpp (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/DOMTimer.cpp 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/page/DOMTimer.cpp 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -53,9 +53,8 @@
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><span class="cx"> static const std::chrono::milliseconds maxIntervalForUserGestureForwarding = std::chrono::milliseconds(1000); // One second matches Gecko.
</span><del>-static const int minIntervalForNonUserObservableChangeTimers = 1000; // Empirically determined to maximize battery life.
</del><ins>+static const std::chrono::milliseconds minIntervalForNonUserObservableChangeTimers = std::chrono::milliseconds(1000); // Empirically determined to maximize battery life.
</ins><span class="cx"> static const int maxTimerNestingLevel = 5;
</span><del>-static const double oneMillisecond = 0.001;
</del><span class="cx">
</span><span class="cx"> class DOMTimerFireState {
</span><span class="cx"> public:
</span><span class="lines">@@ -387,53 +386,52 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(m_nestingLevel <= maxTimerNestingLevel);
</span><span class="cx">
</span><del>- double previousInterval = m_currentTimerInterval;
</del><ins>+ auto previousInterval = m_currentTimerInterval;
</ins><span class="cx"> m_currentTimerInterval = intervalClampedToMinimum();
</span><del>-
- if (WTF::areEssentiallyEqual(previousInterval, m_currentTimerInterval, oneMillisecond))
</del><ins>+ if (previousInterval == m_currentTimerInterval)
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> if (repeatInterval()) {
</span><del>- ASSERT(WTF::areEssentiallyEqual(repeatInterval(), previousInterval, oneMillisecond));
- LOG(DOMTimers, "%p - Updating DOMTimer's repeat interval from %g ms to %g ms due to throttling.", this, previousInterval * 1000., m_currentTimerInterval * 1000.);
</del><ins>+ ASSERT(repeatIntervalMS() == previousInterval);
+ LOG(DOMTimers, "%p - Updating DOMTimer's repeat interval from %lld ms to %lld ms due to throttling.", this, previousInterval.count(), m_currentTimerInterval.count());
</ins><span class="cx"> augmentRepeatInterval(m_currentTimerInterval - previousInterval);
</span><span class="cx"> } else {
</span><del>- LOG(DOMTimers, "%p - Updating DOMTimer's fire interval from %g ms to %g ms due to throttling.", this, previousInterval * 1000., m_currentTimerInterval * 1000.);
</del><ins>+ LOG(DOMTimers, "%p - Updating DOMTimer's fire interval from %lld ms to %lld ms due to throttling.", this, previousInterval.count(), m_currentTimerInterval.count());
</ins><span class="cx"> augmentFireInterval(m_currentTimerInterval - previousInterval);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-double DOMTimer::intervalClampedToMinimum() const
</del><ins>+std::chrono::milliseconds DOMTimer::intervalClampedToMinimum() const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(scriptExecutionContext());
</span><span class="cx"> ASSERT(m_nestingLevel <= maxTimerNestingLevel);
</span><span class="cx">
</span><del>- double intervalInSeconds = std::max(oneMillisecond, m_originalInterval.count() * oneMillisecond);
</del><ins>+ auto interval = std::max(std::chrono::milliseconds(1), m_originalInterval);
</ins><span class="cx">
</span><span class="cx"> // Only apply throttling to repeating timers.
</span><span class="cx"> if (m_nestingLevel < maxTimerNestingLevel)
</span><del>- return intervalInSeconds;
</del><ins>+ return interval;
</ins><span class="cx">
</span><span class="cx"> // Apply two throttles - the global (per Page) minimum, and also a per-timer throttle.
</span><del>- intervalInSeconds = std::max(intervalInSeconds, scriptExecutionContext()->minimumTimerInterval());
</del><ins>+ interval = std::max(interval, scriptExecutionContext()->minimumTimerInterval());
</ins><span class="cx"> if (m_throttleState == ShouldThrottle)
</span><del>- intervalInSeconds = std::max(intervalInSeconds, minIntervalForNonUserObservableChangeTimers * oneMillisecond);
- return intervalInSeconds;
</del><ins>+ interval = std::max(interval, minIntervalForNonUserObservableChangeTimers);
+ return interval;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-double DOMTimer::alignedFireTime(double fireTime) const
</del><ins>+Optional<std::chrono::milliseconds> DOMTimer::alignedFireTime(std::chrono::milliseconds fireTime) const
</ins><span class="cx"> {
</span><del>- if (double alignmentInterval = scriptExecutionContext()->timerAlignmentInterval(m_nestingLevel >= maxTimerNestingLevel)) {
- // Don't mess with zero-delay timers.
- if (!fireTime)
- return fireTime;
- static const double randomizedAlignment = randomNumber();
- // Force alignment to randomizedAlignment fraction of the way between alignemntIntervals, e.g.
- // if alignmentInterval is 10 and randomizedAlignment is 0.3 this will align to 3, 13, 23, ...
- return (ceil(fireTime / alignmentInterval - randomizedAlignment) + randomizedAlignment) * alignmentInterval;
- }
</del><ins>+ auto alignmentInterval = scriptExecutionContext()->timerAlignmentInterval(m_nestingLevel >= maxTimerNestingLevel);
+ if (alignmentInterval == std::chrono::milliseconds::zero())
+ return Nullopt;
+
+ static const double randomizedProportion = randomNumber();
</ins><span class="cx">
</span><del>- return fireTime;
</del><ins>+ // Force alignment to randomizedAlignment fraction of the way between alignemntIntervals, e.g.
+ // if alignmentInterval is 10 and randomizedAlignment is 0.3 this will align to 3, 13, 23, ...
+ auto randomizedOffset = std::chrono::duration_cast<std::chrono::milliseconds>(alignmentInterval * randomizedProportion);
+ auto adjustedFireTime = fireTime - randomizedOffset;
+ return adjustedFireTime - (adjustedFireTime % alignmentInterval) + alignmentInterval + randomizedOffset;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> const char* DOMTimer::activeDOMObjectName() const
</span></span></pre></div>
<a id="trunkSourceWebCorepageDOMTimerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/DOMTimer.h (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/DOMTimer.h 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/page/DOMTimer.h 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -46,9 +46,9 @@
</span><span class="cx"> public:
</span><span class="cx"> virtual ~DOMTimer();
</span><span class="cx">
</span><del>- static double defaultMinimumInterval() { return 0.004; } // 4 milliseconds.
- static double defaultAlignmentInterval() { return 0; }
- static double hiddenPageAlignmentInterval() { return 1.0; } // 1 second.
</del><ins>+ static std::chrono::milliseconds defaultMinimumInterval() { return std::chrono::milliseconds(4); }
+ static std::chrono::milliseconds defaultAlignmentInterval() { return std::chrono::milliseconds::zero(); }
+ static std::chrono::milliseconds hiddenPageAlignmentInterval() { return std::chrono::milliseconds(1000); }
</ins><span class="cx">
</span><span class="cx"> // Creates a new timer owned by specified ScriptExecutionContext, starts it
</span><span class="cx"> // and returns its Id.
</span><span class="lines">@@ -65,7 +65,7 @@
</span><span class="cx"> DOMTimer(ScriptExecutionContext&, std::unique_ptr<ScheduledAction>, std::chrono::milliseconds interval, bool singleShot);
</span><span class="cx"> friend class Internals;
</span><span class="cx">
</span><del>- double intervalClampedToMinimum() const;
</del><ins>+ std::chrono::milliseconds intervalClampedToMinimum() const;
</ins><span class="cx">
</span><span class="cx"> bool isDOMTimersThrottlingEnabled(Document&) const;
</span><span class="cx"> void updateThrottlingStateIfNecessary(const DOMTimerFireState&);
</span><span class="lines">@@ -73,7 +73,7 @@
</span><span class="cx"> // SuspendableTimer
</span><span class="cx"> void fired() override;
</span><span class="cx"> void didStop() override;
</span><del>- double alignedFireTime(double) const override;
</del><ins>+ Optional<std::chrono::milliseconds> alignedFireTime(std::chrono::milliseconds) const override;
</ins><span class="cx">
</span><span class="cx"> // ActiveDOMObject API.
</span><span class="cx"> const char* activeDOMObjectName() const override;
</span><span class="lines">@@ -89,7 +89,7 @@
</span><span class="cx"> std::unique_ptr<ScheduledAction> m_action;
</span><span class="cx"> std::chrono::milliseconds m_originalInterval;
</span><span class="cx"> TimerThrottleState m_throttleState;
</span><del>- double m_currentTimerInterval;
</del><ins>+ std::chrono::milliseconds m_currentTimerInterval;
</ins><span class="cx"> bool m_shouldForwardUserGesture;
</span><span class="cx"> };
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorepagePagecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/Page.cpp (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/Page.cpp 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/page/Page.cpp 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -1206,7 +1206,7 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> m_timerThrottlingState = state;
</span><del>- m_timerThrottlingStateLastChangedTime = monotonicallyIncreasingTime();
</del><ins>+ m_timerThrottlingStateLastChangedTime = std::chrono::steady_clock::now();
</ins><span class="cx">
</span><span class="cx"> updateDOMTimerAlignmentInterval();
</span><span class="cx">
</span><span class="lines">@@ -1221,8 +1221,7 @@
</span><span class="cx">
</span><span class="cx"> void Page::setTimerAlignmentIntervalIncreaseLimit(std::chrono::milliseconds limit)
</span><span class="cx"> {
</span><del>- // FIXME: std::chrono-ify all timer allignment related code.
- m_timerAlignmentIntervalIncreaseLimit = limit.count() * 0.001;
</del><ins>+ m_timerAlignmentIntervalIncreaseLimit = limit;
</ins><span class="cx">
</span><span class="cx"> // If (m_timerAlignmentIntervalIncreaseLimit < m_timerAlignmentInterval) then we need
</span><span class="cx"> // to update m_timerAlignmentInterval, if greater then need to restart the increase timer.
</span><span class="lines">@@ -1248,8 +1247,8 @@
</span><span class="cx"> if (m_isPrerender)
</span><span class="cx"> m_timerAlignmentInterval = m_timerAlignmentIntervalIncreaseLimit;
</span><span class="cx"> else {
</span><del>- ASSERT(m_timerThrottlingStateLastChangedTime);
- m_timerAlignmentInterval = monotonicallyIncreasingTime() - m_timerThrottlingStateLastChangedTime;
</del><ins>+ ASSERT(m_timerThrottlingStateLastChangedTime.time_since_epoch() != std::chrono::steady_clock::duration::zero());
+ m_timerAlignmentInterval = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - m_timerThrottlingStateLastChangedTime);
</ins><span class="cx"> // If we're below the limit, set the timer. If above, clamp to limit.
</span><span class="cx"> if (m_timerAlignmentInterval < m_timerAlignmentIntervalIncreaseLimit)
</span><span class="cx"> needsIncreaseTimer = true;
</span></span></pre></div>
<a id="trunkSourceWebCorepagePageh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/Page.h (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/Page.h 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/page/Page.h 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -219,7 +219,7 @@
</span><span class="cx"> ProgressTracker& progress() const { return *m_progress; }
</span><span class="cx"> BackForwardController& backForward() const { return *m_backForwardController; }
</span><span class="cx">
</span><del>- double domTimerAlignmentInterval() const { return m_timerAlignmentInterval; }
</del><ins>+ std::chrono::milliseconds domTimerAlignmentInterval() const { return m_timerAlignmentInterval; }
</ins><span class="cx">
</span><span class="cx"> #if ENABLE(VIEW_MODE_CSS_MEDIA)
</span><span class="cx"> enum ViewMode {
</span><span class="lines">@@ -621,10 +621,10 @@
</span><span class="cx"> #endif // ENABLE(VIEW_MODE_CSS_MEDIA)
</span><span class="cx">
</span><span class="cx"> TimerThrottlingState m_timerThrottlingState { TimerThrottlingState::Disabled };
</span><del>- double m_timerThrottlingStateLastChangedTime { 0 };
- double m_timerAlignmentInterval;
</del><ins>+ std::chrono::steady_clock::time_point m_timerThrottlingStateLastChangedTime { std::chrono::steady_clock::duration::zero() };
+ std::chrono::milliseconds m_timerAlignmentInterval;
</ins><span class="cx"> Timer m_timerAlignmentIntervalIncreaseTimer;
</span><del>- double m_timerAlignmentIntervalIncreaseLimit { 0 };
</del><ins>+ std::chrono::milliseconds m_timerAlignmentIntervalIncreaseLimit { 0 };
</ins><span class="cx">
</span><span class="cx"> bool m_isEditable;
</span><span class="cx"> bool m_isPrerender;
</span></span></pre></div>
<a id="trunkSourceWebCorepageSettingscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/Settings.cpp (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/Settings.cpp 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/page/Settings.cpp 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -464,9 +464,9 @@
</span><span class="cx"> m_needsAdobeFrameReloadingQuirk = shouldNotReloadIFramesForUnchangedSRC;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void Settings::setMinimumDOMTimerInterval(double interval)
</del><ins>+void Settings::setMinimumDOMTimerInterval(std::chrono::milliseconds interval)
</ins><span class="cx"> {
</span><del>- double oldTimerInterval = m_minimumDOMTimerInterval;
</del><ins>+ auto oldTimerInterval = m_minimumDOMTimerInterval;
</ins><span class="cx"> m_minimumDOMTimerInterval = interval;
</span><span class="cx">
</span><span class="cx"> if (!m_page)
</span></span></pre></div>
<a id="trunkSourceWebCorepageSettingsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/Settings.h (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/Settings.h 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/page/Settings.h 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -152,8 +152,8 @@
</span><span class="cx"> WEBCORE_EXPORT void setNeedsAdobeFrameReloadingQuirk(bool);
</span><span class="cx"> bool needsAcrobatFrameReloadingQuirk() const { return m_needsAdobeFrameReloadingQuirk; }
</span><span class="cx">
</span><del>- WEBCORE_EXPORT void setMinimumDOMTimerInterval(double); // Initialized to DOMTimer::defaultMinimumInterval().
- double minimumDOMTimerInterval() const { return m_minimumDOMTimerInterval; }
</del><ins>+ WEBCORE_EXPORT void setMinimumDOMTimerInterval(std::chrono::milliseconds); // Initialized to DOMTimer::defaultMinimumInterval().
+ std::chrono::milliseconds minimumDOMTimerInterval() const { return m_minimumDOMTimerInterval; }
</ins><span class="cx">
</span><span class="cx"> WEBCORE_EXPORT void setLayoutInterval(std::chrono::milliseconds);
</span><span class="cx"> std::chrono::milliseconds layoutInterval() const { return m_layoutInterval; }
</span><span class="lines">@@ -303,7 +303,7 @@
</span><span class="cx"> const std::unique_ptr<FontGenericFamilies> m_fontGenericFamilies;
</span><span class="cx"> SecurityOrigin::StorageBlockingPolicy m_storageBlockingPolicy;
</span><span class="cx"> std::chrono::milliseconds m_layoutInterval;
</span><del>- double m_minimumDOMTimerInterval;
</del><ins>+ std::chrono::milliseconds m_minimumDOMTimerInterval;
</ins><span class="cx">
</span><span class="cx"> #if ENABLE(TEXT_AUTOSIZING)
</span><span class="cx"> float m_textAutosizingFontScaleFactor;
</span></span></pre></div>
<a id="trunkSourceWebCorepageSuspendableTimerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/SuspendableTimer.h (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/SuspendableTimer.h 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/page/SuspendableTimer.h 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -43,11 +43,19 @@
</span><span class="cx"> // Part of TimerBase interface used by SuspendableTimer clients, modified to work when suspended.
</span><span class="cx"> bool isActive() const { return TimerBase::isActive() || (m_suspended && m_savedIsActive); }
</span><span class="cx"> bool isSuspended() const { return m_suspended; }
</span><ins>+
</ins><span class="cx"> void startRepeating(double repeatInterval);
</span><span class="cx"> void startOneShot(double interval);
</span><span class="cx"> double repeatInterval() const;
</span><span class="cx"> void augmentFireInterval(double delta);
</span><span class="cx"> void augmentRepeatInterval(double delta);
</span><ins>+
+ void startRepeating(std::chrono::milliseconds repeatInterval) { startRepeating(msToSeconds(repeatInterval)); }
+ void startOneShot(std::chrono::milliseconds interval) { startOneShot(msToSeconds(interval)); }
+ std::chrono::milliseconds repeatIntervalMS() const { return secondsToMS(repeatInterval()); }
+ void augmentFireInterval(std::chrono::milliseconds delta) { augmentFireInterval(msToSeconds(delta)); }
+ void augmentRepeatInterval(std::chrono::milliseconds delta) { augmentRepeatInterval(msToSeconds(delta)); }
+
</ins><span class="cx"> using TimerBase::didChangeAlignmentInterval;
</span><span class="cx"> using TimerBase::operator new;
</span><span class="cx"> using TimerBase::operator delete;
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformTimercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/Timer.cpp (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/Timer.cpp 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/platform/Timer.cpp 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -367,13 +367,13 @@
</span><span class="cx"> ASSERT(!inHeap() || hasValidHeapPosition());
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void TimerBase::setNextFireTime(double newUnalignedTime)
</del><ins>+void TimerBase::setNextFireTime(double newTime)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(canAccessThreadLocalDataForThread(m_thread));
</span><span class="cx"> ASSERT(!m_wasDeleted);
</span><span class="cx">
</span><del>- if (m_unalignedNextFireTime != newUnalignedTime)
- m_unalignedNextFireTime = newUnalignedTime;
</del><ins>+ if (m_unalignedNextFireTime != newTime)
+ m_unalignedNextFireTime = newTime;
</ins><span class="cx">
</span><span class="cx"> // Accessing thread global data is slow. Cache the heap pointer.
</span><span class="cx"> if (!m_cachedThreadGlobalTimerHeap)
</span><span class="lines">@@ -381,7 +381,12 @@
</span><span class="cx">
</span><span class="cx"> // Keep heap valid while changing the next-fire time.
</span><span class="cx"> double oldTime = m_nextFireTime;
</span><del>- double newTime = alignedFireTime(newUnalignedTime);
</del><ins>+ // Don't realign zero-delay timers.
+ if (newTime) {
+ if (auto newAlignedTime = alignedFireTime(secondsToMS(newTime)))
+ newTime = msToSeconds(newAlignedTime.value());
+ }
+
</ins><span class="cx"> if (oldTime != newTime) {
</span><span class="cx"> m_nextFireTime = newTime;
</span><span class="cx"> // FIXME: This should be part of ThreadTimers, or another per-thread structure.
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformTimerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/Timer.h (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/Timer.h 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/platform/Timer.h 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -29,6 +29,7 @@
</span><span class="cx"> #include <chrono>
</span><span class="cx"> #include <functional>
</span><span class="cx"> #include <wtf/Noncopyable.h>
</span><ins>+#include <wtf/Optional.h>
</ins><span class="cx"> #include <wtf/Threading.h>
</span><span class="cx"> #include <wtf/Vector.h>
</span><span class="cx">
</span><span class="lines">@@ -45,6 +46,10 @@
</span><span class="cx"> class TimerBase {
</span><span class="cx"> WTF_MAKE_NONCOPYABLE(TimerBase);
</span><span class="cx"> WTF_MAKE_FAST_ALLOCATED;
</span><ins>+protected:
+ static inline double msToSeconds(std::chrono::milliseconds duration) { return duration.count() * 0.001; }
+ static inline std::chrono::milliseconds secondsToMS(double duration) { return std::chrono::milliseconds((std::chrono::milliseconds::rep)(duration * 1000)); }
+
</ins><span class="cx"> public:
</span><span class="cx"> WEBCORE_EXPORT TimerBase();
</span><span class="cx"> WEBCORE_EXPORT virtual ~TimerBase();
</span><span class="lines">@@ -52,9 +57,9 @@
</span><span class="cx"> WEBCORE_EXPORT void start(double nextFireInterval, double repeatInterval);
</span><span class="cx">
</span><span class="cx"> void startRepeating(double repeatInterval) { start(repeatInterval, repeatInterval); }
</span><del>- void startRepeating(std::chrono::milliseconds repeatInterval) { startRepeating(repeatInterval.count() * 0.001); }
</del><ins>+ void startRepeating(std::chrono::milliseconds repeatInterval) { startRepeating(msToSeconds(repeatInterval)); }
</ins><span class="cx"> void startOneShot(double interval) { start(interval, 0); }
</span><del>- void startOneShot(std::chrono::milliseconds interval) { startOneShot(interval.count() * 0.001); }
</del><ins>+ void startOneShot(std::chrono::milliseconds interval) { startOneShot(msToSeconds(interval)); }
</ins><span class="cx">
</span><span class="cx"> WEBCORE_EXPORT void stop();
</span><span class="cx"> bool isActive() const;
</span><span class="lines">@@ -62,9 +67,12 @@
</span><span class="cx"> double nextFireInterval() const;
</span><span class="cx"> double nextUnalignedFireInterval() const;
</span><span class="cx"> double repeatInterval() const { return m_repeatInterval; }
</span><ins>+ std::chrono::milliseconds repeatIntervalMS() const { return secondsToMS(repeatInterval()); }
</ins><span class="cx">
</span><span class="cx"> void augmentFireInterval(double delta) { setNextFireTime(m_nextFireTime + delta); }
</span><ins>+ void augmentFireInterval(std::chrono::milliseconds delta) { augmentFireInterval(msToSeconds(delta)); }
</ins><span class="cx"> void augmentRepeatInterval(double delta) { augmentFireInterval(delta); m_repeatInterval += delta; }
</span><ins>+ void augmentRepeatInterval(std::chrono::milliseconds delta) { augmentRepeatInterval(msToSeconds(delta)); }
</ins><span class="cx">
</span><span class="cx"> void didChangeAlignmentInterval();
</span><span class="cx">
</span><span class="lines">@@ -73,7 +81,7 @@
</span><span class="cx"> private:
</span><span class="cx"> virtual void fired() = 0;
</span><span class="cx">
</span><del>- virtual double alignedFireTime(double fireTime) const { return fireTime; }
</del><ins>+ virtual Optional<std::chrono::milliseconds> alignedFireTime(std::chrono::milliseconds) const { return Nullopt; }
</ins><span class="cx">
</span><span class="cx"> void checkConsistency() const;
</span><span class="cx"> void checkHeapIndex() const;
</span></span></pre></div>
<a id="trunkSourceWebCoretestingInternalSettingscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/testing/InternalSettings.cpp (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/testing/InternalSettings.cpp 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/testing/InternalSettings.cpp 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -466,7 +466,7 @@
</span><span class="cx"> void InternalSettings::setMinimumTimerInterval(double intervalInSeconds, ExceptionCode& ec)
</span><span class="cx"> {
</span><span class="cx"> InternalSettingsGuardForSettings();
</span><del>- settings()->setMinimumDOMTimerInterval(intervalInSeconds);
</del><ins>+ settings()->setMinimumDOMTimerInterval(std::chrono::milliseconds((std::chrono::milliseconds::rep)(intervalInSeconds * 1000)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void InternalSettings::setDefaultVideoPosterURL(const String& url, ExceptionCode& ec)
</span></span></pre></div>
<a id="trunkSourceWebCoretestingInternalSettingsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/testing/InternalSettings.h (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/testing/InternalSettings.h 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebCore/testing/InternalSettings.h 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -75,7 +75,7 @@
</span><span class="cx"> bool m_originalUsesOverlayScrollbars;
</span><span class="cx"> bool m_langAttributeAwareFormControlUIEnabled;
</span><span class="cx"> bool m_imagesEnabled;
</span><del>- double m_minimumTimerInterval;
</del><ins>+ std::chrono::milliseconds m_minimumTimerInterval;
</ins><span class="cx"> #if ENABLE(VIDEO_TRACK)
</span><span class="cx"> bool m_shouldDisplaySubtitles;
</span><span class="cx"> bool m_shouldDisplayCaptions;
</span></span></pre></div>
<a id="trunkSourceWebKitwinChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/win/ChangeLog (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/win/ChangeLog 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebKit/win/ChangeLog 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -1,3 +1,17 @@
</span><ins>+2016-03-06 Gavin Barraclough <barraclough@apple.com>
+
+ Convert DOMTimer to std::chrono::milliseconds
+ https://bugs.webkit.org/show_bug.cgi?id=155085
+
+ Reviewed by Andreas Kling.
+
+ DOMTimer currently uses a mix of millisecond (was int, now std::chrono) and second (as double)
+ time values. Constant conversion back and forth is a complete mess. Stop that.
+
+ * WebView.cpp:
+ (WebView::setMinimumTimerInterval):
+ - Convert double argument into std::chrono::milliseconds.
+
</ins><span class="cx"> 2016-03-05 Yusuke Suzuki <utatane.tea@gmail.com>
</span><span class="cx">
</span><span class="cx"> [ES6] Support Reflect.construct
</span></span></pre></div>
<a id="trunkSourceWebKitwinWebViewcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/win/WebView.cpp (197689 => 197690)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/win/WebView.cpp 2016-03-07 18:41:30 UTC (rev 197689)
+++ trunk/Source/WebKit/win/WebView.cpp 2016-03-07 18:41:56 UTC (rev 197690)
</span><span class="lines">@@ -7220,7 +7220,7 @@
</span><span class="cx"> {
</span><span class="cx"> if (!interval)
</span><span class="cx"> return E_POINTER;
</span><del>- *interval = DOMTimer::defaultMinimumInterval();
</del><ins>+ *interval = DOMTimer::defaultMinimumInterval().count() / 1000.;
</ins><span class="cx"> return S_OK;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -7229,7 +7229,8 @@
</span><span class="cx"> if (!m_page)
</span><span class="cx"> return E_FAIL;
</span><span class="cx">
</span><del>- page()->settings().setMinimumDOMTimerInterval(interval);
</del><ins>+ auto intervalMS = std::chrono::milliseconds((std::chrono::milliseconds::rep)(interval * 1000));
+ page()->settings().setMinimumDOMTimerInterval(intervalMS);
</ins><span class="cx"> return S_OK;
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre>
</div>
</div>
</body>
</html>