fml Namespace Reference

Namespaces
namespace	benchmarking
namespace	icu
namespace	internal
namespace	jni
namespace	paths
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
struct	CFRefTestState
struct	CFRefTraits
	Default retain and release implementations for CFRef. More...
struct	CFRefTraits< CFRefTestState * >
struct	CFRefTraits< CGImageRef >
	fml::CFRef retain and release implementations for CGImageRef. More...
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	ScopedCleanupClosure
	Wraps a closure that is invoked in the destructor unless released by the caller. More...
class	ScopedNSAutoreleasePool
class	ScopedSetLogSettings
class	ScopedTemporaryDirectory
class	Semaphore
	A traditional counting semaphore. Waits decrement the counter and Signal increments it. More...
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
struct	UniqueLooperTraits
class	UniqueObject
class	Wakeable
class	WeakPtr
class	WeakPtrFactory

Concepts
concept	UniqueObjectTraits

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
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 ,   kNotEfficiency }
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, const std::function< bool(typename Collection::iterator)> &predicate)
std::optional< size_t >	EfficiencyCoreCount ()
	Request count of efficiency cores.
bool	RequestAffinity (CpuAffinity affinity)
	Request the given affinity for the current thread.
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.
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.
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.
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.
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.
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, const Type &arg)
template<class Type , class... Rest>
constexpr void	HashCombineSeed (std::size_t &seed, const Type &arg, const Rest &... other_args)
constexpr std::size_t	HashCombine ()
template<class... Type>
constexpr std::size_t	HashCombine (const 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 ()
constexpr bool	ShouldCreateLogMessageConstexpr (LogSeverity severity, bool true_arg)
constexpr void	KillProcessConstexpr (bool true_arg)
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.
bool	AndroidRequestAffinity (CpuAffinity affinity)
	Android specific implementation of RequestAffinity.
static ALooper *	AcquireLooperForThread ()
bool	IsPlatformVersionAtLeast (size_t major, size_t minor=0, size_t patch=0)
NSRange	RangeForCharacterAtIndex (NSString *text, NSUInteger index)
NSRange	RangeForCharactersInRange (NSString *text, NSRange range)
void	ExecuteAfterTaskObservers ()
fml::TaskQueueId	CurrentMessageLoopAddAfterTaskObserver (intptr_t key, fit::closure observer)
void	CurrentMessageLoopRemoveAfterTaskObserver (fml::TaskQueueId queue_id, intptr_t key)
bool	TimerRearm (int fd, fml::TimePoint time_point)
	Rearms the timer to expire at the given time point.
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)
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.

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.
kNotEfficiency	Request affinity for all non-efficiency cores.

Definition at line 18 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,
 
  /// @brief Request affinity for all non-efficiency cores.
  kNotEfficiency,
};

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 54 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 227 of file ref_ptr.h.

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

Referenced by FLUTTER_ASSERT_ARC::MockPlatformMessageResponse::Create(), flutter_runner::testing::FakePlatformMessageResponse::Create(), fml::NativeLibrary::Create(), fml::NativeLibrary::CreateForCurrentProcess(), and fml::NativeLibrary::CreateWithHandle().

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;
}

References FML_DCHECK, gCPUTracker, fml::CPUSpeedTracker::GetIndices(), kEfficiency, and SetUpCPUTracker().

Referenced by EfficiencyCoreCount().

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;
}

References gCPUTracker, fml::CPUSpeedTracker::GetIndices(), and SetUpCPUTracker().

Referenced by RequestAffinity().

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
}

Referenced by BacktraceHere().

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();
}

References Backtrace(), GetSymbolName(), and i.

Referenced by flutter::testing::ThreadCheckingAssetResolver::GetAsMapping(), SignalHandler(), and fml::testing::TEST().

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};
}

References input(), kDecodeMap, and kDecodeMapSize.

Referenced by flutter::ParseBase32(), TEST(), TEST(), and TEST().

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};
}

References input(), and kEncoding.

Referenced by TEST(), TEST(), and TEST().

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
}

Referenced by fml::testing::TEST().

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 static_cast<T>(FML_BYTESWAP_16((uint16_t)n));
  } else if constexpr (sizeof(T) == 4) {
    return static_cast<T>(FML_BYTESWAP_32((uint32_t)n));
  } else if constexpr (sizeof(T) == 8) {
    return static_cast<T>(FML_BYTESWAP_64((uint64_t)n));
  } else {
    static_assert(!sizeof(T), "Unsupported size");
  }
}

References FML_BYTESWAP_16, FML_BYTESWAP_32, and FML_BYTESWAP_64.

ChronoTicksSinceEpoch()

fml::TimePoint fml::ChronoTicksSinceEpoch

(

)

Definition at line 21 of file chrono_timestamp_provider.cc.

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

References fml::ChronoTimestampProvider::Instance(), and fml::ChronoTimestampProvider::Now().

Referenced by fml::testing::CountRemainingTasks(), TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), and fml::testing::TEST().

CommandLineFromArgcArgv()

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

inline

Definition at line 231 of file command_line.h.

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

References argv, and CommandLineFromIterators().

Referenced by CommandLineFromPlatformOrArgcArgv(), FlutterEngineInitialize(), main(), and flutter::testing::SetArgsForProcess().

CommandLineFromInitializerList()

template<typename StringType >

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

inline

Definition at line 252 of file command_line.h.

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

References argv, and CommandLineFromIterators().

Referenced by flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

CommandLineFromIterators()

template<typename InputIterator >

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

inline

Definition at line 202 of file command_line.h.

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

Referenced by CommandLineFromArgcArgv(), CommandLineFromInitializerList(), flutter::CommandLineFromNSProcessInfo(), and dart_runner::IsTestProgram().

CommandLineFromIteratorsFindFirstPositionalArg()

template<typename InputIterator >

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

inline

Definition at line 180 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();
}

References fml::internal::CommandLineBuilder::Build(), and fml::internal::CommandLineBuilder::ProcessArg().

CommandLineFromIteratorsWithArgv0()

template<typename InputIterator >

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

inline

Definition at line 212 of file command_line.h.

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

References fml::internal::CommandLineBuilder::Build(), and fml::internal::CommandLineBuilder::ProcessArg().

Referenced by impeller::compiler::testing::TEST().

CommandLineFromPlatform()

std::optional< CommandLine > fml::CommandLineFromPlatform

(

)

Definition at line 9 of file command_line_posix.cc.

                                                   {
  return std::nullopt;
}

Referenced by CommandLineFromPlatformOrArgcArgv().

CommandLineFromPlatformOrArgcArgv()

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

inline

Definition at line 240 of file command_line.h.

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

References argv, CommandLineFromArgcArgv(), and CommandLineFromPlatform().

Referenced by benchmarking::Main(), main(), main(), and main().

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;
}

References argv, fml::CommandLine::argv0(), fml::CommandLine::has_argv0(), fml::CommandLine::options(), and fml::CommandLine::positional_args().

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);
}

References CreateDirectory, and IsDirectory().

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);
}

References CreateDirectory, FML_DCHECK, and OpenDirectory().

Referenced by TEST(), TEST(), TEST(), impeller::compiler::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

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};
}

Referenced by TEST().

CurrentMessageLoopAddAfterTaskObserver()

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

Definition at line 19 of file task_observers.cc.

                                                                             {
  if (observer) {
    tTaskObservers[key] = std::move(observer);
  }
  return fml::TaskQueueId::Invalid();
}

References fml::TaskQueueId::Invalid(), key, and tTaskObservers.

CurrentMessageLoopRemoveAfterTaskObserver()

void fml::CurrentMessageLoopRemoveAfterTaskObserver	(	fml::TaskQueueId	queue_id,
		intptr_t	key
	)

Definition at line 27 of file task_observers.cc.

                                                             {
  tTaskObservers.erase(key);
}

References key, and tTaskObservers.

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))};
}

References FML_HANDLE_EINTR.

Referenced by flutter::RunConfiguration::InferFromSettings(), and flutter::RunTester().

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 19 of file cpu_affinity.cc.

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

References AndroidEfficiencyCoreCount().

Referenced by fml::testing::TEST().

erase_if()

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

void fml::erase_if	(	Collection &	container,
		const 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();
  }
}

References callback, and tTaskObservers.

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;
}

References fml::UniqueObject< T, Traits >::get(), and fml::UniqueObject< T, Traits >::is_valid().

Referenced by impeller::FindSwiftShaderICDAtKnownPaths(), OpenDirectory(), OpenFile(), TEST(), TEST(), TEST(), impeller::testing::TEST_P(), and impeller::testing::TEST_P().

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;
}

References GetFullHandlePath(), and IsAbsolutePath().

Referenced by GetFileAttributesForUtf8Path().

GetCurrentProcId()

int fml::GetCurrentProcId

(

)

Definition at line 9 of file process_posix.cc.

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

Referenced by impeller::compiler::testing::GetIntermediatesPath().

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;
}

References kRead, kReadWrite, and kWrite.

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());
}

References Utf8ToWideString().

Referenced by GetFileAttributesForUtf8Path().

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());
}

References GetAbsolutePath(), and GetFileAttributesForUtf8Path().

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});
}

References fml::UniqueObject< T, Traits >::get(), MAX_PATH, and WideStringToUtf8().

Referenced by GetAbsolutePath().

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());
}

References GetLastError(), message, and WideStringToUtf8().

GetLogSettings()

LogSettings fml::GetLogSettings

(

)

Definition at line 32 of file log_settings.cc.

                             {
  return state::g_log_settings;
}

References fml::state::g_log_settings.

Referenced by fml::ScopedSetLogSettings::ScopedSetLogSettings().

GetMinLogLevel()

int fml::GetMinLogLevel

(

)

Definition at line 36 of file log_settings.cc.

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

References fml::state::g_log_settings, and kLogFatal.

Referenced by GetVlogVerbosity(), ShouldCreateLogMessage(), fml::testing::TEST_F(), and fml::testing::TEST_F().

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;
}

References kRead, kReadWrite, and kWrite.

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;
}

References kKUnknownFrameName, and name.

Referenced by BacktraceHere().

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 {};
}

References MAX_PATH.

GetVlogVerbosity()

int fml::GetVlogVerbosity

(

)

Definition at line 212 of file logging.cc.

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

References GetMinLogLevel(), and kLogInfo.

HashCombine() [1/2]

constexpr std::size_t fml::HashCombine ( )

constexpr

Definition at line 25 of file hash_combine.h.

                                                {
  return 0xdabbad00;
}

Referenced by flutter::RasterCacheKeyID::GetHash(), impeller::DepthAttachmentDescriptor::GetHash(), impeller::StencilAttachmentDescriptor::GetHash(), impeller::ShaderStageIOSlot::GetHash(), impeller::ShaderStageBufferLayout::GetHash(), impeller::ImmutableSamplerKeyVK::GetHash(), impeller::ComputePipelineDescriptor::GetHash(), impeller::PipelineDescriptor::GetHash(), impeller::ShaderFunction::GetHash(), impeller::VertexDescriptor::GetHash(), impeller::Font::GetHash(), impeller::ColorAttachmentDescriptor::Hash(), impeller::RenderTargetConfig::Hash(), HashCombine(), std::hash< impeller::Font::Metrics >::operator()(), impeller::PipelineLibraryGLES::ProgramKey::Hash::operator()(), flutter::EmbedderExternalView::RenderTargetDescriptor::Hash::operator()(), impeller::ContentContext::RuntimeEffectPipelineKey::Hash::operator()(), impeller::ShaderKey::Hash::operator()(), impeller::ShaderArchive::ShaderKey::Hash::operator()(), impeller::TextShadowCache::TextShadowCacheKey::Hash::operator()(), flutter::EmbedderExternalView::ViewIdentifier::Hash::operator()(), impeller::YUVConversionDescriptorVKHash::operator()(), fml::testing::TEST(), and flutter::testing::TEST().

HashCombine() [2/2]

template<class... Type>

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

constexpr

Definition at line 30 of file hash_combine.h.

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

References args, HashCombine(), and HashCombineSeed().

HashCombineSeed() [1/2]

template<class Type >

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

constexpr

Definition at line 13 of file hash_combine.h.

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

Referenced by flutter::RasterCacheKeyID::GetHash(), impeller::ComputePipelineDescriptor::GetHash(), impeller::PipelineDescriptor::GetHash(), impeller::VertexDescriptor::GetHash(), HashCombine(), HashCombineSeed(), impeller::PipelineLibraryGLES::ProgramKey::Hash::operator()(), and impeller::YUVConversionDescriptorVKHash::operator()().

HashCombineSeed() [2/2]

template<class Type , class... Rest>

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

constexpr

Definition at line 18 of file hash_combine.h.

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

References HashCombineSeed().

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;
}

References input(), and kEncoding.

Referenced by flutter::PersistentCache::SkKeyToFilePath(), and TEST().

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);
}

References gCPUTracker, i, and ReadIntFromFile().

Referenced by SetUpCPUTracker().

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);
}

References fml::paths::GetExecutablePath(), and ToggleSignalHandlers().

Referenced by impeller::compiler::Main(), benchmarking::Main(), and main().

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;
}

References Utf8ToWideString().

Referenced by GetAbsolutePath().

IsCrashHandlingSupported()

bool fml::IsCrashHandlingSupported

(

)

Definition at line 140 of file backtrace.cc.

                                {
  return true;
}

Referenced by fml::testing::TEST().

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));
}

References fml::UniqueObject< T, Traits >::is_valid(), IsDirectory(), and OpenFileReadOnly().

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);
}

References fml::UniqueObject< T, Traits >::get(), and fml::UniqueObject< T, Traits >::is_valid().

Referenced by CreateDirectory(), flutter::DirectoryAssetBundle::DirectoryAssetBundle(), IsDirectory(), RemoveFilesInDirectory(), and VisitFilesRecursively().

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;
}

References fml::FileMapping::kExecute.

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);
}

Referenced by FlutterEngineCreateAOTData(), FlutterEngineInitialize(), flutter::testing::LoadELFSplitSymbolFromFixturesIfNeccessary(), flutter::testing::LoadELFSymbolFromFixturesIfNeccessary(), impeller::MTLShaderLibraryFromFilePaths(), flutter::testing::RunDartCodeInIsolateOnUITaskRunner(), TEST(), and TEST().

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;
}

References fml::FileMapping::kWrite.

Referenced by fml::FileMapping::FileMapping().

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;
}

References fml::FileMapping::kWrite.

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();
}

References i.

KillProcess()

void fml::KillProcess

(

)

Definition at line 220 of file logging.cc.

                   {
  abort();
}

Referenced by KillProcessConstexpr(), fml::testing::TEST(), fml::testing::UnreachableScopeWithoutReturnDoesNotMakeCompilerMad(), and fml::LogMessage::~LogMessage().

KillProcessConstexpr()

constexpr void fml::KillProcessConstexpr ( bool  true_arg )

constexpr

Definition at line 73 of file logging.h.

                                                                {
  if (true_arg) {
    KillProcess();
  }
#if defined(_MSC_VER) && !defined(__clang__)
  __assume(false);
#else   // defined(_MSC_VER) && !defined(__clang__)
  __builtin_unreachable();
#endif  // defined(_MSC_VER) && !defined(__clang__)
}

References KillProcess().

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
}

Referenced by fml::testing::TEST().

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));
}

Referenced by flutter::PlatformMessageResponseAndroid::Complete(), flutter::PlatformMessageResponseDarwin::Complete(), flutter::PlatformMessageResponseAndroid::CompleteEmpty(), flutter::PlatformMessageResponseDarwin::CompleteEmpty(), flutter::ImageDecoderSkia::Decode(), flutter::Picture::DoRasterizeToImage(), flutter::EncodeImage(), flutter::gpu::Context::GetDefaultContext(), flutter::MultiFrameCodec::getNextFrame(), flutter::testing::EmbedderTestContext::GetNextSceneImage(), flutter::PlatformViewEmbedder::EmbedderPlatformMessageHandler::HandlePlatformMessage(), flutter::ImageDecoderImpeller::ImageDecoderImpeller(), InferMetalPlatformViewCreationCallback(), InferOpenGLPlatformViewCreationCallback(), InferSoftwarePlatformViewCreationCallback(), InferVulkanPlatformViewCreationCallback(), flutter::ImmutableBuffer::initFromAsset(), flutter::ImmutableBuffer::initFromFile(), InternalFlutterGpu_CommandBuffer_Submit(), flutter::gpu::Texture::Overwrite(), flutter::PersistentCacheStore(), flutter::PrepareKernelMappings(), impeller::RuntimeStagePlayground::RegisterStage(), flutter::gpu::Shader::RegisterSync(), flutter::testing::RunDartCodeInIsolate(), flutter::testing::RunDartCodeInIsolateOnUITaskRunner(), flutter::RunTester(), flutter::testing::ShellTest::SendEnginePlatformMessage(), flutter::Spawn(), flutter::gpu::CommandBuffer::Submit(), flutter::AndroidExternalViewEmbedder2::SubmitFlutterView(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), impeller::testing::TEST_P(), flutter_runner::VsyncWaiter::VsyncWaiter(), flutter_runner::Engine::~Engine(), flutter::PlatformMessageResponseDart::~PlatformMessageResponseDart(), and flutter_runner::VsyncWaiter::~VsyncWaiter().

MakeRefCounted()

template<typename T , typename... Args>

RefPtr< T > fml::MakeRefCounted

(

Args &&...

args

)

Definition at line 253 of file ref_ptr.h.

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

References args, and fml::internal::MakeRefCountedHelper< T >::MakeRefCounted().

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();
}

Referenced by fml::TimePoint::CurrentWallTime(), and fml::TimePoint::Now().

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);
}

References OpenDirectory().

Referenced by flutter::testing::CanvasCompareTester::CheckDir(), impeller::compiler::testing::CompilerTest::CompilerTest(), CreateDirectory(), impeller::FindSwiftShaderICDAtKnownPaths(), fml::paths::GetCachesDirectory(), flutter::RunConfiguration::InferFromSettings(), impeller::Main(), OpenDirectory(), OpenDirectoryReadOnly(), RemoveDirectoryRecursively(), flutter::RunTester(), fml::ScopedTemporaryDirectory::ScopedTemporaryDirectory(), flutter::StartupAndShutdownShell(), flutter::TemplaterMain(), TEST(), fml::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

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))};
}

References FileExists(), FML_HANDLE_EINTR, fml::UniqueObject< T, Traits >::get(), and ToPosixCreateModeFlags().

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);
}

References kRead, and OpenDirectory().

Referenced by flutter::PersistentCache::LoadSkSLs(), RemoveFilesInDirectory(), impeller::compiler::Switches::Switches(), flutter::testing::TEST_F(), and VisitFilesRecursively().

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);
}

References OpenFile().

Referenced by fml::FileMapping::CreateReadExecute(), fml::FileMapping::CreateReadExecute(), fml::FileMapping::CreateReadOnly(), fml::FileMapping::CreateReadOnly(), flutter::ImmutableBuffer::initFromFile(), OpenFile(), OpenFileReadOnly(), flutter::testing::OpenFixture(), flutter::testing::RunDartCodeInIsolateOnUITaskRunner(), flutter::RunTester(), fml::icu::ICUContext::SetupMapping(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and WriteAtomically().

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))};
}

References FileExists(), FML_HANDLE_EINTR, fml::UniqueObject< T, Traits >::get(), ToPosixAccessFlags(), ToPosixCreateModeFlags(), and TRACE_EVENT0.

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);
}

References kRead, and OpenFile().

Referenced by impeller::compiler::testing::CompilerTest::GetReflectionJson(), impeller::compiler::testing::CompilerTest::GetShaderFile(), IsDirectory(), fml::testing::TEST(), fml::testing::TEST(), and flutter::testing::TEST_F().

operator!=()

template<class T , class Traits >

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

Definition at line 134 of file unique_object.h.

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

References value.

operator==()

template<class T , class Traits >

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

Definition at line 129 of file unique_object.h.

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

References value.

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);
}

References text.

Referenced by TEST(), TEST(), and TEST().

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);
}

References text.

Referenced by TEST(), and TEST().

ReadIntFromFile()

std::optional< int64_t > fml::ReadIntFromFile

(

const std::string &

path

)

Note

Visible for testing.

Definition at line 91 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;
}

Referenced by InitCPUInfo(), fml::testing::TEST(), fml::testing::TEST(), and fml::testing::TEST().

Ref()

template<typename T >

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

inline

Definition at line 242 of file ref_ptr.h.

                             {
  return RefPtr<T>(ptr);
}

Referenced by flutter::ReusableFragmentShader::Create(), flutter::UnrefQueue< T >::DeleteTexture(), and flutter::UnrefQueue< T >::Unref().

RefreshRateToFrameBudget()

template<typename T >

Milliseconds fml::RefreshRateToFrameBudget

(

T

refresh_rate

)

Definition at line 24 of file time_delta.h.

                                                      {
  return Milliseconds(1s) / refresh_rate;
}

Referenced by flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

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);
}

References kReadWrite, OpenDirectory(), RemoveFilesInDirectory(), and UnlinkDirectory().

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);
}

References IsDirectory(), OpenDirectoryReadOnly(), UnlinkDirectory(), UnlinkFile(), and VisitFiles().

Referenced by RemoveDirectoryRecursively(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and fml::ScopedTemporaryDirectory::~ScopedTemporaryDirectory().

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 27 of file cpu_affinity.cc.

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

References AndroidRequestAffinity().

Referenced by flutter::AndroidPlatformThreadConfigSetter(), and fml::testing::TEST().

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);
}

References fml::state::g_log_settings, kLogFatal, and fml::LogSettings::min_log_level.

Referenced by fml::LogInterestListener::HandleInterestChange(), fml::ScopedSetLogSettings::ScopedSetLogSettings(), and fml::ScopedSetLogSettings::~ScopedSetLogSettings().

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
}

References FML_DLOG, and name.

Referenced by fml::Thread::SetCurrentThreadName().

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;
}

References gCPUTracker, gCPUTrackerFlag, InitCPUInfo(), and fml::CPUSpeedTracker::IsValid().

Referenced by AndroidEfficiencyCoreCount(), and AndroidRequestAffinity().

ShouldCreateLogMessage()

bool fml::ShouldCreateLogMessage

(

LogSeverity

severity

)

Definition at line 216 of file logging.cc.

                                                  {
  return severity >= GetMinLogLevel();
}

References GetMinLogLevel().

Referenced by ShouldCreateLogMessageConstexpr().

ShouldCreateLogMessageConstexpr()

constexpr bool fml::ShouldCreateLogMessageConstexpr ( LogSeverity  severity, bool  true_arg  )

constexpr

Definition at line 63 of file logging.h.

                                                              {
  if (true_arg) {
    return ShouldCreateLogMessage(severity);
  }
  return false;
}

References ShouldCreateLogMessage().

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);
}

References BacktraceHere(), FML_LOG, SignalNameToString(), and ToggleSignalHandlers().

Referenced by ToggleSignalHandlers().

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);
}

Referenced by SignalHandler().

strdup()

char * fml::strdup

(

const char *

str1

)

Definition at line 11 of file posix_wrappers_posix.cc.

                               {
  return ::strdup(str1);
}

Referenced by flutter::NativeAssetsAvailableAssets().

swap()

template<class T , class Traits >

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

Definition at line 124 of file unique_object.h.

                                                                              {
  a.swap(b);
}

References fml::UniqueObject< T, Traits >::swap().

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);
}

References fml::CountDownLatch::CountDown(), fml::Thread::GetTaskRunner(), i, and fml::CountDownLatch::Wait().

TEST() [2/9]

fml::TEST	(	CountDownLatchTest	,
		CanWaitOnZero
	)

Definition at line 16 of file count_down_latch_unittests.cc.

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

References fml::CountDownLatch::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()));
}

References fml::MallocMapping::Copy(), fml::MallocMapping::GetMapping(), fml::MallocMapping::GetSize(), and length.

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());
}

References fml::MallocMapping::Copy(), and fml::MallocMapping::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());
}

References fml::MallocMapping::GetMapping(), and fml::MallocMapping::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());
}

References fml::MallocMapping::GetMapping(), fml::MallocMapping::IsDontNeedSafe(), and length.

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());
}

References fml::MallocMapping::GetMapping(), fml::MallocMapping::GetSize(), and length.

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());
}

References fml::MallocMapping::GetMapping(), fml::MallocMapping::GetSize(), and length.

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());
}

References fml::MallocMapping::GetMapping(), fml::MallocMapping::GetSize(), length, and fml::MallocMapping::Release().

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;
}

References FML_HANDLE_EINTR.

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;
}

References FML_DLOG, NSEC_PER_SEC, TFD_TIMER_ABSTIME, timerfd_settime(), fml::TimePoint::ToEpochDelta(), and fml::TimeDelta::ToNanoseconds().

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;
    }
  }
}

References FML_LOG, handler, i, kKnownSignalHandlers, and SignalHandler().

Referenced by InstallCrashHandler(), and SignalHandler().

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;
}

References kRead, kReadWrite, and kWrite.

Referenced by OpenFile().

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;
}

References kRead, kReadWrite, and kWrite.

Referenced by OpenDirectory(), and OpenFile().

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:
        // Do not combine write flags with execute flags.
        return PROT_READ | PROT_EXEC;
    }
  }
  return flags;
}

References fml::FileMapping::kExecute, fml::FileMapping::kRead, and fml::FileMapping::kWrite.

Referenced by fml::FileMapping::FileMapping().

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;
}

References fml::UniqueObject< T, Traits >::get(), and fml::UniqueObject< T, Traits >::is_valid().

Referenced by TEST(), WriteAtomically(), and WriteStringToFile().

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);
}

References UnlinkDirectory().

Referenced by RemoveDirectoryRecursively(), RemoveFilesInDirectory(), TEST(), TEST(), TEST(), TEST(), UnlinkDirectory(), and fml::ScopedTemporaryDirectory::~ScopedTemporaryDirectory().

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;
}

References fml::UniqueObject< T, Traits >::get().

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);
}

References UnlinkFile().

Referenced by RemoveFilesInDirectory(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), flutter::testing::TEST_F(), and UnlinkFile().

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;
}

References FML_DLOG, and fml::UniqueObject< T, Traits >::get().

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());
}

References data.

Referenced by flutter::TextEditingDelta::delta_text(), flutter::TextInputModel::GetCursorOffset(), flutter::TextInputModel::GetText(), fml::jni::JavaStringToString(), flutter::TextEditingDelta::old_text(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), and base::UTF16ToUTF8().

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)};
}

References end.

Referenced by fml::testing::TEST(), fml::testing::TEST(), and fml::testing::TEST().

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());
}

References data.

Referenced by flutter::TextInputModel::AddText(), flutter::TextInputPlugin::ComposeChangeHook(), impeller::interop::ParagraphStyle::SetEllipsis(), flutter::TextInputModel::SetText(), fml::jni::StringToJavaString(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), impeller::interop::testing::TEST_P(), flutter::TextInputPlugin::TextHook(), flutter::TextInputModel::UpdateComposingText(), and base::UTF8ToUTF16().

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());
}

Referenced by flutter::AccessibilityPlugin::Announce(), GetFileAttributesForUtf8Path(), IsAbsolutePath(), flutter::PlatformHandler::SetPlainText(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), and fml::testing::TEST().

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;
}

References FML_DLOG, fml::UniqueObject< T, Traits >::get(), fml::UniqueObject< T, Traits >::is_valid(), and fml::UniqueObject< T, Traits >::release().

Referenced by flutter::PersistentCache::LoadSkSLs(), RemoveFilesInDirectory(), TEST(), and VisitFilesRecursively().

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);
}

References FML_LOG, fml::UniqueObject< T, Traits >::is_valid(), IsDirectory(), OpenDirectoryReadOnly(), and VisitFiles().

Referenced by TEST(), and TEST().

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;
  }
}

References FML_DCHECK, fml::TimePoint::Now(), start, and fml::TimeDelta::ToNanoseconds().

Referenced by fml::ManualResetWaitableEvent::WaitWithTimeout().

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)};
}

References end.

Referenced by flutter::FlutterWindowsView::AnnounceAlert(), fml::testing::TEST(), fml::testing::TEST(), fml::testing::TEST(), and ui::TEST_F().

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());
}

Referenced by GetFullHandlePath(), GetLastErrorMessage(), flutter::PlatformHandler::GetPlainText(), flutter::ParseLanguageName(), fml::testing::TEST(), fml::testing::TEST(), and fml::testing::TEST().

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;
}

References data, FML_HANDLE_EINTR, fml::UniqueObject< T, Traits >::get(), kReadWrite, OpenFile(), and TruncateFile().

Referenced by impeller::compiler::testing::CompilerTest::CanCompileAndReflect(), impeller::compiler::GenerateShaderBundle(), impeller::compiler::Main(), impeller::Main(), impeller::compiler::OutputDepfile(), impeller::compiler::OutputIPLR(), impeller::compiler::OutputReflectionData(), impeller::compiler::OutputSLFile(), flutter::PersistentCacheStore(), impeller::PipelineCacheDataPersist(), flutter::TemplaterMain(), fml::testing::TEST(), fml::testing::TEST(), TEST(), TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

Variable Documentation

gCPUTracker

CPUSpeedTracker* fml::gCPUTracker

static

Definition at line 21 of file cpu_affinity.cc.

Referenced by AndroidEfficiencyCoreCount(), AndroidRequestAffinity(), InitCPUInfo(), and SetUpCPUTracker().

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.

Referenced by SetUpCPUTracker().

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.

                                            {
    // starting from ASCII 50 '2'
    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};

Referenced by Base32Decode().

kDecodeMapSize

constexpr int fml::kDecodeMapSize

staticconstexpr

Initial value:

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

Definition at line 52 of file base32.cc.

Referenced by Base32Decode().

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.

Referenced by Base32Encode(), and HexEncode().

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.

                                       {
    SIGABRT,  // abort program
    SIGFPE,   // floating-point exception
    SIGTERM,  // software termination signal
    SIGSEGV,  // segmentation violation
#if !FML_OS_WIN
    SIGBUS,   // bus error
    SIGSYS,   // non-existent system call invoked
    SIGPIPE,  // write on a pipe with no reader
    SIGALRM,  // real-time timer expired
#endif        // !FML_OS_WIN
};

Referenced by ToggleSignalHandlers().

kKUnknownFrameName [1/2]

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

static

Definition at line 25 of file backtrace.cc.

Referenced by GetSymbolName().

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.

Referenced by fml::LogInterestListener::HandleInterestChange(), fml::testing::TEST_F(), and fml::LogMessage::~LogMessage().

kLogFatal

constexpr LogSeverity fml::kLogFatal = 4

constexpr

Definition at line 19 of file log_level.h.

Referenced by GetMinLogLevel(), fml::LogInterestListener::HandleInterestChange(), SetLogSettings(), fml::testing::TEST(), fml::testing::TEST_F(), and fml::LogMessage::~LogMessage().

kLogImportant

constexpr LogSeverity fml::kLogImportant = 3

constexpr

Definition at line 18 of file log_level.h.

Referenced by fml::LogMessage::~LogMessage().

kLogInfo

constexpr LogSeverity fml::kLogInfo = 0

constexpr

Definition at line 13 of file log_level.h.

Referenced by GetVlogVerbosity(), fml::LogInterestListener::HandleInterestChange(), fml::LogMessage::LogMessage(), fml::testing::TEST_F(), fml::testing::TEST_F(), and fml::LogMessage::~LogMessage().

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.

Referenced by fml::LogInterestListener::HandleInterestChange(), fml::testing::TEST_F(), fml::testing::TEST_F(), flutter::testing::TEST_F(), and fml::LogMessage::~LogMessage().

kUnmerged

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

static

Definition at line 24 of file message_loop_task_queues.h.

Referenced by fml::MessageLoopTaskQueues::Dispose(), fml::MessageLoopTaskQueues::DisposeTasks(), fml::MessageLoopTaskQueues::GetNumPendingTasks(), fml::MessageLoopTaskQueues::GetObserversToNotify(), fml::MessageLoopTaskQueues::Merge(), fml::MessageLoopTaskQueues::Owns(), fml::MessageLoopTaskQueues::RegisterTask(), fml::testing::TEST(), and fml::MessageLoopTaskQueues::Unmerge().

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.

Referenced by impeller::ImpellerValidationBreak().

LOG_FATAL

constexpr LogSeverity fml::LOG_FATAL = kLogFatal

constexpr

Definition at line 45 of file log_level.h.

Referenced by impeller::ImpellerValidationBreak().

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.

Referenced by fml::MessageLoop::EnsureInitializedForCurrentThread(), fml::MessageLoop::GetCurrent(), fml::MessageLoop::GetCurrentTaskQueueId(), and fml::MessageLoop::IsInitializedForCurrentThread().

tls_task_source_grade

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

static

Definition at line 36 of file message_loop_task_queues.cc.

Referenced by fml::MessageLoopTaskQueues::GetCurrentTaskSourceGrade(), and fml::MessageLoopTaskQueues::GetNextTaskToRun().

tTaskObservers

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

Definition at line 11 of file task_observers.cc.

Referenced by CurrentMessageLoopAddAfterTaskObserver(), CurrentMessageLoopRemoveAfterTaskObserver(), and ExecuteAfterTaskObservers().