⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 197690 in webkit


Ignore:
Timestamp:
Mar 7, 2016, 10:41:56 AM (11 years ago)
Author:
barraclough@apple.com
Message:

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.
Location:
trunk/Source
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r197680 r197690  
     12016-03-06  Gavin Barraclough  <barraclough@apple.com>
     2
     3        Convert DOMTimer to std::chrono::milliseconds
     4        https://bugs.webkit.org/show_bug.cgi?id=155085
     5
     6        Reviewed by Andreas Kling.
     7
     8        DOMTimer currently uses a mix of millisecond (was int, now std::chrono) and second (as double)
     9        time values. Constant conversion back and forth is a complete mess. Stop that.
     10
     11        * dom/Document.cpp:
     12        (WebCore::Document::minimumTimerInterval):
     13        (WebCore::Document::timerAlignmentInterval):
     14        * dom/Document.h:
     15            - double -> std::chrono::milliseconds
     16        * dom/ScriptExecutionContext.cpp:
     17        (WebCore::ScriptExecutionContext::adjustMinimumTimerInterval):
     18        (WebCore::ScriptExecutionContext::minimumTimerInterval):
     19        (WebCore::ScriptExecutionContext::timerAlignmentInterval):
     20        * dom/ScriptExecutionContext.h:
     21            - double -> std::chrono::milliseconds
     22        * page/DOMTimer.cpp:
     23        (WebCore::DOMTimer::updateTimerIntervalIfNecessary):
     24        (WebCore::DOMTimer::intervalClampedToMinimum):
     25        (WebCore::DOMTimer::alignedFireTime):
     26        * page/DOMTimer.h:
     27            - double -> std::chrono::milliseconds
     28        * page/Page.cpp:
     29        (WebCore::Page::setTimerThrottlingState):
     30        (WebCore::Page::setTimerAlignmentIntervalIncreaseLimit):
     31        (WebCore::Page::updateDOMTimerAlignmentInterval):
     32        * page/Page.h:
     33            - double -> std::chrono::milliseconds
     34        * page/Settings.cpp:
     35        (WebCore::Settings::setNeedsAdobeFrameReloadingQuirk):
     36        (WebCore::Settings::setMinimumDOMTimerInterval):
     37        * page/Settings.h:
     38            - double -> std::chrono::milliseconds
     39        * page/SuspendableTimer.h:
     40        (WebCore::SuspendableTimer::startRepeating):
     41        (WebCore::SuspendableTimer::startOneShot):
     42        (WebCore::SuspendableTimer::repeatIntervalMS):
     43        (WebCore::SuspendableTimer::augmentFireInterval):
     44        (WebCore::SuspendableTimer::augmentRepeatInterval):
     45            - added std::chrono::milliseconds interface.
     46        * platform/Timer.cpp:
     47        (WebCore::TimerBase::setNextFireTime):
     48            - restructured for new alignedFireTime signatured, moved zero-delay handling to here.
     49              This change made because inside alignedFireTime fireTime will have already been truncated.
     50        * platform/Timer.h:
     51        (WebCore::TimerBase::msToSeconds):
     52        (WebCore::TimerBase::secondsToMS):
     53            - internal helper functions to bridge std::chrono::milliseconds to internal double.
     54        (WebCore::TimerBase::startRepeating):
     55        (WebCore::TimerBase::startOneShot):
     56        (WebCore::TimerBase::repeatIntervalMS):
     57        (WebCore::TimerBase::augmentFireInterval):
     58        (WebCore::TimerBase::augmentRepeatInterval):
     59            - expanded std::chrono::milliseconds interface.
     60        (WebCore::TimerBase::alignedFireTime):
     61            - changed to std::chrono::milliseconds, made return value Optional (null means no alignment).
     62        * testing/InternalSettings.cpp:
     63        (WebCore::InternalSettings::setMinimumTimerInterval):
     64        * testing/InternalSettings.h:
     65            - double -> std::chrono::milliseconds
     66
    1672016-03-07  Andreas Kling  <akling@apple.com>
    268

  • trunk/Source/WebCore/dom/Document.cpp

    r197634 r197690  
    29162916}
    29172917
    2918 double Document::minimumTimerInterval() const
     2918std::chrono::milliseconds Document::minimumTimerInterval() const
    29192919{
    29202920    auto* page = this->page();
    … …  
    29332933}
    29342934
    2935 double Document::timerAlignmentInterval(bool hasReachedMaxNestingLevel) const
    2936 {
    2937     double alignmentInterval = ScriptExecutionContext::timerAlignmentInterval(hasReachedMaxNestingLevel);
     2935std::chrono::milliseconds Document::timerAlignmentInterval(bool hasReachedMaxNestingLevel) const
     2936{
     2937    auto alignmentInterval = ScriptExecutionContext::timerAlignmentInterval(hasReachedMaxNestingLevel);
    29382938
    29392939    // Apply Document-level DOMTimer throttling only if timers have reached their maximum nesting level as the Page may still be visible.

  • trunk/Source/WebCore/dom/Document.h

    r197566 r197690  
    13561356    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;
    13571357
    1358     double minimumTimerInterval() const final;
    1359 
    1360     double timerAlignmentInterval(bool hasReachedMaxNestingLevel) const final;
     1358    std::chrono::milliseconds minimumTimerInterval() const final;
     1359
     1360    std::chrono::milliseconds timerAlignmentInterval(bool hasReachedMaxNestingLevel) const final;
    13611361
    13621362    void updateTitleFromTitleElement();

  • trunk/Source/WebCore/dom/ScriptExecutionContext.cpp

    r196563 r197690  
    427427}
    428428
    429 void ScriptExecutionContext::adjustMinimumTimerInterval(double oldMinimumTimerInterval)
     429void ScriptExecutionContext::adjustMinimumTimerInterval(std::chrono::milliseconds oldMinimumTimerInterval)
    430430{
    431431    if (minimumTimerInterval() != oldMinimumTimerInterval) {
    … …  
    435435}
    436436
    437 double ScriptExecutionContext::minimumTimerInterval() const
     437std::chrono::milliseconds ScriptExecutionContext::minimumTimerInterval() const
    438438{
    439439    // The default implementation returns the DOMTimer's default
    … …  
    451451}
    452452
    453 double ScriptExecutionContext::timerAlignmentInterval(bool) const
     453std::chrono::milliseconds ScriptExecutionContext::timerAlignmentInterval(bool) const
    454454{
    455455    return DOMTimer::defaultAlignmentInterval();

  • trunk/Source/WebCore/dom/ScriptExecutionContext.h

    r196242 r197690  
    171171
    172172    // Interval is in seconds.
    173     void adjustMinimumTimerInterval(double oldMinimumTimerInterval);
    174     virtual double minimumTimerInterval() const;
     173    void adjustMinimumTimerInterval(std::chrono::milliseconds oldMinimumTimerInterval);
     174    virtual std::chrono::milliseconds minimumTimerInterval() const;
    175175
    176176    void didChangeTimerAlignmentInterval();
    177     virtual double timerAlignmentInterval(bool hasReachedMaxNestingLevel) const;
     177    virtual std::chrono::milliseconds timerAlignmentInterval(bool hasReachedMaxNestingLevel) const;
    178178
    179179    virtual EventQueue& eventQueue() const = 0;

  • trunk/Source/WebCore/page/DOMTimer.cpp

    r197603 r197690  
    5454
    5555static const std::chrono::milliseconds maxIntervalForUserGestureForwarding = std::chrono::milliseconds(1000); // One second matches Gecko.
    56 static const int minIntervalForNonUserObservableChangeTimers = 1000; // Empirically determined to maximize battery life.
     56static const std::chrono::milliseconds minIntervalForNonUserObservableChangeTimers = std::chrono::milliseconds(1000); // Empirically determined to maximize battery life.
    5757static const int maxTimerNestingLevel = 5;
    58 static const double oneMillisecond = 0.001;
    5958
    6059class DOMTimerFireState {
    … …  
    388387    ASSERT(m_nestingLevel <= maxTimerNestingLevel);
    389388
    390     double previousInterval = m_currentTimerInterval;
     389    auto previousInterval = m_currentTimerInterval;
    391390    m_currentTimerInterval = intervalClampedToMinimum();
    392 
    393     if (WTF::areEssentiallyEqual(previousInterval, m_currentTimerInterval, oneMillisecond))
     391    if (previousInterval == m_currentTimerInterval)
    394392        return;
    395393
    396394    if (repeatInterval()) {
    397         ASSERT(WTF::areEssentiallyEqual(repeatInterval(), previousInterval, oneMillisecond));
    398         LOG(DOMTimers, "%p - Updating DOMTimer's repeat interval from %g ms to %g ms due to throttling.", this, previousInterval * 1000., m_currentTimerInterval * 1000.);
     395        ASSERT(repeatIntervalMS() == previousInterval);
     396        LOG(DOMTimers, "%p - Updating DOMTimer's repeat interval from %lld ms to %lld ms due to throttling.", this, previousInterval.count(), m_currentTimerInterval.count());
    399397        augmentRepeatInterval(m_currentTimerInterval - previousInterval);
    400398    } else {
    401         LOG(DOMTimers, "%p - Updating DOMTimer's fire interval from %g ms to %g ms due to throttling.", this, previousInterval * 1000., m_currentTimerInterval * 1000.);
     399        LOG(DOMTimers, "%p - Updating DOMTimer's fire interval from %lld ms to %lld ms due to throttling.", this, previousInterval.count(), m_currentTimerInterval.count());
    402400        augmentFireInterval(m_currentTimerInterval - previousInterval);
    403401    }
    404402}
    405403
    406 double DOMTimer::intervalClampedToMinimum() const
     404std::chrono::milliseconds DOMTimer::intervalClampedToMinimum() const
    407405{
    408406    ASSERT(scriptExecutionContext());
    409407    ASSERT(m_nestingLevel <= maxTimerNestingLevel);
    410408
    411     double intervalInSeconds = std::max(oneMillisecond, m_originalInterval.count() * oneMillisecond);
     409    auto interval = std::max(std::chrono::milliseconds(1), m_originalInterval);
    412410
    413411    // Only apply throttling to repeating timers.
    414412    if (m_nestingLevel < maxTimerNestingLevel)
    415         return intervalInSeconds;
     413        return interval;
    416414
    417415    // Apply two throttles - the global (per Page) minimum, and also a per-timer throttle.
    418     intervalInSeconds = std::max(intervalInSeconds, scriptExecutionContext()->minimumTimerInterval());
     416    interval = std::max(interval, scriptExecutionContext()->minimumTimerInterval());
    419417    if (m_throttleState == ShouldThrottle)
    420         intervalInSeconds = std::max(intervalInSeconds, minIntervalForNonUserObservableChangeTimers * oneMillisecond);
    421     return intervalInSeconds;
    422 }
    423 
    424 double DOMTimer::alignedFireTime(double fireTime) const
    425 {
    426     if (double alignmentInterval = scriptExecutionContext()->timerAlignmentInterval(m_nestingLevel >= maxTimerNestingLevel)) {
    427         // Don't mess with zero-delay timers.
    428         if (!fireTime)
    429             return fireTime;
    430         static const double randomizedAlignment = randomNumber();
    431         // Force alignment to randomizedAlignment fraction of the way between alignemntIntervals, e.g.
    432         // if alignmentInterval is 10 and randomizedAlignment is 0.3 this will align to 3, 13, 23, ...
    433         return (ceil(fireTime / alignmentInterval - randomizedAlignment) + randomizedAlignment) * alignmentInterval;
    434     }
    435 
    436     return fireTime;
     418        interval = std::max(interval, minIntervalForNonUserObservableChangeTimers);
     419    return interval;
     420}
     421
     422Optional<std::chrono::milliseconds> DOMTimer::alignedFireTime(std::chrono::milliseconds fireTime) const
     423{
     424    auto alignmentInterval = scriptExecutionContext()->timerAlignmentInterval(m_nestingLevel >= maxTimerNestingLevel);
     425    if (alignmentInterval == std::chrono::milliseconds::zero())
     426        return Nullopt;
     427   
     428    static const double randomizedProportion = randomNumber();
     429
     430    // Force alignment to randomizedAlignment fraction of the way between alignemntIntervals, e.g.
     431    // if alignmentInterval is 10 and randomizedAlignment is 0.3 this will align to 3, 13, 23, ...
     432    auto randomizedOffset = std::chrono::duration_cast<std::chrono::milliseconds>(alignmentInterval * randomizedProportion);
     433    auto adjustedFireTime = fireTime - randomizedOffset;
     434    return adjustedFireTime - (adjustedFireTime % alignmentInterval) + alignmentInterval + randomizedOffset;
    437435}
    438436

  • trunk/Source/WebCore/page/DOMTimer.h

    r197599 r197690  
    4747    virtual ~DOMTimer();
    4848
    49     static double defaultMinimumInterval() { return 0.004; } // 4 milliseconds.
    50     static double defaultAlignmentInterval() { return 0; }
    51     static double hiddenPageAlignmentInterval() { return 1.0; } // 1 second.
     49    static std::chrono::milliseconds defaultMinimumInterval() { return std::chrono::milliseconds(4); }
     50    static std::chrono::milliseconds defaultAlignmentInterval() { return std::chrono::milliseconds::zero(); }
     51    static std::chrono::milliseconds hiddenPageAlignmentInterval() { return std::chrono::milliseconds(1000); }
    5252
    5353    // Creates a new timer owned by specified ScriptExecutionContext, starts it
    … …  
    6666    friend class Internals;
    6767
    68     double intervalClampedToMinimum() const;
     68    std::chrono::milliseconds intervalClampedToMinimum() const;
    6969
    7070    bool isDOMTimersThrottlingEnabled(Document&) const;
    … …  
    7474    void fired() override;
    7575    void didStop() override;
    76     double alignedFireTime(double) const override;
     76    Optional<std::chrono::milliseconds> alignedFireTime(std::chrono::milliseconds) const override;
    7777
    7878    // ActiveDOMObject API.
    … …  
    9090    std::chrono::milliseconds m_originalInterval;
    9191    TimerThrottleState m_throttleState;
    92     double m_currentTimerInterval;
     92    std::chrono::milliseconds m_currentTimerInterval;
    9393    bool m_shouldForwardUserGesture;
    9494};

  • trunk/Source/WebCore/page/Page.cpp

    r197588 r197690  
    12071207
    12081208    m_timerThrottlingState = state;
    1209     m_timerThrottlingStateLastChangedTime = monotonicallyIncreasingTime();
     1209    m_timerThrottlingStateLastChangedTime = std::chrono::steady_clock::now();
    12101210
    12111211    updateDOMTimerAlignmentInterval();
    … …  
    12221222void Page::setTimerAlignmentIntervalIncreaseLimit(std::chrono::milliseconds limit)
    12231223{
    1224     // FIXME: std::chrono-ify all timer allignment related code.
    1225     m_timerAlignmentIntervalIncreaseLimit = limit.count() * 0.001;
     1224    m_timerAlignmentIntervalIncreaseLimit = limit;
    12261225
    12271226    // If (m_timerAlignmentIntervalIncreaseLimit < m_timerAlignmentInterval) then we need
    … …  
    12491248            m_timerAlignmentInterval = m_timerAlignmentIntervalIncreaseLimit;
    12501249        else {
    1251             ASSERT(m_timerThrottlingStateLastChangedTime);
    1252             m_timerAlignmentInterval = monotonicallyIncreasingTime() - m_timerThrottlingStateLastChangedTime;
     1250            ASSERT(m_timerThrottlingStateLastChangedTime.time_since_epoch() != std::chrono::steady_clock::duration::zero());
     1251            m_timerAlignmentInterval = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - m_timerThrottlingStateLastChangedTime);
    12531252            // If we're below the limit, set the timer. If above, clamp to limit.
    12541253            if (m_timerAlignmentInterval < m_timerAlignmentIntervalIncreaseLimit)

  • trunk/Source/WebCore/page/Page.h

    r197581 r197690  
    220220    BackForwardController& backForward() const { return *m_backForwardController; }
    221221
    222     double domTimerAlignmentInterval() const { return m_timerAlignmentInterval; }
     222    std::chrono::milliseconds domTimerAlignmentInterval() const { return m_timerAlignmentInterval; }
    223223
    224224#if ENABLE(VIEW_MODE_CSS_MEDIA)
    … …  
    622622
    623623    TimerThrottlingState m_timerThrottlingState { TimerThrottlingState::Disabled };
    624     double m_timerThrottlingStateLastChangedTime { 0 };
    625     double m_timerAlignmentInterval;
     624    std::chrono::steady_clock::time_point m_timerThrottlingStateLastChangedTime { std::chrono::steady_clock::duration::zero() };
     625    std::chrono::milliseconds m_timerAlignmentInterval;
    626626    Timer m_timerAlignmentIntervalIncreaseTimer;
    627     double m_timerAlignmentIntervalIncreaseLimit { 0 };
     627    std::chrono::milliseconds m_timerAlignmentIntervalIncreaseLimit { 0 };
    628628
    629629    bool m_isEditable;

  • trunk/Source/WebCore/page/Settings.cpp

    r197518 r197690  
    465465}
    466466
    467 void Settings::setMinimumDOMTimerInterval(double interval)
    468 {
    469     double oldTimerInterval = m_minimumDOMTimerInterval;
     467void Settings::setMinimumDOMTimerInterval(std::chrono::milliseconds interval)
     468{
     469    auto oldTimerInterval = m_minimumDOMTimerInterval;
    470470    m_minimumDOMTimerInterval = interval;
    471471

  • trunk/Source/WebCore/page/Settings.h

    r197518 r197690  
    153153    bool needsAcrobatFrameReloadingQuirk() const { return m_needsAdobeFrameReloadingQuirk; }
    154154
    155     WEBCORE_EXPORT void setMinimumDOMTimerInterval(double); // Initialized to DOMTimer::defaultMinimumInterval().
    156     double minimumDOMTimerInterval() const { return m_minimumDOMTimerInterval; }
     155    WEBCORE_EXPORT void setMinimumDOMTimerInterval(std::chrono::milliseconds); // Initialized to DOMTimer::defaultMinimumInterval().
     156    std::chrono::milliseconds minimumDOMTimerInterval() const { return m_minimumDOMTimerInterval; }
    157157
    158158    WEBCORE_EXPORT void setLayoutInterval(std::chrono::milliseconds);
    … …  
    304304    SecurityOrigin::StorageBlockingPolicy m_storageBlockingPolicy;
    305305    std::chrono::milliseconds m_layoutInterval;
    306     double m_minimumDOMTimerInterval;
     306    std::chrono::milliseconds m_minimumDOMTimerInterval;
    307307
    308308#if ENABLE(TEXT_AUTOSIZING)

  • trunk/Source/WebCore/page/SuspendableTimer.h

    r197566 r197690  
    4444    bool isActive() const { return TimerBase::isActive() || (m_suspended && m_savedIsActive); }
    4545    bool isSuspended() const { return m_suspended; }
     46
    4647    void startRepeating(double repeatInterval);
    4748    void startOneShot(double interval);
    … …  
    4950    void augmentFireInterval(double delta);
    5051    void augmentRepeatInterval(double delta);
     52
     53    void startRepeating(std::chrono::milliseconds repeatInterval) { startRepeating(msToSeconds(repeatInterval)); }
     54    void startOneShot(std::chrono::milliseconds interval) { startOneShot(msToSeconds(interval)); }
     55    std::chrono::milliseconds repeatIntervalMS() const { return secondsToMS(repeatInterval()); }
     56    void augmentFireInterval(std::chrono::milliseconds delta) { augmentFireInterval(msToSeconds(delta)); }
     57    void augmentRepeatInterval(std::chrono::milliseconds delta) { augmentRepeatInterval(msToSeconds(delta)); }
     58
    5159    using TimerBase::didChangeAlignmentInterval;
    5260    using TimerBase::operator new;

  • trunk/Source/WebCore/platform/Timer.cpp

    r180058 r197690  
    368368}
    369369
    370 void TimerBase::setNextFireTime(double newUnalignedTime)
     370void TimerBase::setNextFireTime(double newTime)
    371371{
    372372    ASSERT(canAccessThreadLocalDataForThread(m_thread));
    373373    ASSERT(!m_wasDeleted);
    374374
    375     if (m_unalignedNextFireTime != newUnalignedTime)
    376         m_unalignedNextFireTime = newUnalignedTime;
     375    if (m_unalignedNextFireTime != newTime)
     376        m_unalignedNextFireTime = newTime;
    377377
    378378    // Accessing thread global data is slow. Cache the heap pointer.
    … …  
    382382    // Keep heap valid while changing the next-fire time.
    383383    double oldTime = m_nextFireTime;
    384     double newTime = alignedFireTime(newUnalignedTime);
     384    // Don't realign zero-delay timers.
     385    if (newTime) {
     386        if (auto newAlignedTime = alignedFireTime(secondsToMS(newTime)))
     387            newTime = msToSeconds(newAlignedTime.value());
     388    }
     389
    385390    if (oldTime != newTime) {
    386391        m_nextFireTime = newTime;

  • trunk/Source/WebCore/platform/Timer.h

    r197563 r197690  
    3030#include <functional>
    3131#include <wtf/Noncopyable.h>
     32#include <wtf/Optional.h>
    3233#include <wtf/Threading.h>
    3334#include <wtf/Vector.h>
    … …  
    4647    WTF_MAKE_NONCOPYABLE(TimerBase);
    4748    WTF_MAKE_FAST_ALLOCATED;
     49protected:
     50    static inline double msToSeconds(std::chrono::milliseconds duration) { return duration.count() * 0.001; }
     51    static inline std::chrono::milliseconds secondsToMS(double duration) { return std::chrono::milliseconds((std::chrono::milliseconds::rep)(duration * 1000)); }
     52
    4853public:
    4954    WEBCORE_EXPORT TimerBase();
    … …  
    5358
    5459    void startRepeating(double repeatInterval) { start(repeatInterval, repeatInterval); }
    55     void startRepeating(std::chrono::milliseconds repeatInterval) { startRepeating(repeatInterval.count() * 0.001); }
     60    void startRepeating(std::chrono::milliseconds repeatInterval) { startRepeating(msToSeconds(repeatInterval)); }
    5661    void startOneShot(double interval) { start(interval, 0); }
    57     void startOneShot(std::chrono::milliseconds interval) { startOneShot(interval.count() * 0.001); }
     62    void startOneShot(std::chrono::milliseconds interval) { startOneShot(msToSeconds(interval)); }
    5863
    5964    WEBCORE_EXPORT void stop();
    … …  
    6368    double nextUnalignedFireInterval() const;
    6469    double repeatInterval() const { return m_repeatInterval; }
     70    std::chrono::milliseconds repeatIntervalMS() const { return secondsToMS(repeatInterval()); }
    6571
    6672    void augmentFireInterval(double delta) { setNextFireTime(m_nextFireTime + delta); }
     73    void augmentFireInterval(std::chrono::milliseconds delta) { augmentFireInterval(msToSeconds(delta)); }
    6774    void augmentRepeatInterval(double delta) { augmentFireInterval(delta); m_repeatInterval += delta; }
     75    void augmentRepeatInterval(std::chrono::milliseconds delta) { augmentRepeatInterval(msToSeconds(delta)); }
    6876
    6977    void didChangeAlignmentInterval();
    … …  
    7482    virtual void fired() = 0;
    7583
    76     virtual double alignedFireTime(double fireTime) const { return fireTime; }
     84    virtual Optional<std::chrono::milliseconds> alignedFireTime(std::chrono::milliseconds) const { return Nullopt; }
    7785
    7886    void checkConsistency() const;

  • trunk/Source/WebCore/testing/InternalSettings.cpp

    r197563 r197690  
    467467{
    468468    InternalSettingsGuardForSettings();
    469     settings()->setMinimumDOMTimerInterval(intervalInSeconds);
     469    settings()->setMinimumDOMTimerInterval(std::chrono::milliseconds((std::chrono::milliseconds::rep)(intervalInSeconds * 1000)));
    470470}
    471471

  • trunk/Source/WebCore/testing/InternalSettings.h

    r190202 r197690  
    7676        bool m_langAttributeAwareFormControlUIEnabled;
    7777        bool m_imagesEnabled;
    78         double m_minimumTimerInterval;
     78        std::chrono::milliseconds m_minimumTimerInterval;
    7979#if ENABLE(VIDEO_TRACK)
    8080        bool m_shouldDisplaySubtitles;

  • trunk/Source/WebKit/win/ChangeLog

    r197614 r197690  
     12016-03-06  Gavin Barraclough  <barraclough@apple.com>
     2
     3        Convert DOMTimer to std::chrono::milliseconds
     4        https://bugs.webkit.org/show_bug.cgi?id=155085
     5
     6        Reviewed by Andreas Kling.
     7
     8        DOMTimer currently uses a mix of millisecond (was int, now std::chrono) and second (as double)
     9        time values. Constant conversion back and forth is a complete mess. Stop that.
     10
     11        * WebView.cpp:
     12        (WebView::setMinimumTimerInterval):
     13            - Convert double argument into std::chrono::milliseconds.
     14
    1152016-03-05  Yusuke Suzuki  <utatane.tea@gmail.com>
    216

  • trunk/Source/WebKit/win/WebView.cpp

    r195743 r197690  
    72217221    if (!interval)
    72227222        return E_POINTER;
    7223     *interval = DOMTimer::defaultMinimumInterval();
     7223    *interval = DOMTimer::defaultMinimumInterval().count() / 1000.;
    72247224    return S_OK;
    72257225}
    … …  
    72307230        return E_FAIL;
    72317231
    7232     page()->settings().setMinimumDOMTimerInterval(interval);
     7232    auto intervalMS = std::chrono::milliseconds((std::chrono::milliseconds::rep)(interval * 1000));
     7233    page()->settings().setMinimumDOMTimerInterval(intervalMS);
    72337234    return S_OK;
    72347235}
Note: See TracChangeset for help on using the changeset viewer.