Changeset 91206 in webkit


Ignore:
Timestamp:
Jul 18, 2011 1:38:42 PM (13 years ago)
Author:
commit-queue@webkit.org
Message:

Timer scheduling should be based off the monotonic clock
​https://bugs.webkit.org/show_bug.cgi?id=64544

Patch by James Robinson <​jamesr@chromium.org> on 2011-07-18
Reviewed by Darin Adler.

Source/JavaScriptCore:

Switches ThreadCondition::timedWait and related utility functions from currentTime() to
monotonicallyIncreasingTime().

Add WTF::monotonicallyIncreasingTime() to list of exported functions so it can be accessed from WebCore/WebKit.

(WTF::ThreadCondition::timedWait):

  • wtf/ThreadingWin.cpp:

(WTF::absoluteTimeToWaitTimeoutInterval):

  • wtf/gtk/ThreadingGtk.cpp:

(WTF::ThreadCondition::timedWait):

  • wtf/qt/ThreadingQt.cpp:

(WTF::ThreadCondition::timedWait):

Source/WebCore:

Changes the Timer scheduling logic from using absolute values in terms of currentTime() to using relative
intervals in terms of monotonicallyIncreasingTime(). This provides better standards compliance, compatibility,
and predictability when the system clock is adjusted.

No automated tests since there is no way to modify the system clock from DRT.

  • platform/SharedTimer.h:

(WebCore::MainThreadSharedTimer::setFireInterval):

  • platform/ThreadTimers.cpp:

(WebCore::ThreadTimers::updateSharedTimer):
(WebCore::ThreadTimers::sharedTimerFiredInternal):

  • platform/Timer.cpp:

(WebCore::TimerBase::start):
(WebCore::TimerBase::nextFireInterval):

  • platform/android/SharedTimerAndroid.cpp:

(WebCore::setSharedTimerFireInterval):

  • platform/brew/SharedTimerBrew.cpp:

(WebCore::setSharedTimerFireInterval):

  • platform/chromium/PlatformBridge.h:
  • platform/chromium/SharedTimerChromium.cpp:

(WebCore::setSharedTimerFireInterval):

  • platform/efl/SharedTimerEfl.cpp:

(WebCore::addNewTimer):
(WebCore::setSharedTimerFireInterval):

  • platform/gtk/SharedTimerGtk.cpp:

(WebCore::setSharedTimerFireInterval):

  • platform/haiku/SharedTimerHaiku.cpp:

(WebCore::SharedTimerHaiku::start):
(WebCore::setSharedTimerFireInterval):

  • platform/mac/SharedTimerMac.mm:

(WebCore::setSharedTimerFireInterval):

  • platform/qt/SharedTimerQt.cpp:

(WebCore::SharedTimerQt::start):
(WebCore::setSharedTimerFireInterval):

  • platform/win/SharedTimerWin.cpp:

(WebCore::setSharedTimerFireInterval):

  • platform/wince/SharedTimerWinCE.cpp:

(WebCore::setSharedTimerFireInterval):

  • platform/wx/SharedTimerWx.cpp:

(WebCore::setSharedTimerFireInterval):

  • workers/WorkerRunLoop.cpp:

(WebCore::WorkerSharedTimer::setFireInterval):

Source/WebKit/chromium:

Renames setSharedTimerFireTime to setSharedTimerFireInterval to be consistent with WebCore.

  • public/WebKitClient.h:

(WebKit::WebKitClient::setSharedTimerFireInterval):

  • src/PlatformBridge.cpp:

(WebCore::PlatformBridge::setSharedTimerFireInterval):

Source/WebKit2:

Converts the WebKit2 RunLoop and CoreIPC timeouts to use monotonicallyIncreasingTime().

  • Platform/CoreIPC/Connection.cpp:

(CoreIPC::Connection::waitForMessage):
(CoreIPC::Connection::waitForSyncReply):

  • Platform/RunLoop.h:
