fml Namespace Reference

Namespaces
namespace	benchmarking
namespace	icu
namespace	internal
namespace	jni
namespace	paths
namespace	scoped_policy
namespace	state
namespace	testing
namespace	tracing

Classes
class	AsciiTrie
	A trie for looking for ASCII prefixes. More...
class	AtomicObject
class	AutoResetWaitableEvent
class	BasicTaskRunner
	An interface over the ability to schedule tasks on a TaskRunner. More...
class	BitConverter
class	CFRef
class	ChronoTimestampProvider
class	CommandLine
class	ConcurrentMessageLoop
class	ConcurrentMessageLoopDarwin
class	ConcurrentTaskRunner
class	CountDownLatch
struct	CpuIndexAndSpeed
class	CPUSpeedTracker
	A class that computes the correct CPU indices for a requested CPU affinity. More...
class	DataMapping
struct	DebugTaskRunnerChecker
struct	DebugThreadChecker
class	DelayedTask
class	FileMapping
struct	IsByteSwappable
class	LogInterestListener
class	LogMessage
class	LogMessageVoidify
struct	LogSettings
class	LogState
class	MallocMapping
	A Mapping like NonOwnedMapping, but uses Free as its release proc. More...
class	ManualResetWaitableEvent
class	Mapping
class	MessageLoop
class	MessageLoopAndroid
class	MessageLoopDarwin
class	MessageLoopFuchsia
class	MessageLoopImpl
class	MessageLoopLinux
class	MessageLoopTaskQueues
class	MessageLoopWin
class	NativeLibrary
class	NonOwnedMapping
class	PlatformSemaphore
class	RasterThreadMerger
class	RefCountedThreadSafe
class	RefPtr
class	scoped_nsobject
class	scoped_nsobject< id >
class	scoped_nsprotocol
class	ScopedCleanupClosure
	Wraps a closure that is invoked in the destructor unless released by the caller. More...
class	ScopedNSAutoreleasePool
class	ScopedSetLogSettings
class	ScopedTemporaryDirectory
class	ScopedTypeRef
struct	ScopedTypeRefTraits
class	Semaphore
	A traditional counting semaphore. Waits decrement the counter and Signal increments it. More...
class	SharedLock
class	SharedMutex
class	SharedMutexPosix
class	SharedMutexStd
class	SharedThreadMerger
class	Status
class	StatusOr
class	SymbolMapping
class	SyncSwitch
class	TaskQueueEntry
class	TaskQueueId
class	TaskRunner
class	TaskRunnerAffineWeakPtr
class	TaskRunnerAffineWeakPtrFactory
class	TaskRunnerChecker
class	TaskSource
class	Thread
class	ThreadChecker
class	ThreadHandle
class	TimeDelta
class	TimePoint
class	TimestampProvider
class	UniqueLock
struct	UniqueLooperTraits
class	UniqueObject
class	Wakeable
class	WeakContainer
class	WeakNSObject
class	WeakNSObject< id >
class	WeakNSObjectFactory
class	WeakNSProtocol
class	WeakPtr
class	WeakPtrFactory

Typedefs
typedef AsciiTrie::TrieNode	TrieNode
typedef AsciiTrie::TrieNodePtr	TrieNodePtr
using	Base32DecodeConverter = BitConverter< 5, 8, 16 >
using	Base32EncodeConverter = BitConverter< 8, 5, 16 >
using	closure = std::function< void()>
using	DelayedTaskQueue = std::priority_queue< DelayedTask, std::deque< DelayedTask >, std::greater< DelayedTask > >
using	FileVisitor = std::function< bool(const fml::UniqueFD &directory, const std::string &filename)>
typedef int	LogSeverity
template<typename B >
using	ScopedBlock = ScopedTypeRef< B, internal::ScopedBlockTraits< B > >
using	WideStringConverter = std::wstring_convert< std::codecvt_utf8_utf16< wchar_t >, wchar_t >
typedef void *	RasterThreadMergerId
using	Utf16StringConverter = std::wstring_convert< std::codecvt_utf8_utf16< char16_t >, char16_t >
typedef std::function< void()>	ThreadFunction
using	Milliseconds = std::chrono::duration< double, std::milli >
using	UniqueFD = UniqueObject< int, internal::os_unix::UniqueFDTraits >
using	UniqueDir = UniqueObject< DIR *, internal::os_unix::UniqueDirTraits >

Enumerations
enum class	CpuAffinity { kPerformance , kEfficiency , kNotPerformance }
enum class	FilePermission { kRead , kWrite , kReadWrite }
enum class	FlushType { kSingle , kAll }
enum class	RasterThreadStatus { kRemainsMerged , kRemainsUnmerged , kUnmergedNow }
enum class	StatusCode {   kOk , kCancelled , kUnknown , kInvalidArgument ,   kDeadlineExceeded , kNotFound , kAlreadyExists , kPermissionDenied ,   kResourceExhausted , kFailedPrecondition , kAborted , kOutOfRange ,   kUnimplemented , kInternal , kUnavailable , kDataLoss ,   kUnauthenticated }
enum class	TaskSourceGrade { kUserInteraction , kDartEventLoop , kUnspecified }

Functions
static std::string	GetSymbolName (void *symbol)
static int	Backtrace (void **symbols, int size)
std::string	BacktraceHere (size_t offset)
static std::string	SignalNameToString (int signal)
static void	ToggleSignalHandlers (bool set)
static void	SignalHandler (int signal)
void	InstallCrashHandler ()
bool	IsCrashHandlingSupported ()
std::pair< bool, std::string >	Base32Encode (std::string_view input)
std::pair< bool, std::string >	Base32Decode (const std::string &input)
std::vector< std::string >	CommandLineToArgv (const CommandLine &command_line)
template<typename InputIterator >
CommandLine	CommandLineFromIteratorsFindFirstPositionalArg (InputIterator first, InputIterator last, InputIterator *first_positional_arg)
template<typename InputIterator >
CommandLine	CommandLineFromIterators (InputIterator first, InputIterator last)
template<typename InputIterator >
CommandLine	CommandLineFromIteratorsWithArgv0 (const std::string &argv0, InputIterator first, InputIterator last)
std::optional< CommandLine >	CommandLineFromPlatform ()
CommandLine	CommandLineFromArgcArgv (int argc, const char *const *argv)
CommandLine	CommandLineFromPlatformOrArgcArgv (int argc, const char *const *argv)
template<typename StringType >
CommandLine	CommandLineFromInitializerList (std::initializer_list< StringType > argv)
template<class Collection = std::unordered_map<class Key, class Value, class Hash, class Equal>>
void	erase_if (Collection &container, std::function< bool(typename Collection::iterator)> predicate)
std::optional< size_t >	EfficiencyCoreCount ()
	Request count of efficiency cores. More...
bool	RequestAffinity (CpuAffinity affinity)
	Request the given affinity for the current thread. More...
std::optional< int64_t >	ReadIntFromFile (const std::string &path)
template<typename T , class = std::enable_if_t<kIsByteSwappableV<T>>>
constexpr T	ByteSwap (T n)
	Flips the endianness of the given value. The given value must be an integral type of size 1, 2, 4, or 8. More...
template<typename T , class = std::enable_if_t<kIsByteSwappableV<T>>>
constexpr T	BigEndianToArch (T n)
	Convert a known big endian value to match the endianness of the current architecture. This is effectively a cross platform ntohl/ntohs (as network byte order is always Big Endian). The given value must be an integral type of size 1, 2, 4, or 8. More...
template<typename T , class = std::enable_if_t<kIsByteSwappableV<T>>>
constexpr T	LittleEndianToArch (T n)
	Convert a known little endian value to match the endianness of the current architecture. The given value must be an integral type of size 1, 2, 4, or 8. More...
static fml::UniqueFD	CreateDirectory (const fml::UniqueFD &base_directory, const std::vector< std::string > &components, FilePermission permission, size_t index)
fml::UniqueFD	CreateDirectory (const fml::UniqueFD &base_directory, const std::vector< std::string > &components, FilePermission permission)
bool	VisitFilesRecursively (const fml::UniqueFD &directory, const FileVisitor &visitor)
fml::UniqueFD	OpenFileReadOnly (const fml::UniqueFD &base_directory, const char *path)
fml::UniqueFD	OpenDirectoryReadOnly (const fml::UniqueFD &base_directory, const char *path)
bool	RemoveFilesInDirectory (const fml::UniqueFD &directory)
bool	RemoveDirectoryRecursively (const fml::UniqueFD &parent, const char *directory_name)
std::string	CreateTemporaryDirectory ()
fml::UniqueFD	OpenFile (const char *path, bool create_if_necessary, FilePermission permission)
	This can open a directory on POSIX, but not on Windows. More...
fml::UniqueFD	OpenFile (const fml::UniqueFD &base_directory, const char *path, bool create_if_necessary, FilePermission permission)
	This can open a directory on POSIX, but not on Windows. More...
fml::UniqueFD	OpenDirectory (const char *path, bool create_if_necessary, FilePermission permission)
fml::UniqueFD	OpenDirectory (const fml::UniqueFD &base_directory, const char *path, bool create_if_necessary, FilePermission permission)
fml::UniqueFD	Duplicate (fml::UniqueFD::element_type descriptor)
bool	IsDirectory (const fml::UniqueFD &directory)
bool	IsDirectory (const fml::UniqueFD &base_directory, const char *path)
bool	IsFile (const std::string &path)
bool	TruncateFile (const fml::UniqueFD &file, size_t size)
bool	FileExists (const fml::UniqueFD &base_directory, const char *path)
bool	UnlinkDirectory (const char *path)
bool	UnlinkDirectory (const fml::UniqueFD &base_directory, const char *path)
bool	UnlinkFile (const char *path)
bool	UnlinkFile (const fml::UniqueFD &base_directory, const char *path)
bool	WriteAtomically (const fml::UniqueFD &base_directory, const char *file_name, const Mapping &mapping)
bool	VisitFiles (const fml::UniqueFD &directory, const FileVisitor &visitor)
template<class Type >
constexpr void	HashCombineSeed (std::size_t &seed, Type arg)
template<class Type , class... Rest>
constexpr void	HashCombineSeed (std::size_t &seed, Type arg, Rest... other_args)
constexpr std::size_t	HashCombine ()
template<class... Type>
constexpr std::size_t	HashCombine (Type... args)
std::string	HexEncode (std::string_view input)
void	SetLogSettings (const LogSettings &settings)
LogSettings	GetLogSettings ()
int	GetMinLogLevel ()
int	GetVlogVerbosity ()
bool	ShouldCreateLogMessage (LogSeverity severity)
void	KillProcess ()
template<typename T >
internal::CopyableLambda< T >	MakeCopyable (T lambda)
	TEST (MallocMapping, EmptyContructor)
	TEST (MallocMapping, NotEmptyContructor)
	TEST (MallocMapping, MoveConstructor)
	TEST (MallocMapping, Copy)
	TEST (MallocMapping, Release)
	TEST (MallocMapping, IsDontNeedSafe)
	TEST (MallocMapping, CopySizeZero)
