chromium/base/allocator/partition_allocator/src/partition_alloc/partition_alloc_base/time/time.cc

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "partition_alloc/partition_alloc_base/time/time.h"

#include <atomic>
#include <cmath>
#include <limits>
#include <ostream>
#include <tuple>
#include <utility>

#include "partition_alloc/partition_alloc_base/time/time_override.h"

namespace partition_alloc::internal::base {

namespace internal {

std::atomic<TimeNowFunction> g_time_now_function{ … };

std::atomic<TimeNowFunction> g_time_now_from_system_time_function{ … };

std::atomic<TimeTicksNowFunction> g_time_ticks_now_function{ … };

std::atomic<ThreadTicksNowFunction> g_thread_ticks_now_function{ … };

}  // namespace internal

// TimeDelta ------------------------------------------------------------------

int TimeDelta::InDays() const { … }

int TimeDelta::InDaysFloored() const { … }

double TimeDelta::InMillisecondsF() const { … }

int64_t TimeDelta::InMilliseconds() const { … }

int64_t TimeDelta::InMillisecondsRoundedUp() const { … }

double TimeDelta::InMicrosecondsF() const { … }

TimeDelta TimeDelta::CeilToMultiple(TimeDelta interval) const { … }

TimeDelta TimeDelta::FloorToMultiple(TimeDelta interval) const { … }

TimeDelta TimeDelta::RoundToMultiple(TimeDelta interval) const { … }

// Time -----------------------------------------------------------------------

// static
Time Time::Now() { … }

// static
Time Time::NowFromSystemTime() { … }

time_t Time::ToTimeT() const { … }

// static
Time Time::FromSecondsSinceUnixEpoch(double dt) { … }

double Time::InSecondsFSinceUnixEpoch() const { … }

#if PA_BUILDFLAG(IS_POSIX) || PA_BUILDFLAG(IS_FUCHSIA)
// static
Time Time::FromTimeSpec(const timespec& ts) { … }
#endif

// static
Time Time::FromMillisecondsSinceUnixEpoch(double ms_since_epoch) { … }

double Time::InMillisecondsFSinceUnixEpoch() const { … }

double Time::InMillisecondsFSinceUnixEpochIgnoringNull() const { … }

Time Time::FromMillisecondsSinceUnixEpoch(int64_t ms_since_epoch) { … }

int64_t Time::InMillisecondsSinceUnixEpoch() const { … }

// static
bool Time::FromMillisecondsSinceUnixEpoch(int64_t unix_milliseconds,
                                          Time* time) { … }

int64_t Time::ToRoundedDownMillisecondsSinceUnixEpoch() const { … }

// TimeTicks ------------------------------------------------------------------

// static
TimeTicks TimeTicks::Now() { … }

// static
TimeTicks TimeTicks::UnixEpoch() { … }

TimeTicks TimeTicks::SnappedToNextTick(TimeTicks tick_phase,
                                       TimeDelta tick_interval) const { … }

// ThreadTicks ----------------------------------------------------------------

// static
ThreadTicks ThreadTicks::Now() { … }

}  // namespace partition_alloc::internal::base