Location:
trunk/Source
Files:
30 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r91199 r91206  
     12011-07-18  James Robinson  <jamesr@chromium.org>
     2
     3        Timer scheduling should be based off the monotonic clock
     4        https://bugs.webkit.org/show_bug.cgi?id=64544
     5
     6        Reviewed by Darin Adler.
     7
     8        Switches ThreadCondition::timedWait and related utility functions from currentTime() to
     9        monotonicallyIncreasingTime().
     10
     11        Add WTF::monotonicallyIncreasingTime() to list of exported functions so it can be accessed from WebCore/WebKit.
     12
     13        * JavaScriptCore.exp:
     14        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
     15        * wtf/ThreadingPthreads.cpp:
     16        (WTF::ThreadCondition::timedWait):
     17        * wtf/ThreadingWin.cpp:
     18        (WTF::absoluteTimeToWaitTimeoutInterval):
     19        * wtf/gtk/ThreadingGtk.cpp:
     20        (WTF::ThreadCondition::timedWait):
     21        * wtf/qt/ThreadingQt.cpp:
     22        (WTF::ThreadCondition::timedWait):
     23
    1242011-07-18  Filip Pizlo  <fpizlo@apple.com>
    225

  • trunk/Source/JavaScriptCore/JavaScriptCore.exp

    r91194 r91206  
    450450__ZN3WTF23dayInMonthFromDayInYearEib
    451451__ZN3WTF23waitForThreadCompletionEjPPv
     452__ZN3WTF27monotonicallyIncreasingTimeEv
    452453__ZN3WTF27releaseFastMallocFreeMemoryEv
    453454__ZN3WTF28setMainThreadCallbacksPausedEb

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def

    r91194 r91206  
    241241    ?lookupSetter@JSObject@JSC@@UAE?AVJSValue@2@PAVExecState@2@ABVIdentifier@2@@Z
    242242    ?materializePropertyMap@Structure@JSC@@AAEXAAVJSGlobalData@2@@Z
     243    ?monotonicallyIncreasingTime@WTF@@YANXZ
    243244    ?monthFromDayInYear@WTF@@YAHH_N@Z
    244245    ?msToYear@WTF@@YAHN@Z

  • trunk/Source/JavaScriptCore/wtf/ThreadingPthreads.cpp

    r91094 r91206  
    364364bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
    365365{
    366     if (absoluteTime < currentTime())
     366    if (absoluteTime < monotonicallyIncreasingTime())
    367367        return false;
    368368

  • trunk/Source/JavaScriptCore/wtf/ThreadingWin.cpp

    r78597 r91206  
    484484DWORD absoluteTimeToWaitTimeoutInterval(double absoluteTime)
    485485{
    486     double currentTime = WTF::currentTime();
     486    double currentTime = monotonicallyIncreasingTime();
    487487
    488488    // Time is in the past - return immediately.

  • trunk/Source/JavaScriptCore/wtf/gtk/ThreadingGtk.cpp

    r64384 r91206  
    214214{
    215215    // Time is in the past - return right away.
    216     if (absoluteTime < currentTime())
     216    if (absoluteTime < monotonicallyIncreasingTime())
    217217        return false;
    218218   

  • trunk/Source/JavaScriptCore/wtf/qt/ThreadingQt.cpp

    r64384 r91206  
    256256bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
    257257{
    258     double currentTime = WTF::currentTime();
     258    double currentTime = monotonicallyIncreasingTime();
    259259
    260260    // Time is in the past - return immediately.

  • trunk/Source/WebCore/ChangeLog

    r91201 r91206  
     12011-07-18  James Robinson  <jamesr@chromium.org>
     2
     3        Timer scheduling should be based off the monotonic clock
     4        https://bugs.webkit.org/show_bug.cgi?id=64544
     5
     6        Reviewed by Darin Adler.
     7
     8        Changes the Timer scheduling logic from using absolute values in terms of currentTime() to using relative
     9        intervals in terms of monotonicallyIncreasingTime().  This provides better standards compliance, compatibility,
     10        and predictability when the system clock is adjusted.
     11
     12        No automated tests since there is no way to modify the system clock from DRT.
     13
     14        * platform/SharedTimer.h:
     15        (WebCore::MainThreadSharedTimer::setFireInterval):
     16        * platform/ThreadTimers.cpp:
     17        (WebCore::ThreadTimers::updateSharedTimer):
     18        (WebCore::ThreadTimers::sharedTimerFiredInternal):
     19        * platform/Timer.cpp:
     20        (WebCore::TimerBase::start):
     21        (WebCore::TimerBase::nextFireInterval):
     22        * platform/android/SharedTimerAndroid.cpp:
     23        (WebCore::setSharedTimerFireInterval):
     24        * platform/brew/SharedTimerBrew.cpp:
     25        (WebCore::setSharedTimerFireInterval):
     26        * platform/chromium/PlatformBridge.h:
     27        * platform/chromium/SharedTimerChromium.cpp:
     28        (WebCore::setSharedTimerFireInterval):
     29        * platform/efl/SharedTimerEfl.cpp:
     30        (WebCore::addNewTimer):
     31        (WebCore::setSharedTimerFireInterval):
     32        * platform/gtk/SharedTimerGtk.cpp:
     33        (WebCore::setSharedTimerFireInterval):
     34        * platform/haiku/SharedTimerHaiku.cpp:
     35        (WebCore::SharedTimerHaiku::start):
     36        (WebCore::setSharedTimerFireInterval):
     37        * platform/mac/SharedTimerMac.mm:
     38        (WebCore::setSharedTimerFireInterval):
     39        * platform/qt/SharedTimerQt.cpp:
     40        (WebCore::SharedTimerQt::start):
     41        (WebCore::setSharedTimerFireInterval):
     42        * platform/win/SharedTimerWin.cpp:
     43        (WebCore::setSharedTimerFireInterval):
     44        * platform/wince/SharedTimerWinCE.cpp:
     45        (WebCore::setSharedTimerFireInterval):
     46        * platform/wx/SharedTimerWx.cpp:
     47        (WebCore::setSharedTimerFireInterval):
     48        * workers/WorkerRunLoop.cpp:
     49        (WebCore::WorkerSharedTimer::setFireInterval):
     50
    1512011-07-18  Pratik Solanki  <psolanki@apple.com>
    252

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

    r76248 r91206  
    4242        virtual void setFiredFunction(void (*)()) = 0;
    4343
    44         // The fire time is relative to the classic POSIX epoch of January 1, 1970,
    45         // as the result of currentTime() is.
    46         virtual void setFireTime(double) = 0;
     44        // The fire interval is in seconds relative to the current monotonic clock time.
     45        virtual void setFireInterval(double) = 0;
    4746        virtual void stop() = 0;
    4847    };
    … …  
    5251    // FIXME: make ports implement MainThreadSharedTimer directly instead.
    5352    void setSharedTimerFiredFunction(void (*)());
    54     void setSharedTimerFireTime(double);
     53    void setSharedTimerFireInterval(double);
    5554    void stopSharedTimer();
    5655
    … …  
    6362        }
    6463       
    65         virtual void setFireTime(double fireTime)
     64        virtual void setFireInterval(double interval)
    6665        {
    67             setSharedTimerFireTime(fireTime);
     66            setSharedTimerFireInterval(interval);
    6867        }
    6968       

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

    r48086 r91206  
    3232#include "Timer.h"
    3333#include <wtf/CurrentTime.h>
     34
     35using namespace std;
    3436
    3537namespace WebCore {
    … …  
    8284        m_sharedTimer->stop();
    8385    else
    84         m_sharedTimer->setFireTime(m_timerHeap.first()->m_nextFireTime);
     86        m_sharedTimer->setFireInterval(max(m_timerHeap.first()->m_nextFireTime - monotonicallyIncreasingTime(), 0.0));
    8587}
    8688
    … …  
    98100    m_firingTimers = true;
    99101
    100     double fireTime = currentTime();
     102    double fireTime = monotonicallyIncreasingTime();
    101103    double timeToQuit = fireTime + maxDurationOfFiringTimers;
    102104
    … …  
    113115
    114116        // Catch the case where the timer asked timers to fire in a nested event loop, or we are over time limit.
    115         if (!m_firingTimers || timeToQuit < currentTime())
     117        if (!m_firingTimers || timeToQuit < monotonicallyIncreasingTime())
    116118            break;
    117119    }

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

    r53514 r91206  
    182182
    183183    m_repeatInterval = repeatInterval;
    184     setNextFireTime(currentTime() + nextFireInterval);
     184    setNextFireTime(monotonicallyIncreasingTime() + nextFireInterval);
    185185}
    186186
    … …  
    200200{
    201201    ASSERT(isActive());
    202     double current = currentTime();
     202    double current = monotonicallyIncreasingTime();
    203203    if (m_nextFireTime < current)
    204204        return 0;

  • trunk/Source/WebCore/platform/android/SharedTimerAndroid.cpp

    r51140 r91206  
    4646}
    4747
    48 // The fire time is relative to the classic POSIX epoch of January 1, 1970,
    49 // as the result of currentTime() is.
    50 void setSharedTimerFireTime(double fireTime)
     48void setSharedTimerFireInterval(double interval)
    5149{
    52     long long timeInMs = static_cast<long long>((fireTime - WTF::currentTime()) * 1000);
     50    long long timeInMs = static_cast<long long>(interval * 1000);
    5351
    54     LOGV("setSharedTimerFireTime: in %ld millisec", timeInMs);
     52    LOGV("setSharedTimerFireInterval: in %ld millisec", timeInMs);
    5553    if (JavaSharedClient::GetTimerClient())
    5654        JavaSharedClient::GetTimerClient()->setSharedTimer(timeInMs);

  • trunk/Source/WebCore/platform/brew/SharedTimerBrew.cpp

    r54200 r91206  
    4949}
    5050
    51 void setSharedTimerFireTime(double fireTime)
     51void setSharedTimerFireInterval(double interval)
    5252{
    5353    ASSERT(sharedTimerFiredFunction);
    … …  
    5555    CALLBACK_Cancel(&sharedTimerCallback);
    5656
    57     double interval = fireTime - currentTime();
    58     int intervalInMS;
    59 
    60     if (interval < 0)
    61         intervalInMS = 0;
    62     else {
    63         interval *= 1000;
    64         intervalInMS = static_cast<int>(interval);
    65     }
     57    int intervalInMS = statit_cast<int>(interval * 1000);
    6658
    6759    sharedTimerCallback.pfnCancel = 0;

  • trunk/Source/WebCore/platform/chromium/PlatformBridge.h

    r90952 r91206  
    235235    // SharedTimers -------------------------------------------------------
    236236    static void setSharedTimerFiredFunction(void (*func)());
    237     static void setSharedTimerFireTime(double);
     237    static void setSharedTimerFireInterval(double);
    238238    static void stopSharedTimer();
    239239

  • trunk/Source/WebCore/platform/chromium/SharedTimerChromium.cpp

    r76340 r91206  
    3636}
    3737
    38 void setSharedTimerFireTime(double fireTime)
     38void setSharedTimerFireInterval(double fireTime)
    3939{
    40     PlatformBridge::setSharedTimerFireTime(fireTime);
     40    PlatformBridge::setSharedTimerFireInterval(fireTime);
    4141}
    4242

  • trunk/Source/WebCore/platform/efl/SharedTimerEfl.cpp

    r89697 r91206  
    6363}
    6464
    65 void addNewTimer(double fireTime)
     65void addNewTimer(double interval)
    6666{
    67     double interval = fireTime - currentTime();
    6867    stopSharedTimer();
    6968
    … …  
    7170}
    7271
    73 void setSharedTimerFireTime(double fireTime)
     72void setSharedTimerFireInterval(double interval)
    7473{
    75     addNewTimer(fireTime);
     74    addNewTimer(interval);
    7675}
    7776

  • trunk/Source/WebCore/platform/gtk/SharedTimerGtk.cpp

    r65438 r91206  
    5151}
    5252
    53 void setSharedTimerFireTime(double fireTime)
     53void setSharedTimerFireInterval(double interval)
    5454{
    5555    ASSERT(sharedTimerFiredFunction);
    5656
    57     double interval = fireTime - currentTime();
    58     guint intervalInMS;
    59     if (interval < 0)
    60         intervalInMS = 0;
    61     else {
    62         interval *= 1000;
    63         intervalInMS = (guint)interval;
    64     }
     57    guint intervalInMS = static_cast<guint>(interval * 1000);
    6558
    6659    stopSharedTimer();

  • trunk/Source/WebCore/platform/haiku/SharedTimerHaiku.cpp

    r47480 r91206  
    8383}
    8484
    85 void SharedTimerHaiku::start(double fireTime)
     85void SharedTimerHaiku::start(double intervalInSeconds)
    8686{
    8787    m_shouldRun = true;
    8888
    89     double intervalInSeconds = fireTime - currentTime();
    90     bigtime_t intervalInMicroSeconds = intervalInSeconds < 0 ? 0 : intervalInSeconds * 1000000;
     89    bigtime_t intervalInMicroSeconds = intervalInSeconds * 1000000;
    9190
    9291    BMessageRunner::StartSending(Looper(), new BMessage(FIRE_MESSAGE), intervalInMicroSeconds, 1);
    … …  
    112111}
    113112
    114 void setSharedTimerFireTime(double fireTime)
     113void setSharedTimerFireInterval(double interval)
    115114{
    116     SharedTimerHaiku::instance()->start(fireTime);
     115    SharedTimerHaiku::instance()->start(interval);
    117116}
    118117

  • trunk/Source/WebCore/platform/mac/SharedTimerMac.mm

    r85036 r91206  
    168168}
    169169
    170 void setSharedTimerFireTime(double fireTime)
     170void setSharedTimerFireInterval(double interval)
    171171{
    172172    ASSERT(sharedTimerFiredFunction);
    … …  
    177177    }
    178178
    179     CFAbsoluteTime fireDate = fireTime - kCFAbsoluteTimeIntervalSince1970;
     179    CFAbsoluteTime fireDate = CFAbsoluteTimeGetCurrent() + interval;
    180180    sharedTimer = CFRunLoopTimerCreate(0, fireDate, 0, 0, 0, timerFired, 0);
    181181    CFRunLoopAddTimer(CFRunLoopGetCurrent(), sharedTimer, kCFRunLoopCommonModes);

  • trunk/Source/WebCore/platform/qt/SharedTimerQt.cpp

    r78490 r91206  
    9393}
    9494
    95 void SharedTimerQt::start(double fireTime)
     95void SharedTimerQt::start(double interval)
    9696{
    97     double interval = fireTime - currentTime();
    98     unsigned int intervalInMS;
    99     if (interval < 0)
    100         intervalInMS = 0;
    101     else {
    102         interval *= 1000;
    103         intervalInMS = (unsigned int)interval;
    104     }
     97    unsigned int intervalInMS = static_cast<unsigned int>(interval * 1000);
    10598
    10699    m_timer.start(intervalInMS, this);
    … …  
    129122}
    130123
    131 void setSharedTimerFireTime(double fireTime)
     124void setSharedTimerFireInterval(double interval)
    132125{
    133126    if (!QCoreApplication::instance())
    134127        return;
    135128
    136     SharedTimerQt::inst()->start(fireTime);
     129    SharedTimerQt::inst()->start(interval);
    137130}
    138131

  • trunk/Source/WebCore/platform/win/SharedTimerWin.cpp

    r55542 r91206  
    147147}
    148148
    149 void setSharedTimerFireTime(double fireTime)
     149void setSharedTimerFireInterval(double interval)
    150150{
    151151    ASSERT(sharedTimerFiredFunction);
    152152
    153     double interval = fireTime - currentTime();
    154153    unsigned intervalInMS;
    155     if (interval < 0)
    156         intervalInMS = 0;
    157     else {
    158         interval *= 1000;
    159         if (interval > USER_TIMER_MAXIMUM)
    160             intervalInMS = USER_TIMER_MAXIMUM;
    161         else
    162             intervalInMS = (unsigned)interval;
    163     }
     154    interval *= 1000;
     155    if (interval > USER_TIMER_MAXIMUM)
     156        intervalInMS = USER_TIMER_MAXIMUM;
     157    else
     158        intervalInMS = static_cast<unsigned>(interval);
    164159
    165160    initializeOffScreenTimerWindow();

  • trunk/Source/WebCore/platform/wince/SharedTimerWinCE.cpp

    r75190 r91206  
    8989#define USER_TIMER_MINIMUM  0x0000000A
    9090
    91 void setSharedTimerFireTime(double fireTime)
     91void setSharedTimerFireInterval(double intervalSeconds)
    9292{
    9393    ASSERT(sharedTimerFiredFunction);
    9494
    95     double interval = (fireTime - currentTime()) * 1000.;
    96     unsigned intervalInMS = interval < USER_TIMER_MINIMUM
     95    double intervalMS = intervalSeconds * 1000.;
     96    unsigned clampedIntervalMS = intervalMS < USER_TIMER_MINIMUM
    9797        ? USER_TIMER_MINIMUM
    98         : interval > USER_TIMER_MAXIMUM
     98        : intervalMS > USER_TIMER_MAXIMUM
    9999        ? USER_TIMER_MAXIMUM
    100         : static_cast<unsigned>(interval);
     100        : static_cast<unsigned>(intervalMS);
    101101
    102102    if (timerID == TimerIdAuto) {
    … …  
    106106
    107107    initializeOffScreenTimerWindow();
    108     if (SetTimer(timerWindowHandle, TimerIdAuto, intervalInMS, 0))
     108    if (SetTimer(timerWindowHandle, TimerIdAuto, clampedIntervalMS, 0))
    109109        timerID = TimerIdAuto;
    110110    else if (timerID != TimerIdManual)

  • trunk/Source/WebCore/platform/wx/SharedTimerWx.cpp

    r86485 r91206  
    6868}
    6969
    70 void setSharedTimerFireTime(double fireTime)
     70void setSharedTimerFireInterval(double interval)
    7171{
    7272    ASSERT(sharedTimerFiredFunction);
    73    
    74     double interval = fireTime - currentTime();
    7573   
    7674    if (!wkTimer)

  • trunk/Source/WebCore/workers/WorkerRunLoop.cpp

    r84892 r91206  
    4040#include "WorkerContext.h"
    4141#include "WorkerThread.h"
     42#include <wtf/CurrentTime.h>
    4243
    4344namespace WebCore {
    … …  
    5354    // SharedTimer interface.
    5455    virtual void setFiredFunction(void (*function)()) { m_sharedTimerFunction = function; }
    55     virtual void setFireTime(double fireTime) { m_nextFireTime = fireTime; }
     56    virtual void setFireInterval(double interval) { m_nextFireTime = interval + monotonicallyIncreasingTime(); }
    5657    virtual void stop() { m_nextFireTime = 0; }
    5758

  • trunk/Source/WebKit/chromium/ChangeLog

    r91205 r91206  
     12011-07-18  James Robinson  <jamesr@chromium.org>
     2
     3        Timer scheduling should be based off the monotonic clock
     4        https://bugs.webkit.org/show_bug.cgi?id=64544
     5
     6        Reviewed by Darin Adler.
     7
     8        Renames setSharedTimerFireTime to setSharedTimerFireInterval to be consistent with WebCore.
     9
     10        * public/WebKitClient.h:
     11        (WebKit::WebKitClient::setSharedTimerFireInterval):
     12        * src/PlatformBridge.cpp:
     13        (WebCore::PlatformBridge::setSharedTimerFireInterval):
     14
    1152011-07-18  Yuzhu Shen  <yzshen@chromium.com>
    216

  • trunk/Source/WebKit/chromium/public/WebKitClient.h

    r88745 r91206  
    4848#endif
    4949
     50// FIXME: remove after rolling deps
     51#define WEBKIT_USE_MONOTONIC_CLOCK_FOR_TIMER_SCHEDULING
     52
    5053namespace WebKit {
    5154
    … …  
    281284    typedef void (*SharedTimerFunction)();
    282285    virtual void setSharedTimerFiredFunction(SharedTimerFunction timerFunction) { }
    283     virtual void setSharedTimerFireTime(double fireTime) { }
     286    virtual void setSharedTimerFireInterval(double) { }
    284287    virtual void stopSharedTimer() { }
    285288

  • trunk/Source/WebKit/chromium/src/PlatformBridge.cpp

    r90952 r91206  
    666666}
    667667
    668 void PlatformBridge::setSharedTimerFireTime(double fireTime)
    669 {
    670     webKitClient()->setSharedTimerFireTime(fireTime);
     668void PlatformBridge::setSharedTimerFireInterval(double interval)
     669{
     670    webKitClient()->setSharedTimerFireInterval(interval);
    671671}
    672672

  • trunk/Source/WebKit2/ChangeLog

    r91188 r91206  
     12011-07-18  James Robinson  <jamesr@chromium.org>
     2
     3        Timer scheduling should be based off the monotonic clock
     4        https://bugs.webkit.org/show_bug.cgi?id=64544
     5
     6        Reviewed by Darin Adler.
     7
     8        Converts the WebKit2 RunLoop and CoreIPC timeouts to use monotonicallyIncreasingTime().
     9
     10        * Platform/CoreIPC/Connection.cpp:
     11        (CoreIPC::Connection::waitForMessage):
     12        (CoreIPC::Connection::waitForSyncReply):
     13        * Platform/RunLoop.h:
     14
    1152011-07-18  Anders Carlsson  <andersca@apple.com>
    216

  • trunk/Source/WebKit2/Platform/CoreIPC/Connection.cpp

    r89771 r91206  
    345345    }
    346346   
    347     double absoluteTime = currentTime() + timeout;
     347    double absoluteTime = monotonicallyIncreasingTime() + timeout;
    348348   
    349349    std::pair<unsigned, uint64_t> messageAndDestination(std::make_pair(messageID.toInt(), destinationID));
    … …  
    436436        timeout = 1e10;
    437437
    438     double absoluteTime = currentTime() + timeout;
     438    double absoluteTime = monotonicallyIncreasingTime() + timeout;
    439439
    440440    bool timedOut = false;

  • trunk/Source/WebKit2/Platform/RunLoop.h

    r84886 r91206  
    5959
    6060#if PLATFORM(WIN)
    61     // The absoluteTime is in seconds, starting on January 1, 1970. The time is assumed to use the
    62     // same time zone as WTF::currentTime(). Dispatches sent (not posted) messages to the passed-in
     61    // The absoluteTime is in seconds in terms of the monotonic clock. Dispatches sent (not posted) messages to the passed-in
    6362    // set of HWNDs until the semaphore is signaled or absoluteTime is reached. Returns true if the
    6463    // semaphore is signaled, false otherwise.
Note: See TracChangeset for help on using the changeset viewer.