template<typename T >
RefPtr< T >	AdoptRef (T *ptr)
template<typename T >
RefPtr< T >	Ref (T *ptr)
template<typename T , typename... Args>
RefPtr< T >	MakeRefCounted (Args &&... args)
void	InitCPUInfo (size_t cpu_count)
bool	SetUpCPUTracker ()
std::optional< size_t >	AndroidEfficiencyCoreCount ()
	Android specific implementation of EfficiencyCoreCount. More...
bool	AndroidRequestAffinity (CpuAffinity affinity)
	Android specific implementation of RequestAffinity. More...
static ALooper *	AcquireLooperForThread ()
bool	IsPlatformVersionAtLeast (size_t major, size_t minor=0, size_t patch=0)
template<class C >
void	swap (scoped_nsprotocol< C > &p1, scoped_nsprotocol< C > &p2)
template<class C >
bool	operator== (C p1, const scoped_nsprotocol< C > &p2)
template<class C >
bool	operator!= (C p1, const scoped_nsprotocol< C > &p2)
NSRange	RangeForCharacterAtIndex (NSString *text, NSUInteger index)
NSRange	RangeForCharactersInRange (NSString *text, NSRange range)
bool		operator== (NST p1, const WeakNSProtocol< NST > &p2)
bool		operator!= (NST p1, const WeakNSProtocol< NST > &p2)
void	ExecuteAfterTaskObservers ()
void	CurrentMessageLoopAddAfterTaskObserver (intptr_t key, fit::closure observer)
void	CurrentMessageLoopRemoveAfterTaskObserver (intptr_t key)
bool	TimerRearm (int fd, fml::TimePoint time_point)
	Rearms the timer to expire at the given time point. More...
bool	TimerDrain (int fd)
static int	ToPosixAccessFlags (FilePermission permission)
static int	ToPosixCreateModeFlags (FilePermission permission)
static int	ToPosixProtectionFlags (std::initializer_list< FileMapping::Protection > protection_flags)
static bool	IsWritable (std::initializer_list< FileMapping::Protection > protection_flags)
char *	strdup (const char *str1)
int	GetCurrentProcId ()
std::string	GetLastErrorMessage ()
static std::string	GetFullHandlePath (const fml::UniqueFD &handle)
static bool	IsAbsolutePath (const char *path)
static std::string	GetAbsolutePath (const fml::UniqueFD &base_directory, const char *subpath)
static std::wstring	GetTemporaryDirectoryPath ()
static DWORD	GetDesiredAccessFlags (FilePermission permission)
static DWORD	GetShareFlags (FilePermission permission)
static DWORD	GetFileAttributesForUtf8Path (const char *absolute_path)
static DWORD	GetFileAttributesForUtf8Path (const fml::UniqueFD &base_directory, const char *path)
static bool	IsWritable (std::initializer_list< FileMapping::Protection > protection_flags)
static bool	IsExecutable (std::initializer_list< FileMapping::Protection > protection_flags)
std::string	WideStringToUtf8 (const std::wstring_view str)
std::wstring	Utf8ToWideString (const std::string_view str)
std::u16string	WideStringToUtf16 (const std::wstring_view str)
std::wstring	Utf16ToWideString (const std::u16string_view str)
template<typename T , std::size_t N>
constexpr std::size_t	size (T(&array)[N])
std::string	Join (const std::vector< std::string > &vec, const char *delim)
std::string	Utf16ToUtf8 (const std::u16string_view string)
std::u16string	Utf8ToUtf16 (const std::string_view string)
	TEST (CountDownLatchTest, CanWaitOnZero)
	TEST (CountDownLatchTest, CanWait)
template<typename ConditionFn >
bool	WaitWithTimeoutImpl (std::unique_lock< std::mutex > *locker, std::condition_variable *cv, ConditionFn condition, TimeDelta timeout)
void	SetThreadName (const std::string &name)
fml::TimePoint	ChronoTicksSinceEpoch ()
template<typename T >
Milliseconds	RefreshRateToFrameBudget (T refresh_rate)
template<typename Clock , typename Duration >
static int64_t	NanosSinceEpoch (std::chrono::time_point< Clock, Duration > time_point)
template<class T , class Traits >
void	swap (const UniqueObject< T, Traits > &a, const UniqueObject< T, Traits > &b)
template<class T , class Traits >
bool	operator== (const T &value, const UniqueObject< T, Traits > &object)
template<class T , class Traits >
bool	operator!= (const T &value, const UniqueObject< T, Traits > &object)

Variables
static std::string	kKUnknownFrameName = "Unknown"
static size_t	kKnownSignalHandlers []
static std::string	kKUnknownFrameName = "Unknown"
static constexpr char	kEncoding [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
static constexpr signed char	kDecodeMap []
static constexpr int	kDecodeMapSize
template<typename T >
constexpr bool	kIsByteSwappableV = IsByteSwappable<T>::value
static constexpr char	kEncoding [] = "0123456789abcdef"
constexpr LogSeverity	kLogInfo = 0
constexpr LogSeverity	kLogWarning = 1
constexpr LogSeverity	kLogError = 2
constexpr LogSeverity	kLogImportant = 3
constexpr LogSeverity	kLogFatal = 4
constexpr LogSeverity	kLogNumSeverities = 5
constexpr LogSeverity	LOG_INFO = kLogInfo
constexpr LogSeverity	LOG_WARNING = kLogWarning
constexpr LogSeverity	LOG_ERROR = kLogError
constexpr LogSeverity	LOG_IMPORTANT = kLogImportant
constexpr LogSeverity	LOG_FATAL = kLogFatal
const LogSeverity	kLogDFatal = kLogFatal
const LogSeverity	LOG_DFATAL = kLogDFatal
static thread_local std::unique_ptr< MessageLoop >	tls_message_loop
static thread_local std::unique_ptr< TaskSourceGradeHolder >	tls_task_source_grade
static const TaskQueueId	kUnmerged = TaskQueueId(TaskQueueId::kUnmerged)
std::once_flag	gCPUTrackerFlag
static CPUSpeedTracker *	gCPUTracker
static constexpr int	kClockType = CLOCK_MONOTONIC
static constexpr CFTimeInterval	kDistantFuture = 1.0e10
thread_local std::map< intptr_t, fit::closure >	tTaskObservers
static constexpr int	kClockType = CLOCK_MONOTONIC
constexpr Milliseconds	kDefaultFrameBudget = Milliseconds(1s) / 60

Typedef Documentation

Base32DecodeConverter

using fml::Base32DecodeConverter = typedef BitConverter<5, 8, 16>

Definition at line 49 of file base32.h.

Base32EncodeConverter

using fml::Base32EncodeConverter = typedef BitConverter<8, 5, 16>

Definition at line 50 of file base32.h.

closure

using fml::closure = typedef std::function<void()>

Definition at line 14 of file closure.h.

DelayedTaskQueue

using fml::DelayedTaskQueue = typedef std::priority_queue<DelayedTask, std::deque<DelayedTask>, std::greater<DelayedTask> >

Definition at line 42 of file delayed_task.h.

FileVisitor

using fml::FileVisitor = typedef std::function<bool(const fml::UniqueFD& directory, const std::string& filename)>

Signature of a callback on a file in directory with filename (relative to directory). The returned bool should be false if and only if further traversal should be stopped. For example, a file-search visitor may return false when the file is found so no more visiting is needed.

Definition at line 97 of file file.h.

LogSeverity

typedef int fml::LogSeverity

Definition at line 11 of file log_level.h.

Milliseconds

using fml::Milliseconds = typedef std::chrono::duration<double, std::milli>

Definition at line 18 of file time_delta.h.

RasterThreadMergerId

typedef void* fml::RasterThreadMergerId

Definition at line 19 of file shared_thread_merger.h.

ScopedBlock

template<typename B >

using fml::ScopedBlock = typedef ScopedTypeRef<B, internal::ScopedBlockTraits<B> >

Definition at line 41 of file scoped_block.h.

ThreadFunction

typedef std::function<void()> fml::ThreadFunction

Definition at line 27 of file thread.cc.

TrieNode

typedef AsciiTrie::TrieNode fml::TrieNode

Definition at line 10 of file ascii_trie.cc.

TrieNodePtr

typedef AsciiTrie::TrieNodePtr fml::TrieNodePtr

Definition at line 11 of file ascii_trie.cc.

UniqueDir

using fml::UniqueDir = typedef UniqueObject<DIR*, internal::os_unix::UniqueDirTraits>

Definition at line 101 of file unique_fd.h.

UniqueFD

using fml::UniqueFD = typedef UniqueObject<int, internal::os_unix::UniqueFDTraits>

Definition at line 100 of file unique_fd.h.

Utf16StringConverter

using fml::Utf16StringConverter = typedef std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>

Definition at line 23 of file string_conversion.cc.

WideStringConverter

using fml::WideStringConverter = typedef std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t>

Definition at line 13 of file wstring_conversion.cc.

Enumeration Type Documentation

CpuAffinity

enum class fml::CpuAffinity

strong

The CPU Affinity provides a hint to the operating system on which cores a particular thread should be scheduled on. The operating system may or may not honor these requests.

Enumerator
kPerformance	Request CPU affinity for the performance cores. Generally speaking, only the UI and Raster thread should use this option.
kEfficiency	Request CPU affinity for the efficiency cores.
kNotPerformance	Request affinity for all non-performance cores.

Definition at line 17 of file cpu_affinity.h.

                       {
  /// @brief Request CPU affinity for the performance cores.
  ///
  ///        Generally speaking, only the UI and Raster thread should
  ///        use this option.
  kPerformance,
 
  /// @brief Request CPU affinity for the efficiency cores.
  kEfficiency,
 
  /// @brief Request affinity for all non-performance cores.
  kNotPerformance,
};

FilePermission

enum class fml::FilePermission

strong

Enumerator
kRead
kWrite
kReadWrite

Definition at line 24 of file file.h.

                          {
  kRead,
  kWrite,
  kReadWrite,
};

FlushType

enum class fml::FlushType

strong

Enumerator
kSingle
kAll

Definition at line 55 of file message_loop_task_queues.h.

                     {
  kSingle,
  kAll,
};

RasterThreadStatus

enum class fml::RasterThreadStatus

strong

Enumerator
kRemainsMerged
kRemainsUnmerged
kUnmergedNow

Definition at line 20 of file raster_thread_merger.h.

                              {
  kRemainsMerged,
  kRemainsUnmerged,
  kUnmergedNow
};

StatusCode

enum class fml::StatusCode

strong

Enumerator
kOk
kCancelled
kUnknown
kInvalidArgument
kDeadlineExceeded
kNotFound
kAlreadyExists
kPermissionDenied
kResourceExhausted
kFailedPrecondition
kAborted
kOutOfRange
kUnimplemented
kInternal
kUnavailable
kDataLoss
kUnauthenticated

Definition at line 12 of file status.h.

                      {
  kOk,
  kCancelled,
  kUnknown,
  kInvalidArgument,
  kDeadlineExceeded,
  kNotFound,
  kAlreadyExists,
  kPermissionDenied,
  kResourceExhausted,
  kFailedPrecondition,
  kAborted,
  kOutOfRange,
  kUnimplemented,
  kInternal,
  kUnavailable,
  kDataLoss,
  kUnauthenticated
};

TaskSourceGrade

enum class fml::TaskSourceGrade

strong

Categories of work dispatched to MessageLoopTaskQueues dispatcher. By specifying the TaskSourceGrade, you indicate the task's importance to the dispatcher.

Enumerator
kUserInteraction	This TaskSourceGrade indicates that a task is critical to user interaction.
kDartEventLoop	This TaskSourceGrade indicates that a task corresponds to servicing a dart event loop task. These aren't critical to user interaction.
kUnspecified	The absence of a specialized TaskSourceGrade.

Definition at line 15 of file task_source_grade.h.

                           {
  /// This `TaskSourceGrade` indicates that a task is critical to user
  /// interaction.
  kUserInteraction,
  /// This `TaskSourceGrade` indicates that a task corresponds to servicing a
  /// dart event loop task. These aren't critical to user interaction.
  kDartEventLoop,
  /// The absence of a specialized `TaskSourceGrade`.
  kUnspecified,
};

Function Documentation

AcquireLooperForThread()

static ALooper * fml::AcquireLooperForThread ( )

static

Definition at line 16 of file message_loop_android.cc.

                                         {
  ALooper* looper = ALooper_forThread();
 
  if (looper == nullptr) {
    // No looper has been configured for the current thread. Create one and
    // return the same.
    looper = ALooper_prepare(0);
  }
 
  // The thread already has a looper. Acquire a reference to the same and return
  // it.
  ALooper_acquire(looper);
  return looper;
}

AdoptRef()

template<typename T >

RefPtr< T > fml::AdoptRef ( T *  ptr )

inline

Definition at line 222 of file ref_ptr.h.

                                  {
#ifndef NDEBUG
  ptr->Adopt();
#endif
  return RefPtr<T>(ptr, RefPtr<T>::kAdopt);
}

AndroidEfficiencyCoreCount()

std::optional< size_t > fml::AndroidEfficiencyCoreCount

(

)

Android specific implementation of EfficiencyCoreCount.

Definition at line 50 of file cpu_affinity.cc.

                                                 {
  if (!SetUpCPUTracker()) {
    return true;
  }
  auto result = gCPUTracker->GetIndices(CpuAffinity::kEfficiency).size();
  FML_DCHECK(result > 0);
  return result;
}

AndroidRequestAffinity()

bool fml::AndroidRequestAffinity

(

CpuAffinity

affinity

)

Android specific implementation of RequestAffinity.

Definition at line 59 of file cpu_affinity.cc.

                                                  {
  if (!SetUpCPUTracker()) {
    return true;
  }
 
  cpu_set_t set;
  CPU_ZERO(&set);
  for (const auto index : gCPUTracker->GetIndices(affinity)) {
    CPU_SET(index, &set);
  }
  return sched_setaffinity(gettid(), sizeof(set), &set) == 0;
}

Backtrace()

static int fml::Backtrace ( void **  symbols, int  size  )

static

Definition at line 35 of file backtrace.cc.

                                               {
#if FML_OS_WIN
  return CaptureStackBackTrace(0, size, symbols, NULL);
#else
  return ::backtrace(symbols, size);
#endif  // FML_OS_WIN
}

BacktraceHere()

std::string fml::BacktraceHere

(

size_t

offset = 0

)

Definition at line 43 of file backtrace.cc.

                                       {
  constexpr size_t kMaxFrames = 256;
  void* symbols[kMaxFrames];
  const auto available_frames = Backtrace(symbols, kMaxFrames);
  if (available_frames <= 0) {
    return "";
  }
 
  // Exclude here.
  offset += 2;
 
  std::stringstream stream;
  for (int i = offset; i < available_frames; ++i) {
    stream << "Frame " << i - offset << ": " << symbols[i] << " "
           << GetSymbolName(symbols[i]) << std::endl;
  }
  return stream.str();
}

Base32Decode()

std::pair< bool, std::string > fml::Base32Decode

(

const std::string &

input

)

Definition at line 55 of file base32.cc.

                                                              {
  std::string result;
  Base32DecodeConverter converter;
  for (char c : input) {
    int map_index = c - '2';
    if (map_index < 0 || map_index >= kDecodeMapSize ||
        kDecodeMap[map_index] == -1) {
      return {false, result};
    }
    converter.Append(kDecodeMap[map_index]);
    if (converter.CanExtract()) {
      result.push_back(converter.Extract());
    }
  }
  if (converter.Peek() != 0) {
    // The padding should always be zero. Return false if not.
    return {false, result};
  }
  return {true, result};
}

Base32Encode()

std::pair< bool, std::string > fml::Base32Encode

(

std::string_view

input

)

Definition at line 15 of file base32.cc.

                                                            {
  if (input.empty()) {
    return {true, ""};
  }
 
  if (input.size() > std::numeric_limits<size_t>::max() / 8) {
    return {false, ""};
  }
 
  std::string output;
  const size_t encoded_length = (input.size() * 8 + 4) / 5;
  output.reserve(encoded_length);
 
  Base32EncodeConverter converter;
  converter.Append(static_cast<uint8_t>(input[0]));
  size_t next_byte_index = 1;
 
  while (converter.CanExtract()) {
    output.push_back(kEncoding[converter.Extract()]);
    if (converter.CanAppend() && next_byte_index < input.size()) {
      converter.Append(static_cast<uint8_t>(input[next_byte_index++]));
    }
  }
 
  if (converter.BitsAvailable() > 0) {
    output.push_back(kEncoding[converter.Peek()]);
  }
 
  return {true, output};
}

BigEndianToArch()

template<typename T , class = std::enable_if_t<kIsByteSwappableV<T>>>

constexpr T fml::BigEndianToArch ( T  n )

constexpr

Convert a known big endian value to match the endianness of the current architecture. This is effectively a cross platform ntohl/ntohs (as network byte order is always Big Endian). The given value must be an integral type of size 1, 2, 4, or 8.

Definition at line 59 of file endianness.h.

                                 {
#if FML_ARCH_CPU_LITTLE_ENDIAN
  return ByteSwap<T>(n);
#else
  return n;
#endif
}

ByteSwap()

template<typename T , class = std::enable_if_t<kIsByteSwappableV<T>>>

constexpr T fml::ByteSwap ( T  n )

constexpr

Flips the endianness of the given value. The given value must be an integral type of size 1, 2, 4, or 8.

Definition at line 40 of file endianness.h.

                          {
  if constexpr (sizeof(T) == 1) {
    return n;
  } else if constexpr (sizeof(T) == 2) {
    return (T)FML_BYTESWAP_16((uint16_t)n);
  } else if constexpr (sizeof(T) == 4) {
    return (T)FML_BYTESWAP_32((uint32_t)n);
  } else if constexpr (sizeof(T) == 8) {
    return (T)FML_BYTESWAP_64((uint64_t)n);
  } else {
    static_assert(!sizeof(T), "Unsupported size");
  }
}

ChronoTicksSinceEpoch()

fml::TimePoint fml::ChronoTicksSinceEpoch

(

)

Definition at line 21 of file chrono_timestamp_provider.cc.

                                     {
  return ChronoTimestampProvider::Instance().Now();
}

CommandLineFromArgcArgv()

CommandLine fml::CommandLineFromArgcArgv ( int  argc, const char *const *  argv  )

inline

Definition at line 233 of file command_line.h.

                                                                              {
  return CommandLineFromIterators(argv, argv + argc);
}

CommandLineFromInitializerList()

template<typename StringType >

CommandLine fml::CommandLineFromInitializerList ( std::initializer_list< StringType >  argv )

inline

Definition at line 254 of file command_line.h.

                                          {
  return CommandLineFromIterators(argv.begin(), argv.end());
}

CommandLineFromIterators()

template<typename InputIterator >

CommandLine fml::CommandLineFromIterators ( InputIterator  first, InputIterator  last  )

inline

Definition at line 204 of file command_line.h.

                                                                {
  return CommandLineFromIteratorsFindFirstPositionalArg<InputIterator>(
      first, last, nullptr);
}

CommandLineFromIteratorsFindFirstPositionalArg()

template<typename InputIterator >

CommandLine fml::CommandLineFromIteratorsFindFirstPositionalArg ( InputIterator  first, InputIterator  last, InputIterator *  first_positional_arg  )

inline

Definition at line 182 of file command_line.h.

                                         {
  if (first_positional_arg) {
    *first_positional_arg = last;
  }
  internal::CommandLineBuilder builder;
  for (auto it = first; it < last; ++it) {
    if (builder.ProcessArg(*it)) {
      if (first_positional_arg) {
        *first_positional_arg = it;
      }
    }
  }
  return builder.Build();
}

CommandLineFromIteratorsWithArgv0()

template<typename InputIterator >

CommandLine fml::CommandLineFromIteratorsWithArgv0 ( const std::string &  argv0, InputIterator  first, InputIterator  last  )

inline

Definition at line 214 of file command_line.h.

                                                                         {
  internal::CommandLineBuilder builder;
  builder.ProcessArg(argv0);
  for (auto it = first; it < last; ++it) {
    builder.ProcessArg(*it);
  }
  return builder.Build();
}

CommandLineFromPlatform()

std::optional< CommandLine > fml::CommandLineFromPlatform

(

)

Definition at line 9 of file command_line_posix.cc.

                                                   {
  return std::nullopt;
}

CommandLineFromPlatformOrArgcArgv()

CommandLine fml::CommandLineFromPlatformOrArgcArgv ( int  argc, const char *const *  argv  )

inline

Definition at line 242 of file command_line.h.

                                                                              {
  auto command_line = CommandLineFromPlatform();
  if (command_line.has_value()) {
    return *command_line;
  }
  return CommandLineFromArgcArgv(argc, argv);
}

CommandLineToArgv()

std::vector< std::string > fml::CommandLineToArgv

(

const CommandLine &

command_line

)

Definition at line 141 of file command_line.cc.

                                                                        {
  if (!command_line.has_argv0()) {
    return std::vector<std::string>();
  }
 
  std::vector<std::string> argv;
  const std::vector<CommandLine::Option>& options = command_line.options();
  const std::vector<std::string>& positional_args =
      command_line.positional_args();
  // Reserve space for argv[0], options, maybe a "--" (if needed), and the
  // positional arguments.
  argv.reserve(1u + options.size() + 1u + positional_args.size());
 
  argv.push_back(command_line.argv0());
  for (const auto& option : options) {
    if (option.value.empty()) {
      argv.push_back("--" + option.name);
    } else {
      argv.push_back("--" + option.name + "=" + option.value);
    }
  }
 
  if (!positional_args.empty()) {
    // Insert a "--" if necessary.
    if (positional_args[0].size() >= 2u && positional_args[0][0] == '-' &&
        positional_args[0][1] == '-') {
      argv.push_back("--");
    }
 
    argv.insert(argv.end(), positional_args.begin(), positional_args.end());
  }
 
  return argv;
}

CreateDirectory() [1/2]

fml::UniqueFD fml::CreateDirectory	(	const fml::UniqueFD &	base_directory,
		const std::vector< std::string > &	components,
		FilePermission	permission
	)

Definition at line 33 of file file.cc.

                                                         {
  if (!IsDirectory(base_directory)) {
    return {};
  }
 
  if (components.empty()) {
    return {};
  }
 
  return CreateDirectory(base_directory, components, permission, 0);
}

CreateDirectory() [2/2]

static fml::UniqueFD fml::CreateDirectory ( const fml::UniqueFD &  base_directory, const std::vector< std::string > &  components, FilePermission  permission, size_t  index  )

static

Definition at line 12 of file file.cc.

                                                   {
  FML_DCHECK(index <= components.size());
 
  const char* file_path = components[index].c_str();
 
  auto directory = OpenDirectory(base_directory, file_path, true, permission);
 
  if (!directory.is_valid()) {
    return {};
  }
 
  if (index == components.size() - 1) {
    return directory;
  }
 
  return CreateDirectory(directory, components, permission, index + 1);
}

CreateTemporaryDirectory()

std::string fml::CreateTemporaryDirectory

(

)

Definition at line 25 of file file_posix.cc.

                                     {
  char directory_name[] = "/tmp/flutter_XXXXXXXX";
  auto* result = ::mkdtemp(directory_name);
  if (result == nullptr) {
    return "";
  }
  return {result};
}

CurrentMessageLoopAddAfterTaskObserver()

void fml::CurrentMessageLoopAddAfterTaskObserver	(	intptr_t	key,
		fit::closure	observer
	)

Definition at line 19 of file task_observers.cc.

                                                                 {
  if (observer) {
    tTaskObservers[key] = std::move(observer);
  }
}

CurrentMessageLoopRemoveAfterTaskObserver()

void fml::CurrentMessageLoopRemoveAfterTaskObserver

(

intptr_t

key

)

Definition at line 26 of file task_observers.cc.

                                                             {
  tTaskObservers.erase(key);
}

Duplicate()

fml::UniqueFD fml::Duplicate

(

fml::UniqueFD::element_type

descriptor

)

Definition at line 123 of file file_posix.cc.

                                                          {
  return fml::UniqueFD{FML_HANDLE_EINTR(::dup(descriptor))};
}

EfficiencyCoreCount()

std::optional< size_t > fml::EfficiencyCoreCount

(

)

Request count of efficiency cores.

   Efficiency cores are defined as those with the lowest reported
   cpu_max_freq. If the CPU speed could not be determined, or if all
   cores have the same reported speed then this returns std::nullopt.
   That is, the result will never be 0. 

Definition at line 18 of file cpu_affinity.cc.

                                          {
#ifdef FML_OS_ANDROID
  return AndroidEfficiencyCoreCount();
#else
  return std::nullopt;
#endif
}

erase_if()

template<class Collection = std::unordered_map<class Key, class Value, class Hash, class Equal>>

void fml::erase_if	(	Collection &	container,
		std::function< bool(typename Collection::iterator)>	predicate
	)

Definition at line 16 of file container.h.

                                                                        {
  auto it = container.begin();
  while (it != container.end()) {
    if (predicate(it)) {
      it = container.erase(it);
      continue;
    }
    it++;
  }
}

ExecuteAfterTaskObservers()

void fml::ExecuteAfterTaskObservers

(

)

Definition at line 13 of file task_observers.cc.

                                 {
  for (const auto& callback : tTaskObservers) {
    callback.second();
  }
}

FileExists()

bool fml::FileExists	(	const fml::UniqueFD &	base_directory,
		const char *	path
	)

Definition at line 183 of file file_posix.cc.

                                                                     {
  if (!base_directory.is_valid()) {
    return false;
  }
 
  return ::faccessat(base_directory.get(), path, F_OK, 0) == 0;
}

GetAbsolutePath()

static std::string fml::GetAbsolutePath ( const fml::UniqueFD &  base_directory, const char *  subpath  )

static

Definition at line 50 of file file_win.cc.

                                                        {
  std::string path;
  if (IsAbsolutePath(subpath)) {
    path = subpath;
  } else {
    std::stringstream stream;
    stream << GetFullHandlePath(base_directory) << "\\" << subpath;
    path = stream.str();
  }
  std::replace(path.begin(), path.end(), '/', '\\');
  return path;
}

GetCurrentProcId()

int fml::GetCurrentProcId

(

)

Definition at line 9 of file process_posix.cc.

                       {
  return static_cast<int>(getpid());
}

GetDesiredAccessFlags()

static DWORD fml::GetDesiredAccessFlags ( FilePermission  permission )

static

Definition at line 73 of file file_win.cc.

                                                              {
  switch (permission) {
    case FilePermission::kRead:
      return GENERIC_READ;
    case FilePermission::kWrite:
      return GENERIC_WRITE;
    case FilePermission::kReadWrite:
      return GENERIC_READ | GENERIC_WRITE;
  }
  return GENERIC_READ;
}

GetFileAttributesForUtf8Path() [1/2]

static DWORD fml::GetFileAttributesForUtf8Path ( const char *  absolute_path )

static

Definition at line 97 of file file_win.cc.

                                                                     {
  return ::GetFileAttributes(Utf8ToWideString(absolute_path).c_str());
}

GetFileAttributesForUtf8Path() [2/2]

static DWORD fml::GetFileAttributesForUtf8Path ( const fml::UniqueFD &  base_directory, const char *  path  )

static

Definition at line 101 of file file_win.cc.

                                                            {
  std::string full_path = GetAbsolutePath(base_directory, path);
  return GetFileAttributesForUtf8Path(full_path.c_str());
}

GetFullHandlePath()

static std::string fml::GetFullHandlePath ( const fml::UniqueFD &  handle )

static

Definition at line 27 of file file_win.cc.

                                                              {
  wchar_t buffer[MAX_PATH] = {0};
  const DWORD buffer_size = ::GetFinalPathNameByHandle(
      handle.get(), buffer, MAX_PATH, FILE_NAME_NORMALIZED);
  if (buffer_size == 0) {
    return {};
  }
  return WideStringToUtf8({buffer, buffer_size});
}

GetLastErrorMessage()

std::string fml::GetLastErrorMessage

(

)

Definition at line 15 of file errors_win.cc.

                                {
  DWORD last_error = ::GetLastError();
  if (last_error == 0) {
    return {};
  }
 
  const DWORD flags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
                      FORMAT_MESSAGE_FROM_SYSTEM |
                      FORMAT_MESSAGE_IGNORE_INSERTS;
 
  wchar_t* buffer = nullptr;
  size_t size = ::FormatMessage(
      flags,                                      // dwFlags
      NULL,                                       // lpSource
      last_error,                                 // dwMessageId
      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),  // dwLanguageId
      (LPWSTR)&buffer,                            // lpBuffer
      0,                                          // nSize
      NULL                                        // Arguments
  );
 
  std::wstring message(buffer, size);
 
  ::LocalFree(buffer);
 
  std::wstringstream stream;
  stream << message << " (" << last_error << ").";
 
  return WideStringToUtf8(stream.str());
}

GetLogSettings()

LogSettings fml::GetLogSettings

(

)

Definition at line 32 of file log_settings.cc.

                             {
  return state::g_log_settings;
}

GetMinLogLevel()

int fml::GetMinLogLevel

(

)

Definition at line 36 of file log_settings.cc.

                     {
  return std::min(state::g_log_settings.min_log_level, kLogFatal);
}

GetShareFlags()

static DWORD fml::GetShareFlags ( FilePermission  permission )

static

Definition at line 85 of file file_win.cc.

                                                      {
  switch (permission) {
    case FilePermission::kRead:
      return FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
    case FilePermission::kWrite:
      return 0;
    case FilePermission::kReadWrite:
      return 0;
  }
  return FILE_SHARE_READ;
}

GetSymbolName()

static std::string fml::GetSymbolName ( void *  symbol )

static

Definition at line 27 of file backtrace.cc.

                                             {
  char name[1024];
  if (!absl::Symbolize(symbol, name, sizeof(name))) {
    return kKUnknownFrameName;
  }
  return name;
}

GetTemporaryDirectoryPath()

static std::wstring fml::GetTemporaryDirectoryPath ( )

static

Definition at line 64 of file file_win.cc.

                                              {
  wchar_t wchar_path[MAX_PATH];
  auto result_size = ::GetTempPath(MAX_PATH, wchar_path);
  if (result_size > 0) {
    return {wchar_path, result_size};
  }
  return {};
}

GetVlogVerbosity()

int fml::GetVlogVerbosity

(

)

Definition at line 212 of file logging.cc.

                       {
  return std::max(-1, kLogInfo - GetMinLogLevel());
}

HashCombine() [1/2]

constexpr std::size_t fml::HashCombine ( )

constexpr

Definition at line 25 of file hash_combine.h.

                                                {
  return 0xdabbad00;
}

HashCombine() [2/2]

template<class... Type>

constexpr std::size_t fml::HashCombine ( Type...  args )

constexpr

Definition at line 30 of file hash_combine.h.

                                                            {
  std::size_t seed = HashCombine();
  HashCombineSeed(seed, args...);
  return seed;
}

HashCombineSeed() [1/2]

template<class Type >

constexpr void fml::HashCombineSeed ( std::size_t &  seed, Type  arg  )

constexpr

Definition at line 13 of file hash_combine.h.

                                                          {
  seed ^= std::hash<Type>{}(arg) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

HashCombineSeed() [2/2]

template<class Type , class... Rest>

constexpr void fml::HashCombineSeed ( std::size_t &  seed, Type  arg, Rest...  other_args  )

constexpr

Definition at line 18 of file hash_combine.h.

                                                   {
  HashCombineSeed(seed, arg);
  HashCombineSeed(seed, other_args...);
}

HexEncode()

std::string fml::HexEncode

(

std::string_view

input

)

Definition at line 14 of file hex_codec.cc.

                                          {
  std::string result;
  result.reserve(input.size() * 2);
  for (char c : input) {
    uint8_t b = static_cast<uint8_t>(c);
    result.push_back(kEncoding[b >> 4]);
    result.push_back(kEncoding[b & 0xF]);
  }
  return result;
}

InitCPUInfo()

void fml::InitCPUInfo

(

size_t

cpu_count

)

Definition at line 26 of file cpu_affinity.cc.

                                   {
  std::vector<CpuIndexAndSpeed> cpu_speeds;
 
  for (auto i = 0u; i < cpu_count; i++) {
    auto path = "/sys/devices/system/cpu/cpu" + std::to_string(i) +
                "/cpufreq/cpuinfo_max_freq";
    auto speed = ReadIntFromFile(path);
    if (speed.has_value()) {
      cpu_speeds.push_back({.index = i, .speed = speed.value()});
    }
  }
  gCPUTracker = new CPUSpeedTracker(cpu_speeds);
}

InstallCrashHandler()

void fml::InstallCrashHandler

(

)

Definition at line 126 of file backtrace.cc.

                           {
#if FML_OS_WIN
  if (!IsDebuggerPresent()) {
    _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
    _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
  }
#endif
  auto exe_path = fml::paths::GetExecutablePath();
  if (exe_path.first) {
    absl::InitializeSymbolizer(exe_path.second.c_str());
  }
  ToggleSignalHandlers(true);
}

IsAbsolutePath()

static bool fml::IsAbsolutePath ( const char *  path )

static

Definition at line 37 of file file_win.cc.

                                             {
  if (path == nullptr || strlen(path) == 0) {
    return false;
  }
 
  auto wpath = Utf8ToWideString({path});
  if (wpath.empty()) {
    return false;
  }
 
  return ::PathIsRelative(wpath.c_str()) == FALSE;
}

IsCrashHandlingSupported()

bool fml::IsCrashHandlingSupported

(

)

Definition at line 140 of file backtrace.cc.

                                {
  return true;
}

IsDirectory() [1/2]

bool fml::IsDirectory	(	const fml::UniqueFD &	base_directory,
		const char *	path
	)

Definition at line 141 of file file_posix.cc.

                                                                      {
  UniqueFD file = OpenFileReadOnly(base_directory, path);
  return (file.is_valid() && IsDirectory(file));
}

IsDirectory() [2/2]

bool fml::IsDirectory

(

const fml::UniqueFD &

directory

)

Definition at line 127 of file file_posix.cc.

                                               {
  if (!directory.is_valid()) {
    return false;
  }
 
  struct stat stat_result = {};
 
  if (::fstat(directory.get(), &stat_result) != 0) {
    return false;
  }
 
  return S_ISDIR(stat_result.st_mode);
}

IsExecutable()

static bool fml::IsExecutable ( std::initializer_list< FileMapping::Protection >  protection_flags )

static

Definition at line 33 of file mapping_win.cc.

                                                                 {
  for (auto protection : protection_flags) {
    if (protection == FileMapping::Protection::kExecute) {
      return true;
    }
  }
  return false;
}

IsFile()

bool fml::IsFile

(

const std::string &

path

)

Definition at line 146 of file file_posix.cc.

                                   {
  struct stat buf;
  if (stat(path.c_str(), &buf) != 0) {
    return false;
  }
 
  return S_ISREG(buf.st_mode);
}

IsPlatformVersionAtLeast()

bool fml::IsPlatformVersionAtLeast	(	size_t	major,
		size_t	minor = 0,
		size_t	patch = 0
	)

Definition at line 11 of file platform_version.mm.

                                                                        {
  const NSOperatingSystemVersion version = {
      .majorVersion = static_cast<NSInteger>(major),
      .minorVersion = static_cast<NSInteger>(minor),
      .patchVersion = static_cast<NSInteger>(patch),
  };
  return [[NSProcessInfo processInfo] isOperatingSystemAtLeastVersion:version];
}

IsWritable() [1/2]

static bool fml::IsWritable ( std::initializer_list< FileMapping::Protection >  protection_flags )

static

Definition at line 39 of file mapping_posix.cc.

                                                                 {
  for (auto protection : protection_flags) {
    if (protection == FileMapping::Protection::kWrite) {
      return true;
    }
  }
  return false;
}

IsWritable() [2/2]

static bool fml::IsWritable ( std::initializer_list< FileMapping::Protection >  protection_flags )

static

Definition at line 23 of file mapping_win.cc.

                                                                 {
  for (auto protection : protection_flags) {
    if (protection == FileMapping::Protection::kWrite) {
      return true;
    }
  }
  return false;
}

Join()

std::string fml::Join	(	const std::vector< std::string > &	vec,
		const char *	delim
	)

Definition at line 26 of file string_conversion.cc.

                                                                   {
  std::stringstream res;
  for (size_t i = 0; i < vec.size(); ++i) {
    res << vec[i];
    if (i < vec.size() - 1) {
      res << delim;
    }
  }
  return res.str();
}

KillProcess()

void fml::KillProcess

(

)

Definition at line 220 of file logging.cc.

                   {
  abort();
}

LittleEndianToArch()

template<typename T , class = std::enable_if_t<kIsByteSwappableV<T>>>

constexpr T fml::LittleEndianToArch ( T  n )

constexpr

Convert a known little endian value to match the endianness of the current architecture. The given value must be an integral type of size 1, 2, 4, or 8.

Definition at line 71 of file endianness.h.

                                    {
#if !FML_ARCH_CPU_LITTLE_ENDIAN
  return ByteSwap<T>(n);
#else
  return n;
#endif
}

MakeCopyable()

template<typename T >

internal::CopyableLambda< T > fml::MakeCopyable

(

T

lambda

)

Definition at line 57 of file make_copyable.h.

                                                 {
  return internal::CopyableLambda<T>(std::move(lambda));
}

MakeRefCounted()

template<typename T , typename... Args>

RefPtr< T > fml::MakeRefCounted

(

Args &&...

args

)

Definition at line 248 of file ref_ptr.h.

                                         {
  return internal::MakeRefCountedHelper<T>::MakeRefCounted(
      std::forward<Args>(args)...);
}

NanosSinceEpoch()

template<typename Clock , typename Duration >

static int64_t fml::NanosSinceEpoch ( std::chrono::time_point< Clock, Duration >  time_point )

static

Definition at line 39 of file time_point.cc.

                                                     {
  const auto elapsed = time_point.time_since_epoch();
  return std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count();
}

OpenDirectory() [1/2]

fml::UniqueFD fml::OpenDirectory	(	const char *	path,
		bool	create_if_necessary,
		FilePermission	permission
	)

Definition at line 97 of file file_posix.cc.

                                                       {
  return OpenDirectory(fml::UniqueFD{AT_FDCWD}, path, create_if_necessary,
                       permission);
}

OpenDirectory() [2/2]

fml::UniqueFD fml::OpenDirectory	(	const fml::UniqueFD &	base_directory,
		const char *	path,
		bool	create_if_necessary,
		FilePermission	permission
	)

Definition at line 104 of file file_posix.cc.

                                                       {
  if (path == nullptr) {
    return {};
  }
 
  if (create_if_necessary && !FileExists(base_directory, path)) {
    if (::mkdirat(base_directory.get(), path,
                  ToPosixCreateModeFlags(permission) | S_IXUSR) != 0) {
      return {};
    }
  }
 
  return fml::UniqueFD{FML_HANDLE_EINTR(
      ::openat(base_directory.get(), path, O_RDONLY | O_DIRECTORY))};
}

OpenDirectoryReadOnly()

fml::UniqueFD fml::OpenDirectoryReadOnly	(	const fml::UniqueFD &	base_directory,
		const char *	path
	)

Helper method that calls OpenDirectory with create_if_necessary = false and permission = kRead.

Definition at line 97 of file file.cc.

                                                      {
  return OpenDirectory(base_directory, path, false, FilePermission::kRead);
}

OpenFile() [1/2]

fml::UniqueFD fml::OpenFile	(	const char *	path,
		bool	create_if_necessary,
		FilePermission	permission
	)

This can open a directory on POSIX, but not on Windows.

Definition at line 66 of file file_posix.cc.

                                                  {
  return OpenFile(fml::UniqueFD{AT_FDCWD}, path, create_if_necessary,
                  permission);
}

OpenFile() [2/2]

fml::UniqueFD fml::OpenFile	(	const fml::UniqueFD &	base_directory,
		const char *	path,
		bool	create_if_necessary,
		FilePermission	permission
	)

This can open a directory on POSIX, but not on Windows.

Definition at line 73 of file file_posix.cc.

                                                  {
  TRACE_EVENT0("flutter", "fml::OpenFile");
  if (path == nullptr) {
    return {};
  }
 
  int flags = 0;
  int mode = 0;
 
  if (create_if_necessary && !FileExists(base_directory, path)) {
    flags = ToPosixAccessFlags(permission) | O_CREAT | O_TRUNC;
    mode = ToPosixCreateModeFlags(permission);
  } else {
    flags = ToPosixAccessFlags(permission);
    mode = 0;  // Not creating since it already exists.
  }
 
  return fml::UniqueFD{
      FML_HANDLE_EINTR(::openat(base_directory.get(), path, flags, mode))};
}

OpenFileReadOnly()

fml::UniqueFD fml::OpenFileReadOnly	(	const fml::UniqueFD &	base_directory,
		const char *	path
	)

Helper method that calls OpenFile with create_if_necessary = false and permission = kRead.

This can open a directory on POSIX, but not on Windows.

Definition at line 92 of file file.cc.

                                                 {
  return OpenFile(base_directory, path, false, FilePermission::kRead);
}

operator!=() [1/3]

template<class C >

bool fml::operator!=	(	C	p1,
		const scoped_nsprotocol< C > &	p2
	)

Definition at line 147 of file scoped_nsobject.h.

                                                      {
  return p1 != p2.get();
}

operator!=() [2/3]

template<class T , class Traits >

bool fml::operator!=	(	const T &	value,
		const UniqueObject< T, Traits > &	object
	)

Definition at line 131 of file unique_object.h.

                                                                       {
  return !(value == object.get());
}

operator!=() [3/3]

bool fml::operator!=	(	NST	p1,
		const WeakNSProtocol< NST > &	p2
	)

Definition at line 188 of file weak_nsobject.h.

                                                       {
  return p1 != p2.get();
}

operator==() [1/3]

template<class C >

bool fml::operator==	(	C	p1,
		const scoped_nsprotocol< C > &	p2
	)

Definition at line 142 of file scoped_nsobject.h.

                                                      {
  return p1 == p2.get();
}

operator==() [2/3]

template<class T , class Traits >

bool fml::operator==	(	const T &	value,
		const UniqueObject< T, Traits > &	object
	)

Definition at line 126 of file unique_object.h.

                                                                       {
  return value == object.get();
}

operator==() [3/3]

bool fml::operator==	(	NST	p1,
		const WeakNSProtocol< NST > &	p2
	)

Definition at line 183 of file weak_nsobject.h.

                                                       {
  return p1 == p2.get();
}

RangeForCharacterAtIndex()

NSRange fml::RangeForCharacterAtIndex	(	NSString *	text,
		NSUInteger	index
	)

Definition at line 9 of file string_range_sanitization.mm.

                                                                   {
  if (text == nil || index > text.length) {
    return NSMakeRange(NSNotFound, 0);
  }
  if (index < text.length) {
    return [text rangeOfComposedCharacterSequenceAtIndex:index];
  }
  return NSMakeRange(index, 0);
}

RangeForCharactersInRange()

NSRange fml::RangeForCharactersInRange	(	NSString *	text,
		NSRange	range
	)

Definition at line 19 of file string_range_sanitization.mm.

                                                                 {
  if (text == nil || range.location + range.length > text.length) {
    return NSMakeRange(NSNotFound, 0);
  }
  NSRange sanitizedRange = [text rangeOfComposedCharacterSequencesForRange:range];
  // We don't want to override the length, we just want to make sure we don't
  // select into the middle of a multi-byte character. Taking the
  // `sanitizedRange`'s length will end up altering the actual selection.
  return NSMakeRange(sanitizedRange.location, range.length);
}

ReadIntFromFile()

std::optional< int64_t > fml::ReadIntFromFile

(

const std::string &

path

)

Note

Visible for testing.

Definition at line 86 of file cpu_affinity.cc.

                                                            {
  std::ifstream file;
  file.open(path.c_str());
 
  // Dont use stoi because if this data isnt a parseable number then it
  // will abort, as we compile with exceptions disabled.
  int64_t speed = 0;
  file >> speed;
  if (speed > 0) {
    return speed;
  }
  return std::nullopt;
}

Ref()

template<typename T >

RefPtr< T > fml::Ref ( T *  ptr )

inline

Definition at line 237 of file ref_ptr.h.

                             {
  return RefPtr<T>(ptr);
}

RefreshRateToFrameBudget()

template<typename T >

Milliseconds fml::RefreshRateToFrameBudget

(

T

refresh_rate

)

Definition at line 24 of file time_delta.h.

                                                      {
  return Milliseconds(1s) / refresh_rate;
}

RemoveDirectoryRecursively()

bool fml::RemoveDirectoryRecursively	(	const fml::UniqueFD &	parent,
		const char *	directory_name
	)

Helper method to recursively remove files and subdirectories inside the directory. The directory itself will also be removed.

Return true if and only if all files have been successfully removed.

Definition at line 120 of file file.cc.

                                                            {
  auto dir = fml::OpenDirectory(parent, directory_name, false,
                                fml::FilePermission::kReadWrite);
  return RemoveFilesInDirectory(dir) && UnlinkDirectory(parent, directory_name);
}

RemoveFilesInDirectory()

bool fml::RemoveFilesInDirectory

(

const fml::UniqueFD &

directory

)

Helper method to recursively remove files and subdirectories inside the directory. The directory itself will not be removed.

Return true if and only if all files have been successfully removed.

Definition at line 102 of file file.cc.

                                                          {
  fml::FileVisitor recursive_cleanup = [&recursive_cleanup](
                                           const fml::UniqueFD& directory,
                                           const std::string& filename) {
    bool removed;
    if (fml::IsDirectory(directory, filename.c_str())) {
      fml::UniqueFD sub_dir =
          OpenDirectoryReadOnly(directory, filename.c_str());
      removed = VisitFiles(sub_dir, recursive_cleanup) &&
                fml::UnlinkDirectory(directory, filename.c_str());
    } else {
      removed = fml::UnlinkFile(directory, filename.c_str());
    }
    return removed;
  };
  return VisitFiles(directory, recursive_cleanup);
}

RequestAffinity()

bool fml::RequestAffinity

(

CpuAffinity

affinity

)

Request the given affinity for the current thread.

   Returns true if successfull, or if it was a no-op. This function is
   only supported on Android devices.

   Affinity requests are based on documented CPU speed. This speed data
   is parsed from cpuinfo_max_freq files, see also:
   https://www.kernel.org/doc/Documentation/cpu-freq/user-guide.txt 

Definition at line 26 of file cpu_affinity.cc.

                                           {
#ifdef FML_OS_ANDROID
  return AndroidRequestAffinity(affinity);
#else
  return true;
#endif
}

SetLogSettings()

void fml::SetLogSettings

(

const LogSettings &

settings

)

Definition at line 26 of file log_settings.cc.

                                                 {
  // Validate the new settings as we set them.
  state::g_log_settings.min_log_level =
      std::min(kLogFatal, settings.min_log_level);
}

SetThreadName()

void fml::SetThreadName

(

const std::string &

name

)

Definition at line 104 of file thread.cc.

                                          {
  if (name == "") {
    return;
  }
#if defined(FML_OS_MACOSX)
  pthread_setname_np(name.c_str());
#elif defined(FML_OS_LINUX) || defined(FML_OS_ANDROID)
  // Linux thread names are limited to 16 characters including the terminating
  // null.
  constexpr std::string::size_type kLinuxMaxThreadNameLen = 15;
  pthread_setname_np(pthread_self(),
                     name.substr(0, kLinuxMaxThreadNameLen).c_str());
#elif defined(FML_OS_WIN)
  THREADNAME_INFO info;
  info.dwType = 0x1000;
  info.szName = name.c_str();
  info.dwThreadID = GetCurrentThreadId();
  info.dwFlags = 0;
  __try {
    RaiseException(kVCThreadNameException, 0, sizeof(info) / sizeof(DWORD),
                   reinterpret_cast<DWORD_PTR*>(&info));
  } __except (EXCEPTION_CONTINUE_EXECUTION) {
  }
#elif defined(OS_FUCHSIA)
  zx::thread::self()->set_property(ZX_PROP_NAME, name.c_str(), name.size());
#else
  FML_DLOG(INFO) << "Could not set the thread name to '" << name
                 << "' on this platform.";
#endif
}

SetUpCPUTracker()

bool fml::SetUpCPUTracker

(

)

Definition at line 40 of file cpu_affinity.cc.

                       {
  // Populate CPU Info if uninitialized.
  auto count = std::thread::hardware_concurrency();
  std::call_once(gCPUTrackerFlag, [count]() { InitCPUInfo(count); });
  if (gCPUTracker == nullptr || !gCPUTracker->IsValid()) {
    return false;
  }
  return true;
}

ShouldCreateLogMessage()

bool fml::ShouldCreateLogMessage

(

LogSeverity

severity

)

Definition at line 216 of file logging.cc.

                                                  {
  return severity >= GetMinLogLevel();
}

SignalHandler()

static void fml::SignalHandler ( int  signal )

static

Definition at line 101 of file backtrace.cc.

                                      {
  // We are a crash signal handler. This can only happen once. Since we don't
  // want to catch crashes while we are generating the crash reports, disable
  // all set signal handlers to their default values before reporting the crash
  // and re-raising the signal.
  ToggleSignalHandlers(false);
 
  FML_LOG(ERROR) << "Caught signal " << SignalNameToString(signal)
                 << " during program execution." << std::endl
                 << BacktraceHere(3);
 
  ::raise(signal);
}

SignalNameToString()

static std::string fml::SignalNameToString ( int  signal )

static

Definition at line 75 of file backtrace.cc.

                                                {
  switch (signal) {
    case SIGABRT:
      return "SIGABRT";
    case SIGFPE:
      return "SIGFPE";
    case SIGSEGV:
      return "SIGSEGV";
    case SIGTERM:
      return "SIGTERM";
#if !FML_OS_WIN
    case SIGBUS:
      return "SIGBUS";
    case SIGSYS:
      return "SIGSYS";
    case SIGPIPE:
      return "SIGPIPE";
    case SIGALRM:
      return "SIGALRM";
#endif  // !FML_OS_WIN
  };
  return std::to_string(signal);
}

size()

template<typename T , std::size_t N>

constexpr std::size_t fml::size ( T(&)  array[N] )

constexpr

Definition at line 13 of file size.h.

                                        {
  return N;
}

strdup()

char * fml::strdup

(

const char *

str1

)

Definition at line 11 of file posix_wrappers_posix.cc.

                               {
  return ::strdup(str1);
}

swap() [1/2]

template<class T , class Traits >

void fml::swap	(	const UniqueObject< T, Traits > &	a,
		const UniqueObject< T, Traits > &	b
	)

Definition at line 121 of file unique_object.h.

                                                                              {
  a.swap(b);
}

swap() [2/2]

template<class C >

void fml::swap	(	scoped_nsprotocol< C > &	p1,
		scoped_nsprotocol< C > &	p2
	)

Definition at line 137 of file scoped_nsobject.h.

                                                              {
  p1.swap(p2);
}

TEST() [1/9]

fml::TEST	(	CountDownLatchTest	,
		CanWait
	)

Definition at line 21 of file count_down_latch_unittests.cc.

                                  {
  fml::Thread thread("test_thread");
  const size_t count = 100;
  size_t current_count = 0;
  CountDownLatch latch(count);
  auto decrement_latch_on_thread = [runner = thread.GetTaskRunner(), &latch,
                                    &current_count]() {
    runner->PostTask([&latch, &current_count]() {
      std::this_thread::sleep_for(std::chrono::microseconds(100));
      current_count++;
      latch.CountDown();
    });
  };
  for (size_t i = 0; i < count; ++i) {
    decrement_latch_on_thread();
  }
  latch.Wait();
  ASSERT_EQ(current_count, count);
}

TEST() [2/9]

fml::TEST	(	CountDownLatchTest	,
		CanWaitOnZero
	)

Definition at line 16 of file count_down_latch_unittests.cc.

                                        {
  CountDownLatch latch(0);
  latch.Wait();
}

TEST() [3/9]

fml::TEST	(	MallocMapping	,
		Copy
	)

Definition at line 36 of file mapping_unittests.cc.

                          {
  size_t length = 10;
  MallocMapping mapping(reinterpret_cast<uint8_t*>(malloc(length)), length);
  memset(const_cast<uint8_t*>(mapping.GetMapping()), 0xac, mapping.GetSize());
  MallocMapping copied =
      MallocMapping::Copy(mapping.GetMapping(), mapping.GetSize());
 
  ASSERT_NE(mapping.GetMapping(), copied.GetMapping());
  ASSERT_EQ(mapping.GetSize(), copied.GetSize());
  ASSERT_EQ(
      0, memcmp(mapping.GetMapping(), copied.GetMapping(), mapping.GetSize()));
}

TEST() [4/9]

fml::TEST	(	MallocMapping	,
		CopySizeZero
	)

Definition at line 64 of file mapping_unittests.cc.

                                  {
  char ch = 'a';
  MallocMapping mapping = MallocMapping::Copy(&ch, &ch);
  ASSERT_EQ(0u, mapping.GetSize());
}

TEST() [5/9]

fml::TEST	(	MallocMapping	,
		EmptyContructor
	)

Definition at line 10 of file mapping_unittests.cc.

                                     {
  MallocMapping mapping;
  ASSERT_EQ(nullptr, mapping.GetMapping());
  ASSERT_EQ(0u, mapping.GetSize());
}

TEST() [6/9]

fml::TEST	(	MallocMapping	,
		IsDontNeedSafe
	)

Definition at line 57 of file mapping_unittests.cc.

                                    {
  size_t length = 10;
  MallocMapping mapping(reinterpret_cast<uint8_t*>(malloc(length)), length);
  ASSERT_NE(nullptr, mapping.GetMapping());
  ASSERT_FALSE(mapping.IsDontNeedSafe());
}

TEST() [7/9]

fml::TEST	(	MallocMapping	,
		MoveConstructor
	)

Definition at line 23 of file mapping_unittests.cc.

                                     {
  size_t length = 10;
  MallocMapping mapping(reinterpret_cast<uint8_t*>(malloc(length)), length);
  MallocMapping moved = std::move(mapping);
 
  ASSERT_EQ(nullptr,
            mapping.GetMapping());  // NOLINT(clang-analyzer-cplusplus.Move,
                                    // bugprone-use-after-move)
  ASSERT_EQ(0u, mapping.GetSize());
  ASSERT_NE(nullptr, moved.GetMapping());
  ASSERT_EQ(length, moved.GetSize());
}

TEST() [8/9]

fml::TEST	(	MallocMapping	,
		NotEmptyContructor
	)

Definition at line 16 of file mapping_unittests.cc.

                                        {
  size_t length = 10;
  MallocMapping mapping(reinterpret_cast<uint8_t*>(malloc(length)), length);
  ASSERT_NE(nullptr, mapping.GetMapping());
  ASSERT_EQ(length, mapping.GetSize());
}

TEST() [9/9]

fml::TEST	(	MallocMapping	,
		Release
	)

Definition at line 49 of file mapping_unittests.cc.

                             {
  size_t length = 10;
  MallocMapping mapping(reinterpret_cast<uint8_t*>(malloc(length)), length);
  free(const_cast<uint8_t*>(mapping.Release()));
  ASSERT_EQ(nullptr, mapping.GetMapping());
  ASSERT_EQ(0u, mapping.GetSize());
}

TimerDrain()

bool fml::TimerDrain

(

int

fd

)

Drains the timer FD and returns true if it has expired. This may be false in case the timer read is non-blocking and this routine was called before the timer expiry.

Definition at line 59 of file timerfd.cc.

                        {
  // 8 bytes must be read from a signaled timer file descriptor when signaled.
  uint64_t fire_count = 0;
  ssize_t size = FML_HANDLE_EINTR(::read(fd, &fire_count, sizeof(uint64_t)));
  if (size != sizeof(uint64_t)) {
    return false;
  }
  return fire_count > 0;
}

TimerRearm()

bool fml::TimerRearm	(	int	fd,
		fml::TimePoint	time_point
	)

Rearms the timer to expire at the given time point.

Definition at line 38 of file timerfd.cc.

                                                 {
  uint64_t nano_secs = time_point.ToEpochDelta().ToNanoseconds();
 
  // "0" will disarm the timer, desired behavior is to immediately
  // trigger the timer.
  if (nano_secs < 1) {
    nano_secs = 1;
  }
 
  struct itimerspec spec = {};
  spec.it_value.tv_sec = static_cast<time_t>(nano_secs / NSEC_PER_SEC);
  spec.it_value.tv_nsec = nano_secs % NSEC_PER_SEC;
  spec.it_interval = spec.it_value;  // single expiry.
 
  int result = ::timerfd_settime(fd, TFD_TIMER_ABSTIME, &spec, nullptr);
  if (result != 0) {
    FML_DLOG(ERROR) << "timerfd_settime err:" << strerror(errno);
  }
  return result == 0;
}

ToggleSignalHandlers()

static void fml::ToggleSignalHandlers ( bool  set )

static

Definition at line 115 of file backtrace.cc.

                                           {
  for (size_t i = 0; i < sizeof(kKnownSignalHandlers) / sizeof(size_t); ++i) {
    auto signal_name = kKnownSignalHandlers[i];
    auto handler = set ? &SignalHandler : SIG_DFL;
 
    if (::signal(signal_name, handler) == SIG_ERR) {
      FML_LOG(ERROR) << "Could not attach signal handler for " << signal_name;
    }
  }
}

ToPosixAccessFlags()

static int fml::ToPosixAccessFlags ( FilePermission  permission )

static

Definition at line 34 of file file_posix.cc.

                                                         {
  int flags = 0;
  switch (permission) {
    case FilePermission::kRead:
      flags |= O_RDONLY;  // read only
      break;
    case FilePermission::kWrite:
      flags |= O_WRONLY;  // write only
      break;
    case FilePermission::kReadWrite:
      flags |= O_RDWR;  // read-write
      break;
  }
  return flags;
}

ToPosixCreateModeFlags()

static int fml::ToPosixCreateModeFlags ( FilePermission  permission )

static

Definition at line 50 of file file_posix.cc.

                                                             {
  int mode = 0;
  switch (permission) {
    case FilePermission::kRead:
      mode |= S_IRUSR;
      break;
    case FilePermission::kWrite:
      mode |= S_IWUSR;
      break;
    case FilePermission::kReadWrite:
      mode |= S_IRUSR | S_IWUSR;
      break;
  }
  return mode;
}

ToPosixProtectionFlags()

static int fml::ToPosixProtectionFlags ( std::initializer_list< FileMapping::Protection >  protection_flags )

static

Definition at line 20 of file mapping_posix.cc.

                                                                 {
  int flags = 0;
  for (auto protection : protection_flags) {
    switch (protection) {
      case FileMapping::Protection::kRead:
        flags |= PROT_READ;
        break;
      case FileMapping::Protection::kWrite:
        flags |= PROT_WRITE;
        break;
      case FileMapping::Protection::kExecute:
        flags |= PROT_READ | PROT_EXEC;
        break;
    }
  }
  return flags;
}

TruncateFile()

bool fml::TruncateFile	(	const fml::UniqueFD &	file,
		size_t	size
	)

Definition at line 155 of file file_posix.cc.

                                                        {
  if (!file.is_valid()) {
    return false;
  }
 
  return ::ftruncate(file.get(), size) == 0;
}

UnlinkDirectory() [1/2]

bool fml::UnlinkDirectory

(

const char *

path

)

Definition at line 163 of file file_posix.cc.

                                       {
  return UnlinkDirectory(fml::UniqueFD{AT_FDCWD}, path);
}

UnlinkDirectory() [2/2]

bool fml::UnlinkDirectory	(	const fml::UniqueFD &	base_directory,
		const char *	path
	)

Definition at line 167 of file file_posix.cc.

                                                                          {
  return ::unlinkat(base_directory.get(), path, AT_REMOVEDIR) == 0;
}

UnlinkFile() [1/2]

bool fml::UnlinkFile

(

const char *

path

)

Definition at line 171 of file file_posix.cc.

                                  {
  return UnlinkFile(fml::UniqueFD{AT_FDCWD}, path);
}

UnlinkFile() [2/2]

bool fml::UnlinkFile	(	const fml::UniqueFD &	base_directory,
		const char *	path
	)

Definition at line 175 of file file_posix.cc.

                                                                     {
  int code = ::unlinkat(base_directory.get(), path, 0);
  if (code != 0) {
    FML_DLOG(ERROR) << strerror(errno);
  }
  return code == 0;
}

Utf16ToUtf8()

std::string fml::Utf16ToUtf8

(

const std::u16string_view

string

)

Definition at line 37 of file string_conversion.cc.

                                                      {
  Utf16StringConverter converter;
  return converter.to_bytes(string.data());
}

Utf16ToWideString()

std::wstring fml::Utf16ToWideString

(

const std::u16string_view

str

)

Definition at line 32 of file wstring_conversion.cc.

                                                          {
  static_assert(sizeof(std::wstring::value_type) ==
                sizeof(std::u16string::value_type));
  return {begin(str), end(str)};
}

Utf8ToUtf16()

std::u16string fml::Utf8ToUtf16

(

const std::string_view

string

)

Definition at line 42 of file string_conversion.cc.

                                                      {
  Utf16StringConverter converter;
  return converter.from_bytes(string.data());
}

Utf8ToWideString()

std::wstring fml::Utf8ToWideString

(

const std::string_view

str

)

Definition at line 21 of file wstring_conversion.cc.

                                                      {
  WideStringConverter converter;
  return converter.from_bytes(str.data());
}

VisitFiles()

bool fml::VisitFiles	(	const fml::UniqueFD &	directory,
		const FileVisitor &	visitor
	)

Call visitor on all files inside the directory non-recursively. The trivial file "." and ".." will not be visited.

Return false if and only if the visitor returns false during the traversal.

If recursive visiting is needed, call VisitFiles inside the visitor, or use our helper method VisitFilesRecursively.

See also

VisitFilesRecursively.

Note

Procedure doesn't copy all closures.

Definition at line 236 of file file_posix.cc.

                                                                          {
  fml::UniqueFD dup_fd(dup(directory.get()));
  if (!dup_fd.is_valid()) {
    FML_DLOG(ERROR) << "Can't dup the directory fd. Error: " << strerror(errno);
    return true;  // continue to visit other files
  }
 
  fml::UniqueDir dir(::fdopendir(dup_fd.get()));
  if (!dir.is_valid()) {
    FML_DLOG(ERROR) << "Can't open the directory. Error: " << strerror(errno);
    return true;  // continue to visit other files
  }
 
  // The directory fd will be closed by `closedir`.
  (void)dup_fd.release();
 
  // Without `rewinddir`, `readir` will directly return NULL (end of dir is
  // reached) after a previuos `VisitFiles` call for the same `const
  // fml::UniqueFd& directory`.
  rewinddir(dir.get());
  while (dirent* ent = readdir(dir.get())) {
    std::string filename = ent->d_name;
    if (filename != "." && filename != "..") {
      if (!visitor(directory, filename)) {
        return false;
      }
    }
  }
 
  return true;
}

VisitFilesRecursively()

bool fml::VisitFilesRecursively	(	const fml::UniqueFD &	directory,
		const FileVisitor &	visitor
	)

Recursively call visitor on all files inside the directory. Return false if and only if the visitor returns false during the traversal.

This is a helper method that wraps the general VisitFiles method. The VisitFiles is strictly more powerful as it has the access of the recursion stack to the file. For example, VisitFiles may be able to maintain a vector of directory names that lead to a file. That could be useful to compute the relative path between the root directory and the visited file.

See also

VisitFiles.

Note

Procedure doesn't copy all closures.

Definition at line 71 of file file.cc.

                                                       {
  FileVisitor recursive_visitor = [&recursive_visitor, &visitor](
                                      const UniqueFD& directory,
                                      const std::string& filename) {
    if (!visitor(directory, filename)) {
      return false;
    }
    if (IsDirectory(directory, filename.c_str())) {
      UniqueFD sub_dir = OpenDirectoryReadOnly(directory, filename.c_str());
      if (!sub_dir.is_valid()) {
        FML_LOG(ERROR) << "Can't open sub-directory: " << filename;
        return true;
      }
      return VisitFiles(sub_dir, recursive_visitor);
    }
    return true;
  };
  return VisitFiles(directory, recursive_visitor);
}

WaitWithTimeoutImpl()

template<typename ConditionFn >

bool fml::WaitWithTimeoutImpl	(	std::unique_lock< std::mutex > *	locker,
		std::condition_variable *	cv,
		ConditionFn	condition,
		TimeDelta	timeout
	)

Definition at line 20 of file waitable_event.cc.

                                            {
  FML_DCHECK(locker->owns_lock());
 
  if (condition()) {
    return false;
  }
 
  // We may get spurious wakeups.
  TimeDelta wait_remaining = timeout;
  TimePoint start = TimePoint::Now();
  while (true) {
    if (std::cv_status::timeout ==
        cv->wait_for(*locker, std::chrono::nanoseconds(
                                  wait_remaining.ToNanoseconds()))) {
      return true;  // Definitely timed out.
    }
 
    // We may have been awoken.
    if (condition()) {
      return false;
    }
 
    // Or the wakeup may have been spurious.
    TimePoint now = TimePoint::Now();
    FML_DCHECK(now >= start);
    TimeDelta elapsed = now - start;
    // It's possible that we may have timed out anyway.
    if (elapsed >= timeout) {
      return true;
    }
 
    // Otherwise, recalculate the amount that we have left to wait.
    wait_remaining = timeout - elapsed;
  }
}

WideStringToUtf16()

std::u16string fml::WideStringToUtf16

(

const std::wstring_view

str

)

Definition at line 26 of file wstring_conversion.cc.

                                                          {
  static_assert(sizeof(std::wstring::value_type) ==
                sizeof(std::u16string::value_type));
  return {begin(str), end(str)};
}

WideStringToUtf8()

std::string fml::WideStringToUtf8

(

const std::wstring_view

str

)

Definition at line 16 of file wstring_conversion.cc.

                                                      {
  WideStringConverter converter;
  return converter.to_bytes(str.data());
}

WriteAtomically()

bool fml::WriteAtomically	(	const fml::UniqueFD &	base_directory,
		const char *	file_name,
		const Mapping &	mapping
	)

Definition at line 191 of file file_posix.cc.

                                          {
  if (file_name == nullptr || data.GetMapping() == nullptr) {
    return false;
  }
 
  std::stringstream stream;
  stream << file_name << ".temp";
  const auto temp_file_name = stream.str();
 
  auto temp_file = OpenFile(base_directory, temp_file_name.c_str(), true,
                            FilePermission::kReadWrite);
  if (!temp_file.is_valid()) {
    return false;
  }
 
  if (!TruncateFile(temp_file, data.GetSize())) {
    return false;
  }
 
  ssize_t remaining = data.GetSize();
  ssize_t written = 0;
  ssize_t offset = 0;
 
  while (remaining > 0) {
    written = FML_HANDLE_EINTR(
        ::write(temp_file.get(), data.GetMapping() + offset, remaining));
 
    if (written == -1) {
      return false;
    }
 
    remaining -= written;
    offset += written;
  }
 
  if (::fsync(temp_file.get()) != 0) {
    return false;
  }
 
  return ::renameat(base_directory.get(), temp_file_name.c_str(),
                    base_directory.get(), file_name) == 0;
}

Variable Documentation

gCPUTracker

CPUSpeedTracker* fml::gCPUTracker

static

Definition at line 21 of file cpu_affinity.cc.

gCPUTrackerFlag

std::once_flag fml::gCPUTrackerFlag

The CPUSpeedTracker is initialized once the first time a thread affinity is requested.

Definition at line 20 of file cpu_affinity.cc.

kClockType [1/2]

constexpr int fml::kClockType = CLOCK_MONOTONIC

staticconstexpr

Definition at line 14 of file message_loop_android.cc.

kClockType [2/2]

constexpr int fml::kClockType = CLOCK_MONOTONIC

staticconstexpr

Definition at line 15 of file message_loop_linux.cc.

kDecodeMap

constexpr signed char fml::kDecodeMap[]

staticconstexpr

Initial value:

= {
    
    26, 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25}

Definition at line 46 of file base32.cc.

kDecodeMapSize

constexpr int fml::kDecodeMapSize

staticconstexpr

Initial value:

=
    sizeof(kDecodeMap) / sizeof(kDecodeMap[0])

Definition at line 52 of file base32.cc.

kDefaultFrameBudget

constexpr Milliseconds fml::kDefaultFrameBudget = Milliseconds(1s) / 60

constexpr

Definition at line 21 of file time_delta.h.

kDistantFuture

constexpr CFTimeInterval fml::kDistantFuture = 1.0e10

staticconstexpr

Definition at line 14 of file message_loop_darwin.mm.

kEncoding [1/2]

constexpr char fml::kEncoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"

staticconstexpr

Definition at line 13 of file base32.cc.

kEncoding [2/2]

constexpr char fml::kEncoding[] = "0123456789abcdef"

staticconstexpr

Definition at line 12 of file hex_codec.cc.

kIsByteSwappableV

template<typename T >

constexpr bool fml::kIsByteSwappableV = IsByteSwappable<T>::value

constexpr

Definition at line 35 of file endianness.h.

kKnownSignalHandlers

size_t fml::kKnownSignalHandlers[]

static

Initial value:

= {
    SIGABRT,  
    SIGFPE,   
    SIGTERM,  
    SIGSEGV,  
 
    SIGBUS,   
    SIGSYS,   
    SIGPIPE,  
    SIGALRM,  
 
}

Definition at line 62 of file backtrace.cc.

kKUnknownFrameName [1/2]

std::string fml::kKUnknownFrameName = "Unknown"

static

Definition at line 25 of file backtrace.cc.

kKUnknownFrameName [2/2]

std::string fml::kKUnknownFrameName = "Unknown"

static

Definition at line 9 of file backtrace_stub.cc.

kLogDFatal

const LogSeverity fml::kLogDFatal = kLogFatal

Definition at line 58 of file log_level.h.

kLogError

constexpr LogSeverity fml::kLogError = 2

constexpr

Definition at line 15 of file log_level.h.

kLogFatal

constexpr LogSeverity fml::kLogFatal = 4

constexpr

Definition at line 19 of file log_level.h.

kLogImportant

constexpr LogSeverity fml::kLogImportant = 3

constexpr

Definition at line 18 of file log_level.h.

kLogInfo

constexpr LogSeverity fml::kLogInfo = 0

constexpr

Definition at line 13 of file log_level.h.

kLogNumSeverities

constexpr LogSeverity fml::kLogNumSeverities = 5

constexpr

Definition at line 20 of file log_level.h.

kLogWarning

constexpr LogSeverity fml::kLogWarning = 1

constexpr

Definition at line 14 of file log_level.h.

kUnmerged

const TaskQueueId fml::kUnmerged = TaskQueueId(TaskQueueId::kUnmerged)

static

Definition at line 25 of file message_loop_task_queues.h.

LOG_DFATAL

const LogSeverity fml::LOG_DFATAL = kLogDFatal

Definition at line 64 of file log_level.h.

LOG_ERROR

constexpr LogSeverity fml::LOG_ERROR = kLogError

constexpr

Definition at line 35 of file log_level.h.

LOG_FATAL

constexpr LogSeverity fml::LOG_FATAL = kLogFatal

constexpr

Definition at line 45 of file log_level.h.

LOG_IMPORTANT

constexpr LogSeverity fml::LOG_IMPORTANT = kLogImportant

constexpr

Definition at line 40 of file log_level.h.

LOG_INFO

constexpr LogSeverity fml::LOG_INFO = kLogInfo

constexpr

Definition at line 25 of file log_level.h.

LOG_WARNING

constexpr LogSeverity fml::LOG_WARNING = kLogWarning

constexpr

Definition at line 30 of file log_level.h.

tls_message_loop

thread_local std::unique_ptr<MessageLoop> fml::tls_message_loop

static

Definition at line 17 of file message_loop.cc.

tls_task_source_grade

thread_local std::unique_ptr<TaskSourceGradeHolder> fml::tls_task_source_grade

static

Definition at line 35 of file message_loop_task_queues.cc.

tTaskObservers

thread_local std::map<intptr_t, fit::closure> fml::tTaskObservers

Definition at line 11 of file task_observers.cc.