// https://w3c.github.io/web-animations/#finish-an-animation
void
Animation::Finish(ErrorResult& aRv)
{
if (mPlaybackRate == 0 ||
(mPlaybackRate > 0 && EffectEnd() == TimeDuration::Forever())) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
AutoMutationBatchForAnimation mb(*this);
// Seek to the end
TimeDuration limit =
mPlaybackRate > 0 ? TimeDuration(EffectEnd()) : TimeDuration(0);
bool didChange = GetCurrentTime() != Nullable<TimeDuration>(limit);
SilentlySetCurrentTime(limit);
// If we are paused or play-pending we need to fill in the start time in
// order to transition to the finished state.
//
// We only do this, however, if we have an active timeline. If we have an
// inactive timeline we can't transition into the finished state just like
// we can't transition to the running state (this finished state is really
// a substate of the running state).
if (mStartTime.IsNull() &&
mTimeline &&
!mTimeline->GetCurrentTime().IsNull()) {
mStartTime.SetValue(mTimeline->GetCurrentTime().Value() -
limit.MultDouble(1.0 / mPlaybackRate));
didChange = true;
}
// If we just resolved the start time for a pause or play-pending
// animation, we need to clear the task. We don't do this as a branch of
// the above however since we can have a play-pending animation with a
// resolved start time if we aborted a pause operation.
if (!mStartTime.IsNull() &&
(mPendingState == PendingState::PlayPending ||
mPendingState == PendingState::PausePending)) {
if (mPendingState == PendingState::PausePending) {
mHoldTime.SetNull();
}
CancelPendingTasks();
didChange = true;
if (mReady) {
mReady->MaybeResolve(this);
}
}
UpdateTiming(SeekFlag::DidSeek, SyncNotifyFlag::Sync);
if (didChange && IsRelevant()) {
nsNodeUtils::AnimationChanged(this);
}
PostUpdate();
}
// https://w3c.github.io/web-animations/#update-an-animations-finished-state
void
Animation::UpdateFinishedState(SeekFlag aSeekFlag,
SyncNotifyFlag aSyncNotifyFlag)
{
Nullable<TimeDuration> currentTime = GetCurrentTime();
TimeDuration effectEnd = TimeDuration(EffectEnd());
if (!mStartTime.IsNull() &&
mPendingState == PendingState::NotPending) {
if (mPlaybackRate > 0.0 &&
!currentTime.IsNull() &&
currentTime.Value() >= effectEnd) {
if (aSeekFlag == SeekFlag::DidSeek) {
mHoldTime = currentTime;
} else if (!mPreviousCurrentTime.IsNull()) {
mHoldTime.SetValue(std::max(mPreviousCurrentTime.Value(), effectEnd));
} else {
mHoldTime.SetValue(effectEnd);
}
} else if (mPlaybackRate < 0.0 &&
!currentTime.IsNull() &&
currentTime.Value() <= TimeDuration()) {
if (aSeekFlag == SeekFlag::DidSeek) {
mHoldTime = currentTime;
} else if (!mPreviousCurrentTime.IsNull()) {
mHoldTime.SetValue(std::min(mPreviousCurrentTime.Value(),
TimeDuration(0)));
} else {
mHoldTime.SetValue(0);
}
} else if (mPlaybackRate != 0.0 &&
!currentTime.IsNull() &&
mTimeline &&
!mTimeline->GetCurrentTime().IsNull()) {
if (aSeekFlag == SeekFlag::DidSeek && !mHoldTime.IsNull()) {
mStartTime.SetValue(mTimeline->GetCurrentTime().Value() -
(mHoldTime.Value().MultDouble(1 / mPlaybackRate)));
}
mHoldTime.SetNull();
}
}
bool currentFinishedState = PlayState() == AnimationPlayState::Finished;
if (currentFinishedState && !mFinishedIsResolved) {
DoFinishNotification(aSyncNotifyFlag);
} else if (!currentFinishedState && mFinishedIsResolved) {
ResetFinishedPromise();
}
// We must recalculate the current time to take account of any mHoldTime
// changes the code above made.
mPreviousCurrentTime = GetCurrentTime();
}
TimeDuration TimePeriod::length() const
{
if( isInvalid(m_start) )
{
return TimeDuration(E_TIME_NADT);
}
if( m_start >= m_finish )
{
return TimeDuration(Int64(0));
}
return timeBetween(m_start, m_finish);
}
// http://w3c.github.io/web-animations/#pause-an-animation
void
Animation::DoPause(ErrorResult& aRv)
{
if (IsPausedOrPausing()) {
return;
}
// If we are transitioning from idle, fill in the current time
if (GetCurrentTime().IsNull()) {
if (mPlaybackRate >= 0.0) {
mHoldTime.SetValue(TimeDuration(0));
} else {
if (EffectEnd() == TimeDuration::Forever()) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
mHoldTime.SetValue(TimeDuration(EffectEnd()));
}
}
bool reuseReadyPromise = false;
if (mPendingState == PendingState::PlayPending) {
CancelPendingTasks();
reuseReadyPromise = true;
}
// Mark this as no longer running on the compositor so that next time
// we update animations we won't throttle them and will have a chance
// to remove the animation from any layer it might be on.
mIsRunningOnCompositor = false;
if (!reuseReadyPromise) {
// Clear ready promise. We'll create a new one lazily.
mReady = nullptr;
}
mPendingState = PendingState::PausePending;
nsIDocument* doc = GetRenderedDocument();
if (doc) {
PendingAnimationTracker* tracker =
doc->GetOrCreatePendingAnimationTracker();
tracker->AddPausePending(*this);
} else {
TriggerOnNextTick(Nullable<TimeDuration>());
}
UpdateTiming(SeekFlag::NoSeek, SyncNotifyFlag::Async);
}
// https://w3c.github.io/web-animations/#pause-an-animation
void
Animation::DoPause(ErrorResult& aRv)
{
if (IsPausedOrPausing()) {
return;
}
AutoMutationBatchForAnimation mb(*this);
// If we are transitioning from idle, fill in the current time
if (GetCurrentTime().IsNull()) {
if (mPlaybackRate >= 0.0) {
mHoldTime.SetValue(TimeDuration(0));
} else {
if (EffectEnd() == TimeDuration::Forever()) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
mHoldTime.SetValue(TimeDuration(EffectEnd()));
}
}
bool reuseReadyPromise = false;
if (mPendingState == PendingState::PlayPending) {
CancelPendingTasks();
reuseReadyPromise = true;
}
if (!reuseReadyPromise) {
// Clear ready promise. We'll create a new one lazily.
mReady = nullptr;
}
mPendingState = PendingState::PausePending;
nsIDocument* doc = GetRenderedDocument();
if (doc) {
PendingAnimationTracker* tracker =
doc->GetOrCreatePendingAnimationTracker();
tracker->AddPausePending(*this);
} else {
TriggerOnNextTick(Nullable<TimeDuration>());
}
UpdateTiming(SeekFlag::NoSeek, SyncNotifyFlag::Async);
if (IsRelevant()) {
nsNodeUtils::AnimationChanged(this);
}
}
void AsyncPanZoomController::TrackTouch(const MultiTouchInput& aEvent) {
TimeDuration timeDelta = TimeDuration().FromMilliseconds(aEvent.mTime - mLastEventTime);
// Probably a duplicate event, just throw it away.
if (timeDelta.ToMilliseconds() <= EPSILON) {
return;
}
UpdateWithTouchAtDevicePoint(aEvent);
{
MonitorAutoLock monitor(mMonitor);
// We want to inversely scale it because when you're zoomed further in, a
// larger swipe should move you a shorter distance.
float inverseScale = 1 / mFrameMetrics.mResolution.width;
PRInt32 xDisplacement = mX.GetDisplacementForDuration(inverseScale, timeDelta);
PRInt32 yDisplacement = mY.GetDisplacementForDuration(inverseScale, timeDelta);
if (!xDisplacement && !yDisplacement) {
return;
}
ScrollBy(nsIntPoint(xDisplacement, yDisplacement));
ScheduleComposite();
if (aEvent.mTime - mLastRepaint >= PAN_REPAINT_INTERVAL) {
RequestContentRepaint();
mLastRepaint = aEvent.mTime;
}
}
}
TimeDuration
TaskThrottler::AverageDuration()
{
MonitorAutoLock lock(mMonitor);
return mMean.empty() ? TimeDuration() : mMean.mean();
}
void
AnimationPlayer::DoPlay()
{
// FIXME: When we implement finishing behavior (bug 1074630) we will
// need to pass a flag so that when we start playing due to a change in
// animation-play-state we *don't* trigger finishing behavior.
Nullable<TimeDuration> currentTime = GetCurrentTime();
if (currentTime.IsNull()) {
mHoldTime.SetValue(TimeDuration(0));
} else if (mHoldTime.IsNull()) {
// If the hold time is null, we are already playing normally
return;
}
// Clear ready promise. We'll create a new one lazily.
mReady = nullptr;
mIsPending = true;
nsIDocument* doc = GetRenderedDocument();
if (!doc) {
StartOnNextTick(Nullable<TimeDuration>());
return;
}
PendingPlayerTracker* tracker = doc->GetOrCreatePendingPlayerTracker();
tracker->AddPlayPending(*this);
// We may have updated the current time when we set the hold time above
// so notify source content.
UpdateSourceContent();
}
void CacheSystem::set(const String& key, const DataItem &value, uint32 expiration)
{
OS_LOCK(m_cs);
Buffer buff;
value.write(buff);
m_currentSize += buff.getSize();
shared_ptr<Item> item(OS_NEW CacheSystem::Item());
item->item = value;
item->size = buff.getSize();
if(expiration == 0)
item->expiration == DateTime::EMPTY;
else
item->expiration = DateTime::now() + TimeDuration(0, 0, expiration);
m_items[key] = item;
// TODO: Clean logic still missing.
// Will be better to add items to top of a list, and browse from bottom for removing.
if(m_currentSize > m_maxSize)
{
// TODO
// First lap, remove items expired
if(m_currentSize > m_maxSize)
{
// Second lap, remove until reach size.
}
}
}
void ShotGun::shoot()
{
if(ammoCount > 0)
{
elapsedTime = TimeDuration(0.0f);
--ammoCount;
}
}
void
Animation::UpdateFinishedState(bool aSeekFlag)
{
Nullable<TimeDuration> currentTime = GetCurrentTime();
TimeDuration effectEnd = TimeDuration(EffectEnd());
if (!mStartTime.IsNull() &&
mPendingState == PendingState::NotPending) {
if (mPlaybackRate > 0.0 &&
!currentTime.IsNull() &&
currentTime.Value() >= effectEnd) {
if (aSeekFlag) {
mHoldTime = currentTime;
} else if (!mPreviousCurrentTime.IsNull()) {
mHoldTime.SetValue(std::max(mPreviousCurrentTime.Value(), effectEnd));
} else {
mHoldTime.SetValue(effectEnd);
}
} else if (mPlaybackRate < 0.0 &&
!currentTime.IsNull() &&
currentTime.Value().ToMilliseconds() <= 0.0) {
if (aSeekFlag) {
mHoldTime = currentTime;
} else {
mHoldTime.SetValue(0);
}
} else if (mPlaybackRate != 0.0 &&
!currentTime.IsNull()) {
if (aSeekFlag && !mHoldTime.IsNull()) {
mStartTime.SetValue(mTimeline->GetCurrentTime().Value() -
(mHoldTime.Value().MultDouble(1 / mPlaybackRate)));
}
mHoldTime.SetNull();
}
}
bool currentFinishedState = IsFinished();
if (currentFinishedState && !mIsPreviousStateFinished) {
if (mFinished) {
mFinished->MaybeResolve(this);
}
} else if (!currentFinishedState && mIsPreviousStateFinished) {
// Clear finished promise. We'll create a new one lazily.
mFinished = nullptr;
if (mEffect->AsTransition()) {
mEffect->SetIsFinishedTransition(false);
}
}
mIsPreviousStateFinished = currentFinishedState;
// We must recalculate the current time to take account of any mHoldTime
// changes the code above made.
mPreviousCurrentTime = GetCurrentTime();
}
TimeDuration
TimeoutBudgetManager::RecordExecution(const TimeStamp& aNow,
const Timeout* aTimeout)
{
if (!mStart) {
// If we've started a sync operation mStart might be null, in
// which case we should not record this piece of execution.
return TimeDuration();
}
return aNow - mStart;
}
DateTime HMLSchedType::getNextCheckTime()
{
DateTime now = DateTime::now();
//use now.date, only change with this->hour and this->minute
DateTime objtime(now.date(), TimeDuration(hour, minute, 0));
if(now < objtime)
{
return objtime;
}
else
{
if(loop)
{
//now.date plus 1 day, as well as this->hour and this->minute
return objtime + TimeDuration(24, 0, 0);
}
else
{
return DateTime::invalid_datetime();
}
}
}
TimeDuration
TaskThrottler::AverageDuration()
{
if (!mDurations.Length()) {
return TimeDuration();
}
TimeDuration durationSum;
for (uint32_t i = 0; i < mDurations.Length(); i++) {
durationSum += mDurations[i];
}
return durationSum / mDurations.Length();
}
void AsyncPanZoomController::UpdateWithTouchAtDevicePoint(const MultiTouchInput& aEvent) {
SingleTouchData& touch = GetFirstSingleTouch(aEvent);
nsIntPoint point = touch.mScreenPoint;
PRInt32 xPos = point.x, yPos = point.y;
TimeDuration timeDelta = TimeDuration().FromMilliseconds(aEvent.mTime - mLastEventTime);
// Probably a duplicate event, just throw it away.
if (timeDelta.ToMilliseconds() <= EPSILON) {
return;
}
mX.UpdateWithTouchAtDevicePoint(xPos, timeDelta);
mY.UpdateWithTouchAtDevicePoint(yPos, timeDelta);
}
// https://w3c.github.io/web-animations/#finish-an-animation
void
Animation::Finish(ErrorResult& aRv)
{
if (mPlaybackRate == 0 ||
(mPlaybackRate > 0 && EffectEnd() == TimeDuration::Forever())) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
TimeDuration limit =
mPlaybackRate > 0 ? TimeDuration(EffectEnd()) : TimeDuration(0);
SetCurrentTime(limit);
if (mPendingState == PendingState::PlayPending) {
CancelPendingTasks();
if (mReady) {
mReady->MaybeResolve(this);
}
}
UpdateFinishedState(true);
PostUpdate();
}
void TimerThread::DoAfterSleep()
{
mSleeping = PR_TRUE; // wake may be notified without preceding sleep notification
for (PRUint32 i = 0; i < mTimers.Length(); i ++) {
nsTimerImpl *timer = mTimers[i];
// get and set the delay to cause its timeout to be recomputed
PRUint32 delay;
timer->GetDelay(&delay);
timer->SetDelay(delay);
}
// nuke the stored adjustments, so they get recalibrated
mTimeoutAdjustment = TimeDuration(0);
mDelayLineCounter = 0;
mSleeping = PR_FALSE;
}
void
AnimationPlayer::DoPlay()
{
// FIXME: When we implement finishing behavior (bug 1074630) we will
// need to pass a flag so that when we start playing due to a change in
// animation-play-state we *don't* trigger finishing behavior.
Nullable<TimeDuration> currentTime = GetCurrentTime();
if (currentTime.IsNull()) {
mHoldTime.SetValue(TimeDuration(0));
} else if (mHoldTime.IsNull()) {
// If the hold time is null, we are already playing normally
return;
}
// Clear ready promise. We'll create a new one lazily.
mReady = nullptr;
StartNow();
}
void WebsocketTransport::Write(const std::vector<Packet> & packets) {
writable_ = false;
// encodePacket efficient as it uses WS framing
// no need for encodePayload
for (auto packet : packets) {
auto message = EncodePacket(packet);
ws_->Send(message);
}
flush_emitter_->Emit(None());
// fake drain
// defer to next tick to allow Socket to clear writeBuffer
timer_pool_.SetTimeout(TimeDuration(0), [this]{
writable_ = true;
drain_emitter_->Emit(None());
});
}
void
AnimationPlayer::DoPlay()
{
// FIXME: When we implement finishing behavior (bug 1074630) we will
// need to pass a flag so that when we start playing due to a change in
// animation-play-state we *don't* trigger finishing behavior.
Nullable<TimeDuration> currentTime = GetCurrentTime();
if (currentTime.IsNull()) {
mHoldTime.SetValue(TimeDuration(0));
} else if (mHoldTime.IsNull()) {
// If the hold time is null, we are already playing normally
return;
}
// Clear ready promise. We'll create a new one lazily.
mReady = nullptr;
mIsPending = true;
nsIDocument* doc = GetRenderedDocument();
if (!doc) {
// If we have no rendered document (e.g. because the source content's
// target element is orphaned), then treat the animation as ready and
// start it immediately. It is probably preferable to make playing
// *always* asynchronous (e.g. by setting some additional state that
// marks this player as pending and queueing a runnable to resolve the
// start time). That situation, however, is currently rare enough that
// we don't bother for now.
StartNow();
return;
}
PendingPlayerTracker* tracker = doc->GetOrCreatePendingPlayerTracker();
tracker->AddPlayPending(*this);
// We may have updated the current time when we set the hold time above
// so notify source content.
UpdateSourceContent();
}
TimeStamp
Animation::AnimationTimeToTimeStamp(const StickyTimeDuration& aTime) const
{
// Initializes to null. Return the same object every time to benefit from
// return-value-optimization.
TimeStamp result;
// We *don't* check for mTimeline->TracksWallclockTime() here because that
// method only tells us if the timeline times can be converted to
// TimeStamps that can be compared to TimeStamp::Now() or not, *not*
// whether the timelines can be converted to TimeStamp values at all.
//
// Since we never compare the result of this method with TimeStamp::Now()
// it is ok to return values even if mTimeline->TracksWallclockTime() is
// false. Furthermore, we want to be able to use this method when the
// refresh driver is under test control (in which case TracksWallclockTime()
// will return false).
//
// Once we introduce timelines that are not time-based we will need to
// differentiate between them here and determine how to sort their events.
if (!mTimeline) {
return result;
}
// Check the time is convertible to a timestamp
if (aTime == TimeDuration::Forever() ||
mPlaybackRate == 0.0 ||
mStartTime.IsNull()) {
return result;
}
// Invert the standard relation:
// animation time = (timeline time - start time) * playback rate
TimeDuration timelineTime =
TimeDuration(aTime).MultDouble(1.0 / mPlaybackRate) + mStartTime.Value();
result = mTimeline->ToTimeStamp(timelineTime);
return result;
}
void AndroidFlingPhysics::Init(const ParentLayerPoint& aStartingVelocity,
float aPLPPI) {
mVelocity = aStartingVelocity.Length();
// We should not have created a fling animation if there is no velocity.
MOZ_ASSERT(mVelocity != 0.0f);
const double tuningCoeff = ComputeDeceleration(aPLPPI);
mTargetDuration = ComputeFlingDuration(mVelocity, tuningCoeff);
MOZ_ASSERT(!mTargetDuration.IsZero());
mDurationSoFar = TimeDuration();
mLastPos = ParentLayerPoint();
mCurrentPos = ParentLayerPoint();
float coeffX = mVelocity == 0 ? 1.0f : aStartingVelocity.x / mVelocity;
float coeffY = mVelocity == 0 ? 1.0f : aStartingVelocity.y / mVelocity;
mTargetDistance = ComputeFlingDistance(mVelocity, tuningCoeff);
mTargetPos =
ParentLayerPoint(mTargetDistance * coeffX, mTargetDistance * coeffY);
const float hyp = mTargetPos.Length();
if (FuzzyEqualsAdditive(hyp, 0.0f)) {
mDeltaNorm = ParentLayerPoint(1, 1);
} else {
mDeltaNorm = ParentLayerPoint(mTargetPos.x / hyp, mTargetPos.y / hyp);
}
}
// https://w3c.github.io/web-animations/#play-state
AnimationPlayState
Animation::PlayState() const
{
if (mPendingState != PendingState::NotPending) {
return AnimationPlayState::Pending;
}
Nullable<TimeDuration> currentTime = GetCurrentTime();
if (currentTime.IsNull()) {
return AnimationPlayState::Idle;
}
if (mStartTime.IsNull()) {
return AnimationPlayState::Paused;
}
if ((mPlaybackRate > 0.0 && currentTime.Value() >= EffectEnd()) ||
(mPlaybackRate < 0.0 && currentTime.Value() <= TimeDuration())) {
return AnimationPlayState::Finished;
}
return AnimationPlayState::Running;
}
bool DateAdjustDlg::GetAdjustedTimeSpan(TimeDuration& span_ret) const
{
if (!ready_)
return false;
span_ret = TimeDuration(0, 0, 0);
try
{
ASSERT(adj_mode_ == 0);
int days= 0, hours= 0, minutes= 0, seconds= 0;
if (GetInt(edit_days_, days) && GetInt(edit_hours_, hours) && GetInt(edit_minutes_, minutes) && GetInt(edit_seconds_, seconds))
{
span_ret = CreateTimeDuration(days, hours, minutes, seconds);
return true;
}
}
catch (...)
{
}
return false;
}
bool
TextureSourceProvider::NotifyNotUsedAfterComposition(TextureHost* aTextureHost)
{
mNotifyNotUsedAfterComposition.AppendElement(aTextureHost);
// If Compositor holds many TextureHosts without compositing,
// the TextureHosts should be flushed to reduce memory consumption.
const int thresholdCount = 5;
const double thresholdSec = 2.0f;
if (mNotifyNotUsedAfterComposition.Length() > thresholdCount) {
TimeStamp lastCompositionEndTime = GetLastCompositionEndTime();
TimeDuration duration = lastCompositionEndTime ? TimeStamp::Now() - lastCompositionEndTime : TimeDuration();
// Check if we could flush
if (duration.ToSeconds() > thresholdSec) {
FlushPendingNotifyNotUsed();
}
}
return true;
}
TimeDuration TimeDuration::Hours(int64_t hours)
{
return TimeDuration(static_cast<int64_t>(1000 * 60 * 60) * hours);
}
// http://w3c.github.io/web-animations/#play-an-animation
void
Animation::DoPlay(LimitBehavior aLimitBehavior)
{
bool abortedPause = mPendingState == PendingState::PausePending;
bool reuseReadyPromise = false;
if (mPendingState != PendingState::NotPending) {
CancelPendingTasks();
reuseReadyPromise = true;
}
Nullable<TimeDuration> currentTime = GetCurrentTime();
if (mPlaybackRate > 0.0 &&
(currentTime.IsNull() ||
(aLimitBehavior == LimitBehavior::AutoRewind &&
(currentTime.Value().ToMilliseconds() < 0.0 ||
currentTime.Value() >= EffectEnd())))) {
mHoldTime.SetValue(TimeDuration(0));
} else if (mPlaybackRate < 0.0 &&
(currentTime.IsNull() ||
(aLimitBehavior == LimitBehavior::AutoRewind &&
(currentTime.Value().ToMilliseconds() <= 0.0 ||
currentTime.Value() > EffectEnd())))) {
mHoldTime.SetValue(TimeDuration(EffectEnd()));
} else if (mPlaybackRate == 0.0 && currentTime.IsNull()) {
mHoldTime.SetValue(TimeDuration(0));
}
// If the hold time is null then we're either already playing normally (and
// we can ignore this call) or we aborted a pending pause operation (in which
// case, for consistency, we need to go through the motions of doing an
// asynchronous start even though we already have a resolved start time).
if (mHoldTime.IsNull() && !abortedPause) {
return;
}
// Clear the start time until we resolve a new one. We do this except
// for the case where we are aborting a pause and don't have a hold time.
//
// If we're aborting a pause and *do* have a hold time (e.g. because
// the animation is finished or we just applied the auto-rewind behavior
// above) we should respect it by clearing the start time. If we *don't*
// have a hold time we should keep the current start time so that the
// the animation continues moving uninterrupted by the aborted pause.
//
// (If we're not aborting a pause, mHoldTime must be resolved by now
// or else we would have returned above.)
if (!mHoldTime.IsNull()) {
mStartTime.SetNull();
}
if (!reuseReadyPromise) {
// Clear ready promise. We'll create a new one lazily.
mReady = nullptr;
}
mPendingState = PendingState::PlayPending;
nsIDocument* doc = GetRenderedDocument();
if (!doc) {
TriggerOnNextTick(Nullable<TimeDuration>());
return;
}
PendingAnimationTracker* tracker = doc->GetOrCreatePendingAnimationTracker();
tracker->AddPlayPending(*this);
// We may have updated the current time when we set the hold time above.
UpdateTiming();
}
TimeDuration TimeDuration::Days(int64_t days)
{
return TimeDuration(static_cast<int64_t>(1000 * 60 * 60 * 24) * days);
}
TimeDuration TimeDuration::Minutes(int64_t minutes)
{
return TimeDuration(static_cast<int64_t>(1000 * 60) * minutes);
}
TimeDuration TimeDuration::operator -() const {
return TimeDuration() - *this;
}
