author Andreas Tolfsen <ato@sny.no>
Thu, 11 Oct 2018 16:40:36 +0000
changeset 443621 9ca2c179e63e292808918158eb778b16bf18e67f
parent 409333 ada0ac5968f3bed9be8f1428bb857faf589463c6
child 448947 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
bug 1492499: marionette: warn on TimedPromise bailing; r=automatedtester We often use TimedPromise to ensure Marionette does not unexpectedly block on a promise that, for whatever reason, does not resolve. It can however be useful to be alerted when they don't, as it quite often means there is an underlying problem. Depends on D8406 Differential Revision: https://phabricator.services.mozilla.com/D8407

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef SystemTimeConverter_h
#define SystemTimeConverter_h

#include <limits>
#include "mozilla/TimeStamp.h"
#include "mozilla/TypeTraits.h"

// GetCurrentTime is defined in winbase.h as zero argument macro forwarding to
// GetTickCount().
#ifdef GetCurrentTime
#undef GetCurrentTime

namespace mozilla {

// Utility class that converts time values represented as an unsigned integral
// number of milliseconds from one time source (e.g. a native event time) to
// corresponding mozilla::TimeStamp objects.
// This class handles wrapping of integer values and skew between the time
// source and mozilla::TimeStamp values.
// It does this by using an historical reference time recorded in both time
// scales (i.e. both as a numerical time value and as a TimeStamp).
// For performance reasons, this class is careful to minimize calls to the
// native "current time" function (e.g. gdk_x11_server_get_time) since this can
// be slow.
template <typename Time>
class SystemTimeConverter {
    : mReferenceTime(Time(0))
    , mReferenceTimeStamp() // Initializes to the null timestamp
    , mLastBackwardsSkewCheck(Time(0))
    , kTimeRange(std::numeric_limits<Time>::max())
    , kTimeHalfRange(kTimeRange / 2)
    , kBackwardsSkewCheckInterval(Time(2000))
    static_assert(!IsSigned<Time>::value, "Expected Time to be unsigned");

  template <typename CurrentTimeGetter>
  GetTimeStampFromSystemTime(Time aTime,
                             CurrentTimeGetter& aCurrentTimeGetter) {
    TimeStamp roughlyNow = TimeStamp::Now();

    // If the reference time is not set, use the current time value to fill
    // it in.
    if (mReferenceTimeStamp.IsNull()) {
      // This sometimes happens when ::GetMessageTime returns 0 for the first
      // message on Windows.
      if (!aTime)
        return roughlyNow;
      UpdateReferenceTime(aTime, aCurrentTimeGetter);

    // Check for skew between the source of Time values and TimeStamp values.
    // We do this by comparing two durations (both in ms):
    // i.  The duration from the reference time to the passed-in time.
    //     (timeDelta in the diagram below)
    // ii. The duration from the reference timestamp to the current time
    //     based on TimeStamp::Now.
    //     (timeStampDelta in the diagram below)
    // Normally, we'd expect (ii) to be slightly larger than (i) to account
    // for the time taken between generating the event and processing it.
    // If (ii) - (i) is negative then the source of Time values is getting
    // "ahead" of TimeStamp. We call this "forwards" skew below.
    // For the reverse case, if (ii) - (i) is positive (and greater than some
    // tolerance factor), then we may have "backwards" skew. This is often
    // the case when we have a backlog of events and by the time we process
    // them, the time given by the system is comparatively "old".
    // We call the absolute difference between (i) and (ii), "deltaFromNow".
    // Graphically:
    //                    mReferenceTime              aTime
    // Time scale:      ........+.......................*........
    //                          |--------timeDelta------|
    //                  mReferenceTimeStamp             roughlyNow
    // TimeStamp scale: ........+...........................*....
    //                          |------timeStampDelta-------|
    //                                                  |---|
    //                                               deltaFromNow
    Time deltaFromNow;
    bool newer = IsTimeNewerThanTimestamp(aTime, roughlyNow, &deltaFromNow);

    // Tolerance when detecting clock skew.
    static const Time kTolerance = 30;

    // Check for forwards skew
    if (newer) {
      // Make aTime correspond to roughlyNow
      UpdateReferenceTime(aTime, roughlyNow);

      // We didn't have backwards skew so don't bother checking for
      // backwards skew again for a little while.
      mLastBackwardsSkewCheck = aTime;

      return roughlyNow;

    if (deltaFromNow <= kTolerance) {
      // If the time between event times and TimeStamp values is within
      // the tolerance then assume we don't have clock skew so we can
      // avoid checking for backwards skew for a while.
      mLastBackwardsSkewCheck = aTime;
    } else if (aTime - mLastBackwardsSkewCheck > kBackwardsSkewCheckInterval) {
      mLastBackwardsSkewCheck = aTime;

    // Finally, calculate the timestamp
    return roughlyNow - TimeDuration::FromMilliseconds(deltaFromNow);

  CompensateForBackwardsSkew(Time aReferenceTime,
                             const TimeStamp &aLowerBound) {
    // Check if we actually have backwards skew. Backwards skew looks like
    // the following:
    //        mReferenceTime
    // Time:      ..+...a...b...c..........................
    //     mReferenceTimeStamp
    // TimeStamp: ..+.....a.....b.....c....................
    // Converted
    // time:      ......a'..b'..c'.........................
    // What we need to do is bring mReferenceTime "forwards".
    // Suppose when we get (c), we detect possible backwards skew and trigger
    // an async request for the current time (which is passed in here as
    // aReferenceTime).
    // We end up with something like the following:
    //        mReferenceTime     aReferenceTime
    // Time:      ..+...a...b...c...v......................
    //     mReferenceTimeStamp
    // TimeStamp: ..+.....a.....b.....c..........x.........
    //                                ^          ^
    //                          aLowerBound  TimeStamp::Now()
    // If the duration (aLowerBound - mReferenceTimeStamp) is greater than
    // (aReferenceTime - mReferenceTime) then we know we have backwards skew.
    // If that's not the case, then we probably just got caught behind
    // temporarily.
    Time delta;
    if (IsTimeNewerThanTimestamp(aReferenceTime, aLowerBound, &delta)) {

    // We have backwards skew; the equivalent TimeStamp for aReferenceTime lies
    // somewhere between aLowerBound (which was the TimeStamp when we triggered
    // the async request for the current time) and TimeStamp::Now().
    // If aReferenceTime was waiting in the event queue for a long time, the
    // equivalent TimeStamp might be much closer to aLowerBound than
    // TimeStamp::Now() so for now we just set it to aLowerBound. That's
    // guaranteed to be at least somewhat of an improvement.
    UpdateReferenceTime(aReferenceTime, aLowerBound);

  template <typename CurrentTimeGetter>
  UpdateReferenceTime(Time aReferenceTime,
                      const CurrentTimeGetter& aCurrentTimeGetter) {
    Time currentTime = aCurrentTimeGetter.GetCurrentTime();
    TimeStamp currentTimeStamp = TimeStamp::Now();
    Time timeSinceReference = currentTime - aReferenceTime;
    TimeStamp referenceTimeStamp =
      currentTimeStamp - TimeDuration::FromMilliseconds(timeSinceReference);
    UpdateReferenceTime(aReferenceTime, referenceTimeStamp);

  UpdateReferenceTime(Time aReferenceTime,
                      const TimeStamp& aReferenceTimeStamp) {
    mReferenceTime = aReferenceTime;
    mReferenceTimeStamp = aReferenceTimeStamp;

  IsTimeNewerThanTimestamp(Time aTime, TimeStamp aTimeStamp, Time* aDelta)
    Time timeDelta = aTime - mReferenceTime;

    // Cast the result to signed 64-bit integer first since that should be
    // enough to hold the range of values returned by ToMilliseconds() and
    // the result of converting from double to an integer-type when the value
    // is outside the integer range is undefined.
    // Then we do an implicit cast to Time (typically an unsigned 32-bit
    // integer) which wraps times outside that range.
    Time timeStampDelta =
      static_cast<int64_t>((aTimeStamp - mReferenceTimeStamp).ToMilliseconds());

    Time timeToTimeStamp = timeStampDelta - timeDelta;
    bool isNewer = false;
    if (timeToTimeStamp == 0) {
      *aDelta = 0;
    } else if (timeToTimeStamp < kTimeHalfRange) {
      *aDelta = timeToTimeStamp;
    } else {
      isNewer = true;
      *aDelta = timeDelta - timeStampDelta;

    return isNewer;

  Time mReferenceTime;
  TimeStamp mReferenceTimeStamp;
  Time mLastBackwardsSkewCheck;

  const Time kTimeRange;
  const Time kTimeHalfRange;
  const Time kBackwardsSkewCheckInterval;

} // namespace mozilla

#endif /* SystemTimeConverter_h */