diff --git a/deps/perfetto/VERSION b/deps/perfetto/VERSION index 06b0aef2d7b5..5132e635a5f8 100644 --- a/deps/perfetto/VERSION +++ b/deps/perfetto/VERSION @@ -1 +1 @@ -57.2 +58.2 diff --git a/deps/perfetto/sdk/perfetto.cc b/deps/perfetto/sdk/perfetto.cc index 4df59d2c46dd..739d48322046 100644 --- a/deps/perfetto/sdk/perfetto.cc +++ b/deps/perfetto/sdk/perfetto.cc @@ -94,6 +94,109 @@ void AfterMaybeBlockingSyscall() {} } // namespace platform } // namespace base } // namespace perfetto +// gen_amalgamated begin source: src/base/check_cpu_optimizations.cc +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Startup check that the CPU supports the extensions (SSE4.2, AVX2, BMI2, +// LZCNT) the binary is built with when enable_perfetto_x64_cpu_opt is set; if +// not, it prints an error and exits. +// +// Must be built for the baseline x86_64 ISA (its target subtracts +// config("x64_cpu_opt") in src/base/BUILD.gn), else the check could itself use +// instructions the CPU lacks. Context: +// https://github.com/google/perfetto/discussions/5138 + +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/base/export.h" + +#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT) + +#include +#include // For _exit(). + +namespace { + +// Preserve the %rbx register via %rdi to work around a clang bug +// https://bugs.llvm.org/show_bug.cgi?id=17907 (%rbx in an output constraint +// is not considered a clobbered register). +#define PERFETTO_GETCPUID(a, b, c, d, a_inp, c_inp) \ + asm("mov %%rbx, %%rdi\n" \ + "cpuid\n" \ + "xchg %%rdi, %%rbx\n" \ + : "=a"(a), "=D"(b), "=c"(c), "=d"(d) \ + : "a"(a_inp), "2"(c_inp)) + +uint32_t GetXCR0EAX() { + uint32_t eax = 0, edx = 0; + asm("xgetbv" : "=a"(eax), "=d"(edx) : "c"(0)); + return eax; +} + +// If we are building with -msse4 check that the CPU actually supports it. +// This file must be kept in sync with gn/standalone/BUILD.gn. +void PERFETTO_EXPORT_COMPONENT __attribute__((constructor)) +CheckCpuOptimizations() { + uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0; + PERFETTO_GETCPUID(eax, ebx, ecx, edx, 1, 0); + + static constexpr uint64_t xcr0_xmm_mask = 0x2; + static constexpr uint64_t xcr0_ymm_mask = 0x4; + static constexpr uint64_t xcr0_avx_mask = xcr0_xmm_mask | xcr0_ymm_mask; + + const bool have_popcnt = ecx & (1u << 23); + const bool have_sse4_2 = ecx & (1u << 20); + const bool have_avx = + // Does the OS save/restore XMM and YMM state? + (ecx & (1u << 27)) && // OS support XGETBV. + (ecx & (1u << 28)) && // AVX supported in hardware + ((GetXCR0EAX() & xcr0_avx_mask) == xcr0_avx_mask); + + // Get level 7 features (eax = 7 and ecx= 0), to check for AVX2 support. + // (See Intel 64 and IA-32 Architectures Software Developer's Manual + // Volume 2A: Instruction Set Reference, A-M CPUID). + PERFETTO_GETCPUID(eax, ebx, ecx, edx, 7, 0); + const bool have_avx2 = have_avx && ((ebx >> 5) & 0x1); + const bool have_bmi = (ebx >> 3) & 0x1; + const bool have_bmi2 = (ebx >> 8) & 0x1; + + // Get extended features for LZCNT. + PERFETTO_GETCPUID(eax, ebx, ecx, edx, 0x80000001, 0); + const bool have_lzcnt = ecx & (1u << 5); + + if (!have_sse4_2 || !have_popcnt || !have_avx2 || !have_bmi || !have_bmi2 || + !have_lzcnt) { + fprintf( + stderr, + "This executable requires a x86_64 cpu that supports SSE4.2, BMI2, " + "AVX2 and LZCNT.\n" +#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) + "On MacOS, this might be caused by running x86_64 binaries on arm64.\n" + "See https://github.com/google/perfetto/issues/294 for more.\n" +#endif + "Rebuild with enable_perfetto_x64_cpu_opt=false.\n"); + _exit(126); + } +} + +} // namespace + +#endif // PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT) // gen_amalgamated begin source: src/base/android_utils.cc // gen_amalgamated begin header: include/perfetto/ext/base/android_utils.h /* @@ -1148,10 +1251,12 @@ constexpr pid_t kInvalidPid = static_cast(-1); #include #include #include +#include #include #include #include +#include #include #include @@ -1199,6 +1304,54 @@ constexpr size_t ArraySize(const T (&)[TSize]) { return TSize; } +// Adds `a` and `b`, clamping to INT64_MIN / INT64_MAX on overflow instead of +// wrapping (which is UB and can flip the sign of the result). +inline int64_t SaturatingAdd(int64_t a, int64_t b) { + constexpr int64_t kMax = std::numeric_limits::max(); + constexpr int64_t kMin = std::numeric_limits::min(); +#if defined(__clang__) || defined(__GNUC__) + int64_t result; + if (PERFETTO_UNLIKELY(__builtin_add_overflow(a, b, &result))) + return a < 0 ? kMin : kMax; + return result; +#else + if (b > 0 && a > kMax - b) + return kMax; + if (b < 0 && a < kMin - b) + return kMin; + return a + b; +#endif +} + +// Multiplies `a` by `b`, clamping to INT64_MIN / INT64_MAX on overflow instead +// of wrapping (which is UB and can flip the sign of the result). +inline int64_t SaturatingMultiply(int64_t a, int64_t b) { + constexpr int64_t kMax = std::numeric_limits::max(); + constexpr int64_t kMin = std::numeric_limits::min(); +#if defined(__clang__) || defined(__GNUC__) + int64_t result; + if (PERFETTO_UNLIKELY(__builtin_mul_overflow(a, b, &result))) { + // On overflow the true product's sign is the XOR of the operands' signs. + // Neither operand can be zero here (0 never overflows). + return ((a < 0) == (b < 0)) ? kMax : kMin; + } + return result; +#else + // Portable fallback (e.g. MSVC cl.exe): detect overflow *before* multiplying + // by dividing a limit by one operand, which never itself overflows. + if (a == 0 || b == 0) + return 0; + if ((a < 0) == (b < 0)) { // Same sign: product is positive. + if (a > 0 ? (a > kMax / b) : (a < kMax / b)) + return kMax; + } else { // Opposite signs: product is negative. + if (a > 0 ? (b < kMin / a) : (a < kMin / b)) + return kMin; + } + return a * b; +#endif +} + // Function object which invokes 'free' on its parameter, which must be // a pointer. Can be used to store malloc-allocated pointers in std::unique_ptr: // @@ -1221,11 +1374,39 @@ inline constexpr size_t AlignUp(size_t size, size_t alignment) { return (size + alignment - 1) & ~(alignment - 1); } +// Round down |size| to a multiple of |alignment| (must be a power of two). +inline constexpr size_t AlignDown(size_t size, size_t alignment) { + return size & ~(alignment - 1); +} + +template +inline constexpr bool IsPowerOfTwo(T x) { + static_assert(std::is_unsigned_v && std::is_integral_v, + "T must be an unsigned integer"); + return x != 0 && (x & (x - 1)) == 0; +} + +// Returns the smallest power of two greater than or equal to |x|. Returns zero +// for zero or when the result is not representable by T. +template +inline constexpr T RoundUpToPowerOfTwo(T x) { + static_assert(std::is_unsigned_v && std::is_integral_v, + "T must be an unsigned integer"); + if (x == 0) { + return 0; + } + --x; + for (size_t shift = 1; shift < sizeof(T) * 8; shift *= 2) { + x |= x >> shift; + } + return ++x; +} + // TODO(primiano): clean this up and move all existing usages to the constexpr // version above. template constexpr size_t AlignUp(size_t size) { - static_assert((alignment & (alignment - 1)) == 0, "alignment must be a pow2"); + static_assert(IsPowerOfTwo(alignment), "alignment must be a pow2"); return AlignUp(size, alignment); } @@ -1239,6 +1420,13 @@ void SetEnv(const std::string& key, const std::string& value); // unsetenv(2)-equivalent. Deals with Windows vs Posix discrepancies. void UnsetEnv(const std::string& key); +// Returns true if |fd| is connected to an interactive terminal (TTY). Deals +// with Windows vs Posix discrepancies (isatty() vs _isatty()). +bool IsTty(int fd); + +// Convenience overload for C stdio streams (e.g. stdin/stdout/stderr). +bool IsTty(FILE* stream); + // Calls mallopt(M_PURGE, 0) on Android. Does nothing on other platforms. // This forces the allocator to release freed memory. This is used to work // around various Scudo inefficiencies. See b/170217718. @@ -1248,10 +1436,10 @@ void MaybeReleaseAllocatorMemToOS(); uid_t GetCurrentUserId(); // Forks the process. -// Parent: prints the PID of the child, calls |parent_cb| and exits from the -// process with its return value. +// Parent: calls |parent_cb| with the child's PID and exits with its return +// value. The callback owns any startup output (e.g. printing the PID). // Child: redirects stdio onto /dev/null, chdirs into / and returns. -void Daemonize(std::function parent_cb); +void Daemonize(std::function parent_cb); // Returns the path of the current executable, e.g. /foo/bar/exe. std::string GetCurExecutablePath(); @@ -1896,6 +2084,7 @@ using ScopedDir = ScopedResource; #include // For mode_t & O_RDONLY/RDWR. Exists also on Windows. #include +#include #include #include @@ -1977,6 +2166,16 @@ int PERFETTO_EXPORT_COMPONENT CloseFile(int fd); bool FlushFile(int fd); +// Moves the file offset to |offset| bytes from the beginning of the file. +// Returns false if |offset| cannot be represented by the platform or the seek +// fails. +bool SeekFile(int fd, uint64_t offset); + +// Changes the size of an open file to |size| bytes. +// Returns false if |size| cannot be represented by the platform or truncation +// fails. +bool TruncateFile(int fd, uint64_t size); + // Returns true if mkdir succeeds, false if it fails (see errno in that case). // `mode` is the permission bits for the new directory; it is ignored on // Windows. @@ -1992,6 +2191,9 @@ bool Unlink(const char* path); // Wrapper around access(path, F_OK). bool FileExists(const std::string& path); +// Returns true if the path exists and is a directory. +bool DirectoryExists(const std::string& path); + // Gets the extension for a filename. If the file has two extensions, returns // only the last one (foo.pb.gz => .gz). Returns empty string if there is no // extension. @@ -2021,6 +2223,22 @@ std::string Basename(const std::string& path); // Dirname("C:\\Windows\\System32") => "C:\\Windows" std::string Dirname(const std::string& path); +// Returns the length of the leading root component of a path: "/" on UNIX, +// "C:\" or "\\" (UNC) on Windows. Returns 0 if the path is relative. Like +// Basename() and Dirname(), both '/' and '\' are recognized on all platforms. +// Stripping the returned prefix turns the path into a relative one. +// Examples: +// PathRootPrefixLength("/usr/bin/ls") => 1 +// PathRootPrefixLength("//usr/bin") => 2 +// PathRootPrefixLength("C:\\Windows") => 3 +// PathRootPrefixLength("C:foo") => 0 (relative to the current dir of drive +// C:) PathRootPrefixLength("foo/bar") => 0 +size_t PathRootPrefixLength(const std::string& path); + +// Returns true if the path starts with a root component. See +// PathRootPrefixLength(). +bool IsAbsolutePath(const std::string& path); + // Puts the path to all files under |dir_path| in |output|, recursively walking // subdirectories. File paths are relative to |dir_path|. Only files are // included, not directories. Path separator is always '/', even on windows (not @@ -2046,6 +2264,13 @@ std::optional GetFileSize(const std::string& path); // Returns the size of the open file |fd|, or nullopt in case of error. std::optional GetFileSize(PlatformHandle fd); +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +// On Windows PlatformHandle is a HANDLE, not a file descriptor. This overload +// accepts the CRT file descriptors returned by base::OpenFile(). On other +// platforms PlatformHandle is an int, so the overload above already covers it. +std::optional GetFileSize(int fd); +#endif + // This class uses inotify (on Linux/Android) to watch for the creation of // files in the filesystem. When the specified file is created, it triggers a // callback function. @@ -3521,6 +3746,7 @@ class WeakPtrFactory { #include #include +#include #include #include #include @@ -3765,6 +3991,52 @@ bool FlushFile(int fd) { #endif } +bool SeekFile(int fd, uint64_t offset) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + if (fd < 0) { + errno = EBADF; + return false; + } + if (offset > static_cast(std::numeric_limits::max())) { + errno = EOVERFLOW; + return false; + } + return _lseeki64(fd, static_cast(offset), SEEK_SET) != -1; +#else + if (offset > static_cast(std::numeric_limits::max())) { + errno = EOVERFLOW; + return false; + } + return lseek(fd, static_cast(offset), SEEK_SET) != + static_cast(-1); +#endif +} + +bool TruncateFile(int fd, uint64_t size) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + if (fd < 0) { + errno = EBADF; + return false; + } + if (size > static_cast(std::numeric_limits::max())) { + errno = EOVERFLOW; + return false; + } + int result = _chsize_s(fd, static_cast(size)); + if (result != 0) { + errno = result; + return false; + } + return true; +#else + if (size > static_cast(std::numeric_limits::max())) { + errno = EOVERFLOW; + return false; + } + return PERFETTO_EINTR(ftruncate(fd, static_cast(size))) == 0; +#endif +} + bool Mkdir(const std::string& path, uint32_t mode) { #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) base::ignore_result(mode); @@ -3847,6 +4119,22 @@ bool FileExists(const std::string& path) { #endif } +bool DirectoryExists(const std::string& path) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + DWORD attrs = GetFileAttributesA(path.c_str()); + return attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY); +#else + struct stat st; + if (stat(path.c_str(), &st) != 0) { + return false; + } + // MSan's stat() interceptor on glibc 2.35+ does not mark the output buffer + // as initialized (the syscall goes through statx). + PERFETTO_MSAN_UNPOISON(&st, sizeof(st)); + return S_ISDIR(st.st_mode); +#endif +} + // Declared in base/platform_handle.h. int ClosePlatformHandle(PlatformHandle handle) { #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) @@ -4064,6 +4352,27 @@ std::string Dirname(const std::string& path) { return p.substr(0, last_sep); } +size_t PathRootPrefixLength(const std::string& path) { + size_t pos = 0; + // Skip over a leading drive letter, e.g. "C:\foo". + bool has_drive_letter = path.size() >= 2 && path[1] == ':' && + ((path[0] >= 'a' && path[0] <= 'z') || + (path[0] >= 'A' && path[0] <= 'Z')); + if (has_drive_letter) + pos = 2; + + size_t end = path.find_first_not_of("/\\", pos); + end = end == std::string::npos ? path.size() : end; + + // A drive letter not followed by a separator ("C:foo") is relative to the + // current directory of that drive, not absolute. + return end > pos ? end : 0; +} + +bool IsAbsolutePath(const std::string& path) { + return PathRootPrefixLength(path) != 0; +} + base::Status SetFilePermissions(const std::string& file_path, const std::string& group_name_or_id, const std::string& mode_bits) { @@ -4147,6 +4456,12 @@ std::optional GetFileSize(PlatformHandle fd) { #endif } +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +std::optional GetFileSize(int fd) { + return GetFileSize(reinterpret_cast(_get_osfhandle(fd))); +} +#endif + // LinuxFileWatch #if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \ @@ -7564,9 +7879,14 @@ ScopedPlatformHandle OpenFileForMmap(const std::string& file_path) { return OpenFile(file_path, O_RDONLY); #elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) // This does not use base::OpenFile to avoid getting an exclusive lock. + // + // The share flags mirror the POSIX open(O_RDONLY) above, which has no notion + // of share modes. Same flags as LLVM's openNativeFileInternal(): + // https://github.com/llvm/llvm-project/blob/main/llvm/lib/Support/Windows/Path.inc return ScopedPlatformHandle( - CreateFileA(file_path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, - OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)); + CreateFileA(file_path.c_str(), GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)); #else // mmap is not supported. Do not even open the file. base::ignore_result(file_path); @@ -9746,7 +10066,11 @@ std::optional GetTimezoneOffsetMins() { PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) #include #include // For _exit() -#include // For getpagesize() and geteuid() & fork() & sysconf() +#endif + +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +// For isatty(), getpagesize(), geteuid(), fork() & sysconf(). +#include #endif #if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) @@ -9808,75 +10132,6 @@ using MalloptType = int (*)(int, int); } // namespace #endif // OS_ANDROID -namespace { - -#if PERFETTO_BUILDFLAG(PERFETTO_X64_CPU_OPT) - -// Preserve the %rbx register via %rdi to work around a clang bug -// https://bugs.llvm.org/show_bug.cgi?id=17907 (%rbx in an output constraint -// is not considered a clobbered register). -#define PERFETTO_GETCPUID(a, b, c, d, a_inp, c_inp) \ - asm("mov %%rbx, %%rdi\n" \ - "cpuid\n" \ - "xchg %%rdi, %%rbx\n" \ - : "=a"(a), "=D"(b), "=c"(c), "=d"(d) \ - : "a"(a_inp), "2"(c_inp)) - -uint32_t GetXCR0EAX() { - uint32_t eax = 0, edx = 0; - asm("xgetbv" : "=a"(eax), "=d"(edx) : "c"(0)); - return eax; -} - -// If we are building with -msse4 check that the CPU actually supports it. -// This file must be kept in sync with gn/standalone/BUILD.gn. -void PERFETTO_EXPORT_COMPONENT __attribute__((constructor)) -CheckCpuOptimizations() { - uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0; - PERFETTO_GETCPUID(eax, ebx, ecx, edx, 1, 0); - - static constexpr uint64_t xcr0_xmm_mask = 0x2; - static constexpr uint64_t xcr0_ymm_mask = 0x4; - static constexpr uint64_t xcr0_avx_mask = xcr0_xmm_mask | xcr0_ymm_mask; - - const bool have_popcnt = ecx & (1u << 23); - const bool have_sse4_2 = ecx & (1u << 20); - const bool have_avx = - // Does the OS save/restore XMM and YMM state? - (ecx & (1u << 27)) && // OS support XGETBV. - (ecx & (1u << 28)) && // AVX supported in hardware - ((GetXCR0EAX() & xcr0_avx_mask) == xcr0_avx_mask); - - // Get level 7 features (eax = 7 and ecx= 0), to check for AVX2 support. - // (See Intel 64 and IA-32 Architectures Software Developer's Manual - // Volume 2A: Instruction Set Reference, A-M CPUID). - PERFETTO_GETCPUID(eax, ebx, ecx, edx, 7, 0); - const bool have_avx2 = have_avx && ((ebx >> 5) & 0x1); - const bool have_bmi = (ebx >> 3) & 0x1; - const bool have_bmi2 = (ebx >> 8) & 0x1; - - // Get extended features for LZCNT. - PERFETTO_GETCPUID(eax, ebx, ecx, edx, 0x80000001, 0); - const bool have_lzcnt = ecx & (1u << 5); - - if (!have_sse4_2 || !have_popcnt || !have_avx2 || !have_bmi || !have_bmi2 || - !have_lzcnt) { - fprintf( - stderr, - "This executable requires a x86_64 cpu that supports SSE4.2, BMI2, " - "AVX2 and LZCNT.\n" -#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) - "On MacOS, this might be caused by running x86_64 binaries on arm64.\n" - "See https://github.com/google/perfetto/issues/294 for more.\n" -#endif - "Rebuild with enable_perfetto_x64_cpu_opt=false.\n"); - _exit(126); - } -} -#endif - -} // namespace - namespace perfetto { namespace base { @@ -9958,7 +10213,23 @@ void UnsetEnv(const std::string& key) { #endif } -void Daemonize(std::function parent_cb) { +bool IsTty(int fd) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + return ::_isatty(fd) != 0; +#else + return ::isatty(fd) != 0; +#endif +} + +bool IsTty(FILE* stream) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + return IsTty(::_fileno(stream)); +#else + return IsTty(::fileno(stream)); +#endif +} + +void Daemonize(std::function parent_cb) { #if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \ @@ -9994,8 +10265,7 @@ void Daemonize(std::function parent_cb) { pipe.wr.reset(); char one = '\0'; PERFETTO_CHECK(Read(*pipe.rd, &one, sizeof(one)) == 1 && one == '1'); - printf("%d\n", pid); - int err = parent_cb(); + int err = parent_cb(pid); exit(err); } } @@ -10572,7 +10842,8 @@ constexpr uint32_t kWatchdogDefaultCpuWindow = 10 * 60 * 1000; // 10 minutes. // The default memory margin we give to our processes. This is used as as a // constant to put on top of the trace buffers. -constexpr uint64_t kWatchdogDefaultMemorySlack = 32 * 1024 * 1024; // 32 MiB. +// TODO(b/540573436): Retune the value once we have a proper solution. +constexpr uint64_t kWatchdogDefaultMemorySlack = 64 * 1024 * 1024; // 64 MiB. constexpr uint32_t kWatchdogDefaultMemoryWindow = 30 * 1000; // 30 seconds. inline void RunTaskWithWatchdogGuard(const std::function& task) { @@ -11258,7 +11529,6 @@ void WeakRunner::PostDelayedTask(std::function f, #define PERFETTO_FLAGS_BUFFER_CLONE_PRESERVE_READ_ITER true #define PERFETTO_FLAGS_USE_UNIX_SOCKET_INOTIFY \ PERFETTO_BUILDFLAG(PERFETTO_ENABLE_SOCK_INOTIFY) -#define PERFETTO_FLAGS_TRACK_EVENT_INCREMENTAL_STATE_CLEAR_NOT_DESTROY true #define PERFETTO_FLAGS_TRIGGER_PERFETTO_ON_TRACED_PROBES_DISCONNECT false #define PERFETTO_FLAGS_USE_PCRE2 PERFETTO_BUILDFLAG(PERFETTO_PCRE2) #define PERFETTO_FLAGS_SYS_STATS_LARGE_READ true @@ -13917,7 +14187,7 @@ void Subprocess::StdoutErrThread(MovableState* s) { if (!res) { auto err = GetLastError(); if (err != ERROR_BROKEN_PIPE) - PERFETTO_PLOG("Subprocess ReadFile(stdouterr) failed %ld", err); + PERFETTO_PLOG("Subprocess ReadFile(stdouterr) failed %lx", err); } if (rsize > 0) { @@ -19970,6 +20240,7 @@ bool TraceStats_BufferStats::operator==(const TraceStats_BufferStats& other) con && ::protozero::internal::gen_helpers::EqualsField(padding_bytes_cleared_, other.padding_bytes_cleared_) && ::protozero::internal::gen_helpers::EqualsField(chunks_written_, other.chunks_written_) && ::protozero::internal::gen_helpers::EqualsField(chunks_rewritten_, other.chunks_rewritten_) + && ::protozero::internal::gen_helpers::EqualsField(chunks_relocated_, other.chunks_relocated_) && ::protozero::internal::gen_helpers::EqualsField(chunks_overwritten_, other.chunks_overwritten_) && ::protozero::internal::gen_helpers::EqualsField(chunks_discarded_, other.chunks_discarded_) && ::protozero::internal::gen_helpers::EqualsField(chunks_read_, other.chunks_read_) @@ -19980,8 +20251,7 @@ bool TraceStats_BufferStats::operator==(const TraceStats_BufferStats& other) con && ::protozero::internal::gen_helpers::EqualsField(readaheads_succeeded_, other.readaheads_succeeded_) && ::protozero::internal::gen_helpers::EqualsField(readaheads_failed_, other.readaheads_failed_) && ::protozero::internal::gen_helpers::EqualsField(abi_violations_, other.abi_violations_) - && ::protozero::internal::gen_helpers::EqualsField(trace_writer_packet_loss_, other.trace_writer_packet_loss_) - && ::protozero::internal::gen_helpers::EqualsField(shadow_buffer_stats_, other.shadow_buffer_stats_); + && ::protozero::internal::gen_helpers::EqualsField(trace_writer_packet_loss_, other.trace_writer_packet_loss_); } bool TraceStats_BufferStats::ParseFromArray(const void* raw, size_t size) { @@ -20018,6 +20288,9 @@ bool TraceStats_BufferStats::ParseFromArray(const void* raw, size_t size) { case 10 /* chunks_rewritten */: field.get(&chunks_rewritten_); break; + case 20 /* chunks_relocated */: + field.get(&chunks_relocated_); + break; case 3 /* chunks_overwritten */: field.get(&chunks_overwritten_); break; @@ -20051,9 +20324,6 @@ bool TraceStats_BufferStats::ParseFromArray(const void* raw, size_t size) { case 19 /* trace_writer_packet_loss */: field.get(&trace_writer_packet_loss_); break; - case 21 /* shadow_buffer_stats */: - (*shadow_buffer_stats_).ParseFromArray(field.data(), field.size()); - break; default: field.SerializeAndAppendTo(&unknown_fields_); break; @@ -20115,6 +20385,11 @@ void TraceStats_BufferStats::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeVarInt(10, chunks_rewritten_, msg); } + // Field 20: chunks_relocated + if (_has_field_[20]) { + ::protozero::internal::gen_helpers::SerializeVarInt(20, chunks_relocated_, msg); + } + // Field 3: chunks_overwritten if (_has_field_[3]) { ::protozero::internal::gen_helpers::SerializeVarInt(3, chunks_overwritten_, msg); @@ -20170,129 +20445,6 @@ void TraceStats_BufferStats::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeVarInt(19, trace_writer_packet_loss_, msg); } - // Field 21: shadow_buffer_stats - if (_has_field_[21]) { - (*shadow_buffer_stats_).Serialize(msg->BeginNestedMessage<::protozero::Message>(21)); - } - - protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); -} - - -TraceStats_BufferStats_ShadowBufferStats::TraceStats_BufferStats_ShadowBufferStats() = default; -TraceStats_BufferStats_ShadowBufferStats::~TraceStats_BufferStats_ShadowBufferStats() = default; -TraceStats_BufferStats_ShadowBufferStats::TraceStats_BufferStats_ShadowBufferStats(const TraceStats_BufferStats_ShadowBufferStats&) = default; -TraceStats_BufferStats_ShadowBufferStats& TraceStats_BufferStats_ShadowBufferStats::operator=(const TraceStats_BufferStats_ShadowBufferStats&) = default; -TraceStats_BufferStats_ShadowBufferStats::TraceStats_BufferStats_ShadowBufferStats(TraceStats_BufferStats_ShadowBufferStats&&) noexcept = default; -TraceStats_BufferStats_ShadowBufferStats& TraceStats_BufferStats_ShadowBufferStats::operator=(TraceStats_BufferStats_ShadowBufferStats&&) = default; - -bool TraceStats_BufferStats_ShadowBufferStats::operator==(const TraceStats_BufferStats_ShadowBufferStats& other) const { - return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) - && ::protozero::internal::gen_helpers::EqualsField(packets_seen_, other.packets_seen_) - && ::protozero::internal::gen_helpers::EqualsField(packets_in_both_, other.packets_in_both_) - && ::protozero::internal::gen_helpers::EqualsField(packets_only_v1_, other.packets_only_v1_) - && ::protozero::internal::gen_helpers::EqualsField(packets_only_v2_, other.packets_only_v2_) - && ::protozero::internal::gen_helpers::EqualsField(patches_attempted_, other.patches_attempted_) - && ::protozero::internal::gen_helpers::EqualsField(v1_patches_succeeded_, other.v1_patches_succeeded_) - && ::protozero::internal::gen_helpers::EqualsField(v2_patches_succeeded_, other.v2_patches_succeeded_) - && ::protozero::internal::gen_helpers::EqualsField(stats_version_, other.stats_version_); -} - -bool TraceStats_BufferStats_ShadowBufferStats::ParseFromArray(const void* raw, size_t size) { - unknown_fields_.clear(); - bool packed_error = false; - - ::protozero::ProtoDecoder dec(raw, size); - for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { - if (field.id() < _has_field_.size()) { - _has_field_.set(field.id()); - } - switch (field.id()) { - case 1 /* packets_seen */: - field.get(&packets_seen_); - break; - case 2 /* packets_in_both */: - field.get(&packets_in_both_); - break; - case 3 /* packets_only_v1 */: - field.get(&packets_only_v1_); - break; - case 4 /* packets_only_v2 */: - field.get(&packets_only_v2_); - break; - case 5 /* patches_attempted */: - field.get(&patches_attempted_); - break; - case 6 /* v1_patches_succeeded */: - field.get(&v1_patches_succeeded_); - break; - case 7 /* v2_patches_succeeded */: - field.get(&v2_patches_succeeded_); - break; - case 8 /* stats_version */: - field.get(&stats_version_); - break; - default: - field.SerializeAndAppendTo(&unknown_fields_); - break; - } - } - return !packed_error && !dec.bytes_left(); -} - -std::string TraceStats_BufferStats_ShadowBufferStats::SerializeAsString() const { - ::protozero::internal::gen_helpers::MessageSerializer msg; - Serialize(msg.get()); - return msg.SerializeAsString(); -} - -std::vector TraceStats_BufferStats_ShadowBufferStats::SerializeAsArray() const { - ::protozero::internal::gen_helpers::MessageSerializer msg; - Serialize(msg.get()); - return msg.SerializeAsArray(); -} - -void TraceStats_BufferStats_ShadowBufferStats::Serialize(::protozero::Message* msg) const { - // Field 1: packets_seen - if (_has_field_[1]) { - ::protozero::internal::gen_helpers::SerializeVarInt(1, packets_seen_, msg); - } - - // Field 2: packets_in_both - if (_has_field_[2]) { - ::protozero::internal::gen_helpers::SerializeVarInt(2, packets_in_both_, msg); - } - - // Field 3: packets_only_v1 - if (_has_field_[3]) { - ::protozero::internal::gen_helpers::SerializeVarInt(3, packets_only_v1_, msg); - } - - // Field 4: packets_only_v2 - if (_has_field_[4]) { - ::protozero::internal::gen_helpers::SerializeVarInt(4, packets_only_v2_, msg); - } - - // Field 5: patches_attempted - if (_has_field_[5]) { - ::protozero::internal::gen_helpers::SerializeVarInt(5, patches_attempted_, msg); - } - - // Field 6: v1_patches_succeeded - if (_has_field_[6]) { - ::protozero::internal::gen_helpers::SerializeVarInt(6, v1_patches_succeeded_, msg); - } - - // Field 7: v2_patches_succeeded - if (_has_field_[7]) { - ::protozero::internal::gen_helpers::SerializeVarInt(7, v2_patches_succeeded_, msg); - } - - // Field 8: stats_version - if (_has_field_[8]) { - ::protozero::internal::gen_helpers::SerializeVarInt(8, stats_version_, msg); - } - protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } @@ -22009,7 +22161,8 @@ bool DisplayVideoConfig::operator==(const DisplayVideoConfig& other) const { && ::protozero::internal::gen_helpers::EqualsField(scale_, other.scale_) && ::protozero::internal::gen_helpers::EqualsField(format_, other.format_) && ::protozero::internal::gen_helpers::EqualsField(key_frame_interval_secs_, other.key_frame_interval_secs_) - && ::protozero::internal::gen_helpers::EqualsField(max_stream_size_bytes_, other.max_stream_size_bytes_); + && ::protozero::internal::gen_helpers::EqualsField(max_stream_size_bytes_, other.max_stream_size_bytes_) + && ::protozero::internal::gen_helpers::EqualsField(bitrate_bps_, other.bitrate_bps_); } bool DisplayVideoConfig::ParseFromArray(const void* raw, size_t size) { @@ -22034,6 +22187,9 @@ bool DisplayVideoConfig::ParseFromArray(const void* raw, size_t size) { case 4 /* max_stream_size_bytes */: field.get(&max_stream_size_bytes_); break; + case 5 /* bitrate_bps */: + field.get(&bitrate_bps_); + break; default: field.SerializeAndAppendTo(&unknown_fields_); break; @@ -22075,6 +22231,11 @@ void DisplayVideoConfig::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeVarInt(4, max_stream_size_bytes_, msg); } + // Field 5: bitrate_bps + if (_has_field_[5]) { + ::protozero::internal::gen_helpers::SerializeVarInt(5, bitrate_bps_, msg); + } + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } @@ -25058,7 +25219,8 @@ bool ProcessStatsConfig::operator==(const ProcessStatsConfig& other) const { && ::protozero::internal::gen_helpers::EqualsField(record_process_age_, other.record_process_age_) && ::protozero::internal::gen_helpers::EqualsField(record_process_runtime_, other.record_process_runtime_) && ::protozero::internal::gen_helpers::EqualsField(record_process_dmabuf_rss_, other.record_process_dmabuf_rss_) - && ::protozero::internal::gen_helpers::EqualsField(resolve_process_fds_, other.resolve_process_fds_); + && ::protozero::internal::gen_helpers::EqualsField(resolve_process_fds_, other.resolve_process_fds_) + && ::protozero::internal::gen_helpers::EqualsField(skip_main_thread_message_, other.skip_main_thread_message_); } bool ProcessStatsConfig::ParseFromArray(const void* raw, size_t size) { @@ -25103,6 +25265,9 @@ bool ProcessStatsConfig::ParseFromArray(const void* raw, size_t size) { case 9 /* resolve_process_fds */: field.get(&resolve_process_fds_); break; + case 14 /* skip_main_thread_message */: + field.get(&skip_main_thread_message_); + break; default: field.SerializeAndAppendTo(&unknown_fields_); break; @@ -25174,6 +25339,11 @@ void ProcessStatsConfig::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, resolve_process_fds_, msg); } + // Field 14: skip_main_thread_message + if (_has_field_[14]) { + ::protozero::internal::gen_helpers::SerializeTinyVarInt(14, skip_main_thread_message_, msg); + } + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } @@ -27673,6 +27843,7 @@ void ChromiumHistogramSamplesConfig_HistogramSample::Serialize(::protozero::Mess // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_aflags_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/common/trace_attributes.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h" @@ -29349,6 +29520,7 @@ void InterceptorConfig::Serialize(::protozero::Message* msg) const { // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_aflags_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/common/trace_attributes.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h" @@ -29956,6 +30128,7 @@ void TestConfig_DummyFields::Serialize(::protozero::Message* msg) const { // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_aflags_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/common/trace_attributes.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h" @@ -29999,6 +30172,7 @@ bool TraceConfig::operator==(const TraceConfig& other) const { && ::protozero::internal::gen_helpers::EqualsField(allow_user_build_tracing_, other.allow_user_build_tracing_) && ::protozero::internal::gen_helpers::EqualsField(unique_session_name_, other.unique_session_name_) && ::protozero::internal::gen_helpers::EqualsField(compression_type_, other.compression_type_) + && ::protozero::internal::gen_helpers::EqualsField(compression_, other.compression_) && ::protozero::internal::gen_helpers::EqualsField(incident_report_config_, other.incident_report_config_) && ::protozero::internal::gen_helpers::EqualsField(statsd_logging_, other.statsd_logging_) && ::protozero::internal::gen_helpers::EqualsField(trace_uuid_msb_, other.trace_uuid_msb_) @@ -30012,7 +30186,7 @@ bool TraceConfig::operator==(const TraceConfig& other) const { && ::protozero::internal::gen_helpers::EqualsField(write_flush_mode_, other.write_flush_mode_) && ::protozero::internal::gen_helpers::EqualsField(fflush_post_write_, other.fflush_post_write_) && ::protozero::internal::gen_helpers::EqualsField(trace_all_machines_, other.trace_all_machines_) - && ::protozero::internal::gen_helpers::EqualsField(notes_, other.notes_); + && ::protozero::internal::gen_helpers::EqualsField(trace_attributes_, other.trace_attributes_); } int TraceConfig::buffers_size() const { return static_cast(buffers_.size()); } @@ -30027,16 +30201,12 @@ TraceConfig_ProducerConfig* TraceConfig::add_producers() { producers_.emplace_ba int TraceConfig::session_semaphores_size() const { return static_cast(session_semaphores_.size()); } void TraceConfig::clear_session_semaphores() { session_semaphores_.clear(); } TraceConfig_SessionSemaphore* TraceConfig::add_session_semaphores() { session_semaphores_.emplace_back(); return &session_semaphores_.back(); } -int TraceConfig::notes_size() const { return static_cast(notes_.size()); } -void TraceConfig::clear_notes() { notes_.clear(); } -TraceConfig_Note* TraceConfig::add_notes() { notes_.emplace_back(); return ¬es_.back(); } bool TraceConfig::ParseFromArray(const void* raw, size_t size) { buffers_.clear(); data_sources_.clear(); producers_.clear(); activate_triggers_.clear(); session_semaphores_.clear(); - notes_.clear(); unknown_fields_.clear(); bool packed_error = false; @@ -30131,6 +30301,9 @@ bool TraceConfig::ParseFromArray(const void* raw, size_t size) { case 24 /* compression_type */: field.get(&compression_type_); break; + case 47 /* compression */: + (*compression_).ParseFromArray(field.data(), field.size()); + break; case 25 /* incident_report_config */: (*incident_report_config_).ParseFromArray(field.data(), field.size()); break; @@ -30171,9 +30344,8 @@ bool TraceConfig::ParseFromArray(const void* raw, size_t size) { case 43 /* trace_all_machines */: field.get(&trace_all_machines_); break; - case 46 /* notes */: - notes_.emplace_back(); - notes_.back().ParseFromArray(field.data(), field.size()); + case 48 /* trace_attributes */: + (*trace_attributes_).ParseFromArray(field.data(), field.size()); break; default: field.SerializeAndAppendTo(&unknown_fields_); @@ -30331,6 +30503,11 @@ void TraceConfig::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeVarInt(24, compression_type_, msg); } + // Field 47: compression + if (_has_field_[47]) { + (*compression_).Serialize(msg->BeginNestedMessage<::protozero::Message>(47)); + } + // Field 25: incident_report_config if (_has_field_[25]) { (*incident_report_config_).Serialize(msg->BeginNestedMessage<::protozero::Message>(25)); @@ -30396,73 +30573,9 @@ void TraceConfig::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeTinyVarInt(43, trace_all_machines_, msg); } - // Field 46: notes - for (auto& it : notes_) { - it.Serialize(msg->BeginNestedMessage<::protozero::Message>(46)); - } - - protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); -} - - -TraceConfig_Note::TraceConfig_Note() = default; -TraceConfig_Note::~TraceConfig_Note() = default; -TraceConfig_Note::TraceConfig_Note(const TraceConfig_Note&) = default; -TraceConfig_Note& TraceConfig_Note::operator=(const TraceConfig_Note&) = default; -TraceConfig_Note::TraceConfig_Note(TraceConfig_Note&&) noexcept = default; -TraceConfig_Note& TraceConfig_Note::operator=(TraceConfig_Note&&) = default; - -bool TraceConfig_Note::operator==(const TraceConfig_Note& other) const { - return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) - && ::protozero::internal::gen_helpers::EqualsField(key_, other.key_) - && ::protozero::internal::gen_helpers::EqualsField(value_, other.value_); -} - -bool TraceConfig_Note::ParseFromArray(const void* raw, size_t size) { - unknown_fields_.clear(); - bool packed_error = false; - - ::protozero::ProtoDecoder dec(raw, size); - for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { - if (field.id() < _has_field_.size()) { - _has_field_.set(field.id()); - } - switch (field.id()) { - case 1 /* key */: - ::protozero::internal::gen_helpers::DeserializeString(field, &key_); - break; - case 2 /* value */: - ::protozero::internal::gen_helpers::DeserializeString(field, &value_); - break; - default: - field.SerializeAndAppendTo(&unknown_fields_); - break; - } - } - return !packed_error && !dec.bytes_left(); -} - -std::string TraceConfig_Note::SerializeAsString() const { - ::protozero::internal::gen_helpers::MessageSerializer msg; - Serialize(msg.get()); - return msg.SerializeAsString(); -} - -std::vector TraceConfig_Note::SerializeAsArray() const { - ::protozero::internal::gen_helpers::MessageSerializer msg; - Serialize(msg.get()); - return msg.SerializeAsArray(); -} - -void TraceConfig_Note::Serialize(::protozero::Message* msg) const { - // Field 1: key - if (_has_field_[1]) { - ::protozero::internal::gen_helpers::SerializeString(1, key_, msg); - } - - // Field 2: value - if (_has_field_[2]) { - ::protozero::internal::gen_helpers::SerializeString(2, value_, msg); + // Field 48: trace_attributes + if (_has_field_[48]) { + (*trace_attributes_).Serialize(msg->BeginNestedMessage<::protozero::Message>(48)); } protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); @@ -31014,6 +31127,171 @@ void TraceConfig_IncidentReportConfig::Serialize(::protozero::Message* msg) cons } +TraceConfig_CompressionConfig::TraceConfig_CompressionConfig() = default; +TraceConfig_CompressionConfig::~TraceConfig_CompressionConfig() = default; +TraceConfig_CompressionConfig::TraceConfig_CompressionConfig(const TraceConfig_CompressionConfig&) = default; +TraceConfig_CompressionConfig& TraceConfig_CompressionConfig::operator=(const TraceConfig_CompressionConfig&) = default; +TraceConfig_CompressionConfig::TraceConfig_CompressionConfig(TraceConfig_CompressionConfig&&) noexcept = default; +TraceConfig_CompressionConfig& TraceConfig_CompressionConfig::operator=(TraceConfig_CompressionConfig&&) = default; + +bool TraceConfig_CompressionConfig::operator==(const TraceConfig_CompressionConfig& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) + && ::protozero::internal::gen_helpers::EqualsField(deflate_, other.deflate_) + && ::protozero::internal::gen_helpers::EqualsField(zstd_, other.zstd_); +} + +bool TraceConfig_CompressionConfig::ParseFromArray(const void* raw, size_t size) { + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + case 1 /* deflate */: + (*deflate_).ParseFromArray(field.data(), field.size()); + break; + case 2 /* zstd */: + (*zstd_).ParseFromArray(field.data(), field.size()); + break; + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string TraceConfig_CompressionConfig::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector TraceConfig_CompressionConfig::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void TraceConfig_CompressionConfig::Serialize(::protozero::Message* msg) const { + // Field 1: deflate + if (_has_field_[1]) { + (*deflate_).Serialize(msg->BeginNestedMessage<::protozero::Message>(1)); + } + + // Field 2: zstd + if (_has_field_[2]) { + (*zstd_).Serialize(msg->BeginNestedMessage<::protozero::Message>(2)); + } + + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + + +TraceConfig_CompressionConfig_Zstd::TraceConfig_CompressionConfig_Zstd() = default; +TraceConfig_CompressionConfig_Zstd::~TraceConfig_CompressionConfig_Zstd() = default; +TraceConfig_CompressionConfig_Zstd::TraceConfig_CompressionConfig_Zstd(const TraceConfig_CompressionConfig_Zstd&) = default; +TraceConfig_CompressionConfig_Zstd& TraceConfig_CompressionConfig_Zstd::operator=(const TraceConfig_CompressionConfig_Zstd&) = default; +TraceConfig_CompressionConfig_Zstd::TraceConfig_CompressionConfig_Zstd(TraceConfig_CompressionConfig_Zstd&&) noexcept = default; +TraceConfig_CompressionConfig_Zstd& TraceConfig_CompressionConfig_Zstd::operator=(TraceConfig_CompressionConfig_Zstd&&) = default; + +bool TraceConfig_CompressionConfig_Zstd::operator==(const TraceConfig_CompressionConfig_Zstd& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) + && ::protozero::internal::gen_helpers::EqualsField(level_, other.level_); +} + +bool TraceConfig_CompressionConfig_Zstd::ParseFromArray(const void* raw, size_t size) { + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + case 1 /* level */: + field.get(&level_); + break; + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string TraceConfig_CompressionConfig_Zstd::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector TraceConfig_CompressionConfig_Zstd::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void TraceConfig_CompressionConfig_Zstd::Serialize(::protozero::Message* msg) const { + // Field 1: level + if (_has_field_[1]) { + ::protozero::internal::gen_helpers::SerializeVarInt(1, level_, msg); + } + + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + + +TraceConfig_CompressionConfig_Deflate::TraceConfig_CompressionConfig_Deflate() = default; +TraceConfig_CompressionConfig_Deflate::~TraceConfig_CompressionConfig_Deflate() = default; +TraceConfig_CompressionConfig_Deflate::TraceConfig_CompressionConfig_Deflate(const TraceConfig_CompressionConfig_Deflate&) = default; +TraceConfig_CompressionConfig_Deflate& TraceConfig_CompressionConfig_Deflate::operator=(const TraceConfig_CompressionConfig_Deflate&) = default; +TraceConfig_CompressionConfig_Deflate::TraceConfig_CompressionConfig_Deflate(TraceConfig_CompressionConfig_Deflate&&) noexcept = default; +TraceConfig_CompressionConfig_Deflate& TraceConfig_CompressionConfig_Deflate::operator=(TraceConfig_CompressionConfig_Deflate&&) = default; + +bool TraceConfig_CompressionConfig_Deflate::operator==(const TraceConfig_CompressionConfig_Deflate& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_); +} + +bool TraceConfig_CompressionConfig_Deflate::ParseFromArray(const void* raw, size_t size) { + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string TraceConfig_CompressionConfig_Deflate::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector TraceConfig_CompressionConfig_Deflate::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void TraceConfig_CompressionConfig_Deflate::Serialize(::protozero::Message* msg) const { + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + + TraceConfig_IncrementalStateConfig::TraceConfig_IncrementalStateConfig() = default; TraceConfig_IncrementalStateConfig::~TraceConfig_IncrementalStateConfig() = default; TraceConfig_IncrementalStateConfig::TraceConfig_IncrementalStateConfig(const TraceConfig_IncrementalStateConfig&) = default; @@ -31483,7 +31761,8 @@ bool TraceConfig_BuiltinDataSource::operator==(const TraceConfig_BuiltinDataSour && ::protozero::internal::gen_helpers::EqualsField(snapshot_interval_ms_, other.snapshot_interval_ms_) && ::protozero::internal::gen_helpers::EqualsField(prefer_suspend_clock_for_snapshot_, other.prefer_suspend_clock_for_snapshot_) && ::protozero::internal::gen_helpers::EqualsField(disable_chunk_usage_histograms_, other.disable_chunk_usage_histograms_) - && ::protozero::internal::gen_helpers::EqualsField(disable_extension_descriptors_, other.disable_extension_descriptors_); + && ::protozero::internal::gen_helpers::EqualsField(disable_extension_descriptors_, other.disable_extension_descriptors_) + && ::protozero::internal::gen_helpers::EqualsField(enable_concurrent_session_events_, other.enable_concurrent_session_events_); } bool TraceConfig_BuiltinDataSource::ParseFromArray(const void* raw, size_t size) { @@ -31523,6 +31802,9 @@ bool TraceConfig_BuiltinDataSource::ParseFromArray(const void* raw, size_t size) case 9 /* disable_extension_descriptors */: field.get(&disable_extension_descriptors_); break; + case 10 /* enable_concurrent_session_events */: + field.get(&enable_concurrent_session_events_); + break; default: field.SerializeAndAppendTo(&unknown_fields_); break; @@ -31589,6 +31871,11 @@ void TraceConfig_BuiltinDataSource::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeTinyVarInt(9, disable_extension_descriptors_, msg); } + // Field 10: enable_concurrent_session_events + if (_has_field_[10]) { + ::protozero::internal::gen_helpers::SerializeTinyVarInt(10, enable_concurrent_session_events_, msg); + } + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } @@ -31832,12 +32119,8 @@ void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_system_property.pbzero.cc // Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/camera_event.pbzero.cc -// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/android/cpu_per_uid_data.pbzero.cc // Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/frame_timeline_event.pbzero.cc -// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/android/graphics_frame_event.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/android/initial_display_state.pbzero.cc @@ -31872,6 +32155,8 @@ void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/vulkan_memory_event.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/inline_callstack.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/art_process_metadata.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/deobfuscation.pbzero.cc @@ -31882,6 +32167,8 @@ void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/smaps.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/profiling/stack_sample.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_active_processes.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/track_event/chrome_application_state_info.pbzero.cc @@ -37149,6 +37436,7 @@ bool TrackEvent::operator==(const TrackEvent& other) const { && ::protozero::internal::gen_helpers::EqualsField(correlation_id_str_iid_, other.correlation_id_str_iid_) && ::protozero::internal::gen_helpers::EqualsField(callstack_, other.callstack_) && ::protozero::internal::gen_helpers::EqualsField(callstack_iid_, other.callstack_iid_) + && ::protozero::internal::gen_helpers::EqualsField(callstack_weight_, other.callstack_weight_) && ::protozero::internal::gen_helpers::EqualsField(debug_annotations_, other.debug_annotations_) && ::protozero::internal::gen_helpers::EqualsField(task_execution_, other.task_execution_) && ::protozero::internal::gen_helpers::EqualsField(log_message_, other.log_message_) @@ -37275,6 +37563,9 @@ bool TrackEvent::ParseFromArray(const void* raw, size_t size) { case 56 /* callstack_iid */: field.get(&callstack_iid_); break; + case 57 /* callstack_weight */: + field.get(&callstack_weight_); + break; case 4 /* debug_annotations */: debug_annotations_.emplace_back(); debug_annotations_.back().ParseFromArray(field.data(), field.size()); @@ -37483,6 +37774,11 @@ void TrackEvent::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeVarInt(56, callstack_iid_, msg); } + // Field 57: callstack_weight + if (_has_field_[57]) { + ::protozero::internal::gen_helpers::SerializeFixed(57, callstack_weight_, msg); + } + // Field 4: debug_annotations for (auto& it : debug_annotations_) { it.Serialize(msg->BeginNestedMessage<::protozero::Message>(4)); @@ -37812,22 +38108,22 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const { } -TrackEvent_Callstack::TrackEvent_Callstack() = default; -TrackEvent_Callstack::~TrackEvent_Callstack() = default; -TrackEvent_Callstack::TrackEvent_Callstack(const TrackEvent_Callstack&) = default; -TrackEvent_Callstack& TrackEvent_Callstack::operator=(const TrackEvent_Callstack&) = default; -TrackEvent_Callstack::TrackEvent_Callstack(TrackEvent_Callstack&&) noexcept = default; -TrackEvent_Callstack& TrackEvent_Callstack::operator=(TrackEvent_Callstack&&) = default; +TrackEvent_InlineCallstack::TrackEvent_InlineCallstack() = default; +TrackEvent_InlineCallstack::~TrackEvent_InlineCallstack() = default; +TrackEvent_InlineCallstack::TrackEvent_InlineCallstack(const TrackEvent_InlineCallstack&) = default; +TrackEvent_InlineCallstack& TrackEvent_InlineCallstack::operator=(const TrackEvent_InlineCallstack&) = default; +TrackEvent_InlineCallstack::TrackEvent_InlineCallstack(TrackEvent_InlineCallstack&&) noexcept = default; +TrackEvent_InlineCallstack& TrackEvent_InlineCallstack::operator=(TrackEvent_InlineCallstack&&) = default; -bool TrackEvent_Callstack::operator==(const TrackEvent_Callstack& other) const { +bool TrackEvent_InlineCallstack::operator==(const TrackEvent_InlineCallstack& other) const { return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) && ::protozero::internal::gen_helpers::EqualsField(frames_, other.frames_); } -int TrackEvent_Callstack::frames_size() const { return static_cast(frames_.size()); } -void TrackEvent_Callstack::clear_frames() { frames_.clear(); } -TrackEvent_Callstack_Frame* TrackEvent_Callstack::add_frames() { frames_.emplace_back(); return &frames_.back(); } -bool TrackEvent_Callstack::ParseFromArray(const void* raw, size_t size) { +int TrackEvent_InlineCallstack::frames_size() const { return static_cast(frames_.size()); } +void TrackEvent_InlineCallstack::clear_frames() { frames_.clear(); } +TrackEvent_InlineCallstack_Frame* TrackEvent_InlineCallstack::add_frames() { frames_.emplace_back(); return &frames_.back(); } +bool TrackEvent_InlineCallstack::ParseFromArray(const void* raw, size_t size) { frames_.clear(); unknown_fields_.clear(); bool packed_error = false; @@ -37850,19 +38146,19 @@ bool TrackEvent_Callstack::ParseFromArray(const void* raw, size_t size) { return !packed_error && !dec.bytes_left(); } -std::string TrackEvent_Callstack::SerializeAsString() const { +std::string TrackEvent_InlineCallstack::SerializeAsString() const { ::protozero::internal::gen_helpers::MessageSerializer msg; Serialize(msg.get()); return msg.SerializeAsString(); } -std::vector TrackEvent_Callstack::SerializeAsArray() const { +std::vector TrackEvent_InlineCallstack::SerializeAsArray() const { ::protozero::internal::gen_helpers::MessageSerializer msg; Serialize(msg.get()); return msg.SerializeAsArray(); } -void TrackEvent_Callstack::Serialize(::protozero::Message* msg) const { +void TrackEvent_InlineCallstack::Serialize(::protozero::Message* msg) const { // Field 1: frames for (auto& it : frames_) { it.Serialize(msg->BeginNestedMessage<::protozero::Message>(1)); @@ -37872,21 +38168,21 @@ void TrackEvent_Callstack::Serialize(::protozero::Message* msg) const { } -TrackEvent_Callstack_Frame::TrackEvent_Callstack_Frame() = default; -TrackEvent_Callstack_Frame::~TrackEvent_Callstack_Frame() = default; -TrackEvent_Callstack_Frame::TrackEvent_Callstack_Frame(const TrackEvent_Callstack_Frame&) = default; -TrackEvent_Callstack_Frame& TrackEvent_Callstack_Frame::operator=(const TrackEvent_Callstack_Frame&) = default; -TrackEvent_Callstack_Frame::TrackEvent_Callstack_Frame(TrackEvent_Callstack_Frame&&) noexcept = default; -TrackEvent_Callstack_Frame& TrackEvent_Callstack_Frame::operator=(TrackEvent_Callstack_Frame&&) = default; +TrackEvent_InlineCallstack_Frame::TrackEvent_InlineCallstack_Frame() = default; +TrackEvent_InlineCallstack_Frame::~TrackEvent_InlineCallstack_Frame() = default; +TrackEvent_InlineCallstack_Frame::TrackEvent_InlineCallstack_Frame(const TrackEvent_InlineCallstack_Frame&) = default; +TrackEvent_InlineCallstack_Frame& TrackEvent_InlineCallstack_Frame::operator=(const TrackEvent_InlineCallstack_Frame&) = default; +TrackEvent_InlineCallstack_Frame::TrackEvent_InlineCallstack_Frame(TrackEvent_InlineCallstack_Frame&&) noexcept = default; +TrackEvent_InlineCallstack_Frame& TrackEvent_InlineCallstack_Frame::operator=(TrackEvent_InlineCallstack_Frame&&) = default; -bool TrackEvent_Callstack_Frame::operator==(const TrackEvent_Callstack_Frame& other) const { +bool TrackEvent_InlineCallstack_Frame::operator==(const TrackEvent_InlineCallstack_Frame& other) const { return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) && ::protozero::internal::gen_helpers::EqualsField(function_name_, other.function_name_) && ::protozero::internal::gen_helpers::EqualsField(source_file_, other.source_file_) && ::protozero::internal::gen_helpers::EqualsField(line_number_, other.line_number_); } -bool TrackEvent_Callstack_Frame::ParseFromArray(const void* raw, size_t size) { +bool TrackEvent_InlineCallstack_Frame::ParseFromArray(const void* raw, size_t size) { unknown_fields_.clear(); bool packed_error = false; @@ -37913,19 +38209,19 @@ bool TrackEvent_Callstack_Frame::ParseFromArray(const void* raw, size_t size) { return !packed_error && !dec.bytes_left(); } -std::string TrackEvent_Callstack_Frame::SerializeAsString() const { +std::string TrackEvent_InlineCallstack_Frame::SerializeAsString() const { ::protozero::internal::gen_helpers::MessageSerializer msg; Serialize(msg.get()); return msg.SerializeAsString(); } -std::vector TrackEvent_Callstack_Frame::SerializeAsArray() const { +std::vector TrackEvent_InlineCallstack_Frame::SerializeAsArray() const { ::protozero::internal::gen_helpers::MessageSerializer msg; Serialize(msg.get()); return msg.SerializeAsArray(); } -void TrackEvent_Callstack_Frame::Serialize(::protozero::Message* msg) const { +void TrackEvent_InlineCallstack_Frame::Serialize(::protozero::Message* msg) const { // Field 1: function_name if (_has_field_[1]) { ::protozero::internal::gen_helpers::SerializeString(1, function_name_, msg); @@ -38248,6 +38544,8 @@ void TrackEvent_Callstack_Frame::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/linux/journald_event.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/perfetto/concurrent_session_event.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/perfetto/perfetto_metatrace.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/perfetto/trace_provenance.pbzero.cc @@ -40472,12 +40770,6 @@ class PERFETTO_EXPORT_COMPONENT ConsumerEndpoint { }; // class ConsumerEndpoint. struct PERFETTO_EXPORT_COMPONENT TracingServiceInitOpts { - // Function used by tracing service to compress packets. Takes a pointer to - // a vector of TracePackets and replaces the packets in the vector with - // compressed ones. - using CompressorFn = void (*)(std::vector*); - CompressorFn compressor_fn = nullptr; - // An (optional) list of proto extension descriptors to dump into each trace // recorded. This is to support injecting protos that are known by the // embedder (e.g. the Android vendor image) but not by the upstream perfetto. @@ -40550,8 +40842,7 @@ class PERFETTO_EXPORT_COMPONENT TracingService { kDisabled }; - // Implemented in src/core/tracing_service_impl.cc . CompressorFn can be - // nullptr, in which case TracingService will not support compression. + // Implemented in src/core/tracing_service_impl.cc . static std::unique_ptr CreateInstance( std::unique_ptr, base::TaskRunner*, @@ -41681,6 +41972,24 @@ constexpr size_t kMaxCommitDataRequestChunkSize = 128 * 1024 - 512; // This is ipc::kIPCBufferSize - 512, see // |kMaxTracePacketSliceSize| in tracing_service_impl.h +// Conservative upper bound of a ChunkToPatch's serialized size, used to bound +// how many patches are packed into one request. Over-estimating only causes an +// extra split, never an oversized frame. +uint32_t EstimateChunkToPatchSize(const CommitDataRequest::ChunkToPatch& ctp) { + uint32_t size = 32; // Fixed fields + repeated-field tag/length. + for (const auto& patch : ctp.patches()) { + size += static_cast(patch.data().size()) + 16; // data + framing. + } + return size; +} + +// Conservative upper bound of a ChunkToMove's serialized size: the inlined +// chunk data plus field tags, varints and the submessage length prefix. As +// above, over-estimating only causes an extra split. +uint32_t EstimateChunkToMoveSize(const CommitDataRequest::ChunksToMove& ctm) { + return static_cast(ctm.data().size()) + 32; +} + MaybeUnboundBufferID MakeTargetBufferIdForReservation(uint16_t reservation_id) { // Reservation IDs are stored in the upper bits. PERFETTO_CHECK(reservation_id > 0); @@ -42293,13 +42602,17 @@ void SharedMemoryArbiterImpl::CommitDataWithSplitting( std::function callback) { PERFETTO_DCHECK(use_shmem_emulation_); - // If the request is small enough to be sent in a single IPC - // avoid the request splitting. - uint32_t total_bytes = 0; + // If the request is small enough to be sent in a single IPC avoid the request + // splitting. |estimated_bytes| includes a conservative bound for the patches, + // which are serialized into the request too. + uint32_t estimated_bytes = 0; for (const auto& ctm : req->chunks_to_move()) { - total_bytes += static_cast(ctm.data().size()); + estimated_bytes += EstimateChunkToMoveSize(ctm); } - if (total_bytes < kMaxCommitDataRequestChunkSize) { + for (const auto& ctp : req->chunks_to_patch()) { + estimated_bytes += EstimateChunkToPatchSize(ctp); + } + if (estimated_bytes < kMaxCommitDataRequestChunkSize) { producer_endpoint_->CommitData(*req, std::move(callback)); return; } @@ -42314,14 +42627,15 @@ void SharedMemoryArbiterImpl::CommitDataWithSplitting( // cannot be greater than |kMaxPageSize| in size, which is less than // |kIPCBufferSize|. We provide 512-bytes of headroom for message // overhead. - if (current_req_bytes + ctm.data().size() >= - kMaxCommitDataRequestChunkSize) { + uint32_t ctm_bytes = EstimateChunkToMoveSize(ctm); + if (current_req_bytes != 0 && + current_req_bytes + ctm_bytes >= kMaxCommitDataRequestChunkSize) { producer_endpoint_->CommitData(*split_req); split_req.reset(new CommitDataRequest()); current_req_bytes = 0; } - current_req_bytes += ctm.data().size(); + current_req_bytes += ctm_bytes; auto* new_ctm = split_req->add_chunks_to_move(); new_ctm->set_page(ctm.page()); new_ctm->set_chunk(ctm.chunk()); @@ -42330,15 +42644,26 @@ void SharedMemoryArbiterImpl::CommitDataWithSplitting( new_ctm->set_data(ctm.data()); } - // In shmem emulation mode, the pending commit data requests splitting - // is done on a best effort basis, meaning that although rare it is - // possible for the last commit data request to exceed the - // |kIPCBufferSize| since, we aren't checking the size of the chunk - // patches. - *split_req->mutable_chunks_to_patch() = - std::move(*req->mutable_chunks_to_patch()); - split_req->set_flush_request_id(req->flush_request_id()); + // Split the patches too, instead of appending all of them to the last + // request: a flush with many patched chunks could otherwise exceed the limit + // (see https://github.com/google/perfetto/issues/6426). Patches are applied + // after moves and IPC is ordered, so trailing patch requests preserve + // ordering. + for (auto& ctp : *req->mutable_chunks_to_patch()) { + uint32_t ctp_bytes = EstimateChunkToPatchSize(ctp); + // A lone ChunkToPatch always fits, so only ever split a non-empty request. + if (current_req_bytes != 0 && + current_req_bytes + ctp_bytes >= kMaxCommitDataRequestChunkSize) { + producer_endpoint_->CommitData(*split_req); + split_req.reset(new CommitDataRequest()); + current_req_bytes = 0; + } + current_req_bytes += ctp_bytes; + *split_req->add_chunks_to_patch() = std::move(ctp); + } + if (req->has_flush_request_id()) + split_req->set_flush_request_id(req->flush_request_id()); producer_endpoint_->CommitData(*split_req, std::move(callback)); } @@ -42606,14 +42931,14 @@ void SharedMemoryArbiterImpl::ScrapeEmulatedSharedMemoryBuffer( // This function must be called on the IPC thread. PERFETTO_CHECK(task_runner_->RunsTasksOnCurrentThread()); - CommitDataRequest commit_req; + auto commit_req = std::make_unique(); ForEachScrapableChunk(&shmem_abi_, [&](SharedMemoryABI::Chunk* chunk, bool chunk_complete, auto, auto) { const auto writer = buffer_for_writers.find(chunk->writer_id()); if (writer == buffer_for_writers.end()) return; BufferID target_buffer_id = writer->second; - auto* ctm = commit_req.add_chunks_to_move(); + auto* ctm = commit_req->add_chunks_to_move(); auto page_and_chunk = shmem_abi_.GetPageAndChunkIndex(*chunk); ctm->set_page(static_cast(page_and_chunk.first)); ctm->set_chunk(static_cast(page_and_chunk.second)); @@ -42621,9 +42946,12 @@ void SharedMemoryArbiterImpl::ScrapeEmulatedSharedMemoryBuffer( ctm->set_data(chunk->begin(), chunk->size()); ctm->set_chunk_incomplete(!chunk_complete); }); - if (commit_req.chunks_to_move_size() == 0) + if (commit_req->chunks_to_move_size() == 0) return; - producer_endpoint_->CommitData(commit_req); + // A scrape can pick up every in-flight chunk in the emulated SMB at once, + // which can easily exceed the IPC frame size limit, so it must go through + // the same splitting as regular commits. + CommitDataWithSplitting(std::move(commit_req), nullptr); } std::unique_ptr SharedMemoryArbiterImpl::CreateTraceWriterInternal( @@ -44248,19 +44576,13 @@ void DataSourceType::ClearIncrementalState( internal::DataSourceInstanceThreadLocalState* tls_inst, uint32_t instance_index, uint32_t actual_generation) { - if constexpr ( - PERFETTO_FLAGS_TRACK_EVENT_INCREMENTAL_STATE_CLEAR_NOT_DESTROY) { - // Try to clear the existing state if we have a clear function and the - // state exists. This allows reusing allocated memory instead of - // destroying and recreating the state object. - void* incremental_state = tls_inst->incremental_state.get(); - if (clear_incremental_state_fn_ && incremental_state && - clear_incremental_state_fn_(incremental_state, user_arg_)) { - tls_inst->incremental_state_generation = actual_generation; - } else { - tls_inst->incremental_state.reset(); - CreateIncrementalState(tls_inst, instance_index); - } + // Try to clear the existing state if we have a clear function and the + // state exists. This allows reusing allocated memory instead of + // destroying and recreating the state object. + void* incremental_state = tls_inst->incremental_state.get(); + if (clear_incremental_state_fn_ && incremental_state && + clear_incremental_state_fn_(incremental_state, user_arg_)) { + tls_inst->incremental_state_generation = actual_generation; } else { tls_inst->incremental_state.reset(); CreateIncrementalState(tls_inst, instance_index); @@ -46901,8 +47223,15 @@ bool TracingMuxerImpl::RegisterDataSource( bool no_flush, DataSourceStaticState* static_state) { // Ignore repeated registrations. - if (static_state->index != kMaxDataSources) + if (static_state->index != kMaxDataSources) { + PERFETTO_ELOG( + "Data source \"%s\" registration ignored: this data source type is " + "already registered. See " + "https://perfetto.dev/docs/instrumentation/" + "tracing-sdk#reporting-many-similar-things", + descriptor.name().c_str()); return true; + } uint32_t new_index = next_data_source_index_++; if (new_index >= kMaxDataSources) { @@ -48585,6 +48914,7 @@ void TracingMuxerImpl::Shutdown() { std::unique_ptr owned_task_runner( muxer->task_runner_.get()); + Platform* platform = muxer->platform_; base::WaitableEvent shutdown_done; owned_task_runner->PostTask([muxer, &shutdown_done] { // Check that no consumer session is currently active on any backend. @@ -48602,13 +48932,17 @@ void TracingMuxerImpl::Shutdown() { // The task runner must be deleted outside the muxer thread. This is done by // `owned_task_runner` above. muxer->task_runner_.release(); - auto* platform = muxer->platform_; delete muxer; instance_ = TracingMuxerFake::Get(); - platform->Shutdown(); shutdown_done.Notify(); }); shutdown_done.Wait(); + + // Join the muxer thread before the platform (and its TLS key) is destroyed. + owned_task_runner.reset(); + + // On the calling thread, so the platform can free this thread's TLS object. + platform->Shutdown(); } void TracingMuxerImpl::AppendResetForTestingCallback(std::function cb) { @@ -48736,7 +49070,7 @@ class NoDestructor { // gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet_defaults.pbzero.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/debug_annotation.pbzero.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/track_descriptor.pbzero.h" -#if PERFETTO_BUILDFLAG(PERFETTO_OS_MAC) +#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) #include #endif @@ -49164,7 +49498,7 @@ void TrackEventInternal::ResetIncrementalState( thread_time_counter_track.uuid); } -#if PERFETTO_BUILDFLAG(PERFETTO_OS_MAC) +#if PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) // Emit a MacOS point-of-interest signpost to synchronize Mac profiler time // with boot time. // TODO(leszeks): Consider allowing synchronization against other clocks @@ -49689,6 +50023,9 @@ PlatformWindows::PlatformWindows() { } PlatformWindows::~PlatformWindows() { + // TlsFree doesn't call destructors, so do it manually for the calling + // thread. + OnThreadExit(); ::TlsFree(tls_key_); instance = nullptr; } @@ -52198,8 +52535,8 @@ const char* GetVersionCode(); #ifndef GEN_PERFETTO_VERSION_GEN_H_ #define GEN_PERFETTO_VERSION_GEN_H_ -#define PERFETTO_VERSION_STRING() "v57.2-da1d152cf" -#define PERFETTO_VERSION_SCM_REVISION() "da1d152cff27890903d158fe96751de3aab883cc" +#define PERFETTO_VERSION_STRING() "v58.2-add693d8b" +#define PERFETTO_VERSION_SCM_REVISION() "add693d8b338ba9599dbcbc3e300b1ab8c000897" #endif // GEN_PERFETTO_VERSION_GEN_H_ /* @@ -59162,6 +59499,419 @@ perfetto::base::Status LoadMessageFilterConfig(const TraceFilter& filt, } } // namespace protozero +// gen_amalgamated begin source: src/tracing/service/zlib_compressor.cc +// gen_amalgamated begin header: src/tracing/service/zlib_compressor.h +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ +#define SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ + +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h" + +namespace perfetto { + +#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) +void ZlibCompressFn(std::vector*); +#endif + +} // namespace perfetto + +#endif // SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "src/tracing/service/zlib_compressor.h" + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + +// File compiles to nothing when the buildflag is off (e.g. SDK opt-out). +#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) + +#include + +// gen_amalgamated expanded: #include "protos/perfetto/trace/trace.pbzero.h" +// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h" +// gen_amalgamated expanded: #include "src/tracing/service/packet_compressor_common.h" + +namespace perfetto { + +namespace { + +using packet_compressor::GetPreamble; +using packet_compressor::kCompressSliceSize; +using packet_compressor::Preamble; +using packet_compressor::PreambleToSlice; + +// A compressor for `TracePacket`s that uses zlib. The class is exposed for +// testing. +class ZlibPacketCompressor { + public: + ZlibPacketCompressor(); + ~ZlibPacketCompressor(); + + // Can be called multiple times, before Finish() is called. + void PushPacket(const TracePacket& packet); + + // Returned the compressed data. Can be called at most once. After this call, + // the object is unusable (PushPacket should not be called) and must be + // destroyed. + TracePacket Finish(); + + private: + void PushData(const void* data, uint32_t size); + void NewOutputSlice(); + void PushCurSlice(); + + z_stream stream_; + size_t total_new_slices_size_ = 0; + std::vector new_slices_; + std::unique_ptr cur_slice_; +}; + +ZlibPacketCompressor::ZlibPacketCompressor() { + memset(&stream_, 0, sizeof(stream_)); + int status = deflateInit(&stream_, 6); + PERFETTO_CHECK(status == Z_OK); +} + +ZlibPacketCompressor::~ZlibPacketCompressor() { + int status = deflateEnd(&stream_); + PERFETTO_CHECK(status == Z_OK); +} + +void ZlibPacketCompressor::PushPacket(const TracePacket& packet) { + // We need to be able to tokenize packets in the compressed stream, so we + // prefix a proto preamble to each packet. The compressed stream looks like a + // valid Trace proto. + Preamble preamble = + GetPreamble(packet.size()); + PushData(preamble.buf.data(), preamble.size); + for (const Slice& slice : packet.slices()) { + PushData(slice.start, static_cast(slice.size)); + } +} + +void ZlibPacketCompressor::PushData(const void* data, uint32_t size) { + stream_.next_in = const_cast(static_cast(data)); + stream_.avail_in = static_cast(size); + while (stream_.avail_in != 0) { + if (stream_.avail_out == 0) { + NewOutputSlice(); + } + int status = deflate(&stream_, Z_NO_FLUSH); + PERFETTO_CHECK(status == Z_OK); + } +} + +TracePacket ZlibPacketCompressor::Finish() { + for (;;) { + int status = deflate(&stream_, Z_FINISH); + if (status == Z_STREAM_END) + break; + PERFETTO_CHECK(status == Z_OK || status == Z_BUF_ERROR); + NewOutputSlice(); + } + + PushCurSlice(); + + TracePacket packet; + packet.AddSlice(PreambleToSlice( + GetPreamble( + total_new_slices_size_))); + for (auto& slice : new_slices_) { + packet.AddSlice(std::move(slice)); + } + return packet; +} + +void ZlibPacketCompressor::NewOutputSlice() { + PushCurSlice(); + cur_slice_ = std::make_unique(kCompressSliceSize); + stream_.next_out = reinterpret_cast(cur_slice_.get()); + stream_.avail_out = kCompressSliceSize; +} + +void ZlibPacketCompressor::PushCurSlice() { + if (cur_slice_) { + total_new_slices_size_ += kCompressSliceSize - stream_.avail_out; + new_slices_.push_back(Slice::TakeOwnership( + std::move(cur_slice_), kCompressSliceSize - stream_.avail_out)); + } +} + +} // namespace + +void ZlibCompressFn(std::vector* packets) { + if (packets->empty()) { + return; + } + + ZlibPacketCompressor stream; + + for (const TracePacket& packet : *packets) { + stream.PushPacket(packet); + } + + TracePacket packet = stream.Finish(); + + packets->clear(); + packets->push_back(std::move(packet)); +} + +} // namespace perfetto + +#endif // PERFETTO_BUILDFLAG(PERFETTO_ZLIB) +// gen_amalgamated begin source: src/tracing/service/zstd_compressor.cc +// gen_amalgamated begin header: src/tracing/service/zstd_compressor.h +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SRC_TRACING_SERVICE_ZSTD_COMPRESSOR_H_ +#define SRC_TRACING_SERVICE_ZSTD_COMPRESSOR_H_ + +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h" + +namespace perfetto { + +#if PERFETTO_BUILDFLAG(PERFETTO_ZSTD) +// Compresses `packets` with zstd at the given compression `level`. +void ZstdCompressFn(std::vector*, int level); +#endif + +} // namespace perfetto + +#endif // SRC_TRACING_SERVICE_ZSTD_COMPRESSOR_H_ +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "src/tracing/service/zstd_compressor.h" + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + +#if PERFETTO_BUILDFLAG(PERFETTO_ZSTD) + +#include + +#include + +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" +// gen_amalgamated expanded: #include "protos/perfetto/trace/trace.pbzero.h" +// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h" +// gen_amalgamated expanded: #include "src/tracing/service/packet_compressor_common.h" + +namespace perfetto { + +namespace { + +using packet_compressor::GetPreamble; +using packet_compressor::kCompressSliceSize; +using packet_compressor::Preamble; +using packet_compressor::PreambleToSlice; + +// ScopedResource's close function must return int; ZSTD_freeCStream returns +// size_t, so wrap it. It only fails for a static-allocated stream, not the +// heap one ZSTD_createCStream gives us, so returning 0 is safe. +inline int ZstdFreeCStream(ZSTD_CStream* cstream) { + ZSTD_freeCStream(cstream); + return 0; +} +using ScopedZstdCStream = base::ScopedResource; + +// A compressor for `TracePacket`s that uses zstd's streaming API: data is fed +// in with ZSTD_compressStream2(ZSTD_e_continue) and the frame is finalized with +// ZSTD_e_end, emitting output in fixed-size slices (kCompressSliceSize). +// zstd API reference: https://facebook.github.io/zstd/zstd_manual.html +class ZstdPacketCompressor { + public: + explicit ZstdPacketCompressor(int level); + + // Can be called multiple times, before Finish() is called. + void PushPacket(const TracePacket& packet); + + // Returns the compressed data. Can be called at most once. After this call, + // the object is unusable (PushPacket should not be called) and must be + // destroyed. + TracePacket Finish(); + + private: + void PushData(const void* data, uint32_t size); + void NewOutputSlice(); + void PushCurSlice(); + + ScopedZstdCStream cstream_; + // Points into `cur_slice_`. Zero-initialized so that the first compression + // call observes a full output buffer and allocates the initial slice. + ZSTD_outBuffer out_{/*dst=*/nullptr, /*size=*/0, /*pos=*/0}; + size_t total_new_slices_size_ = 0; + std::vector new_slices_; + std::unique_ptr cur_slice_; +}; + +ZstdPacketCompressor::ZstdPacketCompressor(int level) { + cstream_.reset(ZSTD_createCStream()); + PERFETTO_CHECK(cstream_); + // zstd maps 0 to its default level, clamps levels above its max, and treats + // negatives as fast modes, so any int is safe to pass through here. + size_t rc = + ZSTD_CCtx_setParameter(cstream_.get(), ZSTD_c_compressionLevel, level); + PERFETTO_CHECK(!ZSTD_isError(rc)); +} + +void ZstdPacketCompressor::PushPacket(const TracePacket& packet) { + // Prefix each packet with its proto preamble so the compressed stream itself + // parses as a valid Trace proto, and its packets can be tokenized back out. + Preamble preamble = + GetPreamble(packet.size()); + PushData(preamble.buf.data(), preamble.size); + for (const Slice& slice : packet.slices()) { + PushData(slice.start, static_cast(slice.size)); + } +} + +void ZstdPacketCompressor::PushData(const void* data, uint32_t size) { + // ZSTD_e_continue hands data to the encoder, which buffers and emits at its + // own discretion. It may not consume all input in one call (e.g. when the + // output slice fills), so loop until `in` is drained, giving it a fresh slice + // whenever `out_` is full. + ZSTD_inBuffer in = {/*src=*/data, /*size=*/size, /*pos=*/0}; + while (in.pos < in.size) { + if (out_.pos == out_.size) { + NewOutputSlice(); + } + size_t rc = + ZSTD_compressStream2(cstream_.get(), &out_, &in, ZSTD_e_continue); + PERFETTO_CHECK(!ZSTD_isError(rc)); + } +} + +TracePacket ZstdPacketCompressor::Finish() { + // ZSTD_e_end flushes buffered data and writes the frame epilogue. Per the + // contract, keep calling (draining `out_` into new slices) until it reports 0 + // bytes remaining. + size_t remaining; + do { + if (out_.pos == out_.size) { + NewOutputSlice(); + } + ZSTD_inBuffer in = {/*src=*/nullptr, /*size=*/0, /*pos=*/0}; + remaining = ZSTD_compressStream2(cstream_.get(), &out_, &in, ZSTD_e_end); + PERFETTO_CHECK(!ZSTD_isError(remaining)); + } while (remaining != 0); + + PushCurSlice(); + + TracePacket packet; + packet.AddSlice(PreambleToSlice( + GetPreamble< + protos::pbzero::TracePacket::kZstdCompressedPacketsFieldNumber>( + total_new_slices_size_))); + for (auto& slice : new_slices_) { + packet.AddSlice(std::move(slice)); + } + return packet; +} + +void ZstdPacketCompressor::NewOutputSlice() { + PushCurSlice(); + cur_slice_ = std::make_unique(kCompressSliceSize); + out_.dst = cur_slice_.get(); + out_.size = kCompressSliceSize; + out_.pos = 0; +} + +void ZstdPacketCompressor::PushCurSlice() { + if (!cur_slice_) { + return; + } + total_new_slices_size_ += out_.pos; + new_slices_.push_back(Slice::TakeOwnership(std::move(cur_slice_), out_.pos)); +} + +} // namespace + +void ZstdCompressFn(std::vector* packets, int level) { + if (packets->empty()) { + return; + } + + ZstdPacketCompressor stream(level); + + for (const TracePacket& packet : *packets) { + stream.PushPacket(packet); + } + + TracePacket packet = stream.Finish(); + + packets->clear(); + packets->push_back(std::move(packet)); +} + +} // namespace perfetto + +#endif // PERFETTO_BUILDFLAG(PERFETTO_ZSTD) // gen_amalgamated begin source: src/tracing/service/clock.cc // gen_amalgamated begin header: src/tracing/service/clock.h /* @@ -59514,6 +60264,7 @@ const uint32_t kReservedFieldIds[] = { protos::pbzero::TracePacket::kTraceConfigFieldNumber, protos::pbzero::TracePacket::kTraceStatsFieldNumber, protos::pbzero::TracePacket::kCompressedPacketsFieldNumber, + protos::pbzero::TracePacket::kZstdCompressedPacketsFieldNumber, protos::pbzero::TracePacket::kSynchronizationMarkerFieldNumber, protos::pbzero::TracePacket::kTrustedPidFieldNumber, protos::pbzero::TracePacket::kMachineIdFieldNumber, @@ -59944,12 +60695,10 @@ class TraceBuffer { // Type of trace buffer implementation. // TODO(primiano): remove this once TraceBufferV2 proves itself. - // kV2 is experimental and kV1WithV2Shadow is a testing-only class that - // is used to gather confidence that the two return the same results. + // kV2 is experimental. enum BufType { kV1, kV2, - kV1WithV2Shadow, }; // Argument for out-of-band patches applied through TryPatchChunkContents(). @@ -61729,139 +62478,7 @@ TraceBufferV1::TraceBufferV1(CloneCtor, const TraceBufferV1& src) TraceBuffer::~TraceBuffer() = default; } // namespace perfetto -// gen_amalgamated begin source: src/tracing/service/trace_buffer_v1_with_v2_shadow.cc -// gen_amalgamated begin header: src/tracing/service/trace_buffer_v1_with_v2_shadow.h -/* - * Copyright (C) 2025 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef SRC_TRACING_SERVICE_TRACE_BUFFER_V1_WITH_V2_SHADOW_H_ -#define SRC_TRACING_SERVICE_TRACE_BUFFER_V1_WITH_V2_SHADOW_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/ext/base/flat_hash_map.h" -// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h" - -namespace perfetto { - -class TracePacket; - -// **************************************************************************** -// * THIS IS A TEMPORARY CLASS FOR TESTING PURPOSES ONLY. * -// * It will be removed once TraceBufferV2 is validated and fully rolled out. * -// **************************************************************************** -// -// A wrapper around TraceBufferV1 that also maintains a TraceBufferV2 shadow -// buffer for comparison purposes. All data is written to both buffers, but -// only V1 data is returned during readback. Comparison statistics are -// computed to validate that V2 returns equivalent data. -// -// The comparison works as follows: -// - CopyChunkUntrusted/TryPatchChunkContents: forwarded to both V1 and V2 -// - BeginRead: forwarded to both. V2 is eagerly read to completion and packet -// hashes are stored. -// - ReadNextTracePacket: forwarded to V1 only. Each V1 packet's hash is -// compared against V2 hashes. -// - stats(): returns V1's stats with shadow comparison fields populated. -class TraceBufferV1WithV2Shadow : public TraceBuffer { - public: - static std::unique_ptr Create(size_t size_in_bytes, - OverwritePolicy); - - ~TraceBufferV1WithV2Shadow() override; - - // TraceBuffer implementation - forwards to both V1 and V2. - void CopyChunkUntrusted(ProducerID producer_id_trusted, - const ClientIdentity& client_identity_trusted, - WriterID writer_id, - ChunkID chunk_id, - uint16_t num_fragments, - uint8_t chunk_flags, - bool chunk_complete, - const uint8_t* src, - size_t size) override; - - bool TryPatchChunkContents(ProducerID, - WriterID, - ChunkID, - const Patch* patches, - size_t patches_size, - bool other_patches_pending) override; - - // BeginRead forwards to both. V2 is eagerly read and hashes are stored. - void BeginRead() override; - - // ReadNextTracePacket forwards to V1 only. Hash comparison is performed. - bool ReadNextTracePacket( - TracePacket*, - PacketSequenceProperties* sequence_properties, - uint32_t* previous_packet_on_sequence_dropped) override; - - std::unique_ptr CloneReadOnly() const override; - - // Stats returns V1's stats with shadow comparison fields populated. - const TraceStats::BufferStats& stats() const override; - - // These all forward to V1 only. - void set_read_only() override; - const WriterStats& writer_stats() const override; - size_t size() const override; - size_t used_size() const override; - size_t GetMemoryUsageBytes() const override; - OverwritePolicy overwrite_policy() const override; - bool has_data() const override; - BufType buf_type() const override { return kV1WithV2Shadow; } - - private: - TraceBufferV1WithV2Shadow(); - - // Updates the shadow comparison stats in stats_. - void UpdateShadowStats() const; - - static constexpr uint8_t kSeenInV1 = 1 << 0; - static constexpr uint8_t kSeenInV2 = 1 << 1; - - std::unique_ptr v1_; - std::unique_ptr v2_; - - struct HashPacketCounts { - uint16_t seen_in_v1 = 0; - uint16_t seen_in_v2 = 0; - }; - base::FlatHashMap, - base::QuadraticProbe, - /*AppendOnly=*/true> - packet_hashes_; - uint64_t packets_seen_ = 0; - - // Patch statistics. - uint64_t patches_attempted_ = 0; - uint64_t v1_patches_succeeded_ = 0; - uint64_t v2_patches_succeeded_ = 0; - - // Cached stats that combines V1 stats with shadow comparison results. - mutable TraceStats::BufferStats stats_; -}; - -} // namespace perfetto - -#endif // SRC_TRACING_SERVICE_TRACE_BUFFER_V1_WITH_V2_SHADOW_H_ +// gen_amalgamated begin source: src/tracing/service/trace_buffer_v2.cc // gen_amalgamated begin header: src/tracing/service/trace_buffer_v2.h // gen_amalgamated begin header: include/perfetto/ext/base/circular_queue.h /* @@ -63139,240 +63756,6 @@ class TraceBufferV2 : public TraceBuffer { * limitations under the License. */ -// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1_with_v2_shadow.h" - -// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h" -// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h" -// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1.h" -// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v2.h" - -// **************************************************************************** -// * THIS IS A TEMPORARY CLASS FOR TESTING PURPOSES ONLY. * -// * It will be removed once TraceBufferV2 is validated and fully rolled out. * -// * See the header file for detailed documentation. * -// **************************************************************************** - -namespace perfetto { - -namespace { - -// Stop processing hashes after these many packets. After this point we lose -// stats accuracy for the sake of keeping memory bounded. -constexpr size_t kMaxPacketHashes = 1000000; - -uint64_t ComputePacketHash( - const TracePacket& packet, - const TraceBuffer::PacketSequenceProperties& seq_props) { - base::MurmurHashCombiner hasher; - for (const Slice& slice : packet.slices()) { - hasher.Combine(std::string_view(reinterpret_cast(slice.start), - slice.size)); - } - hasher.Combine(seq_props.producer_id_trusted); - hasher.Combine(seq_props.writer_id); - return hasher.digest(); -} - -void IncrementWithSaturation(uint16_t* v) { - *v += *v < UINT16_MAX ? 1 : 0; -} - -} // namespace - -TraceBufferV1WithV2Shadow::TraceBufferV1WithV2Shadow() = default; -TraceBufferV1WithV2Shadow::~TraceBufferV1WithV2Shadow() = default; - -// static -std::unique_ptr TraceBufferV1WithV2Shadow::Create( - size_t size_in_bytes, - OverwritePolicy policy) { - auto v1 = TraceBufferV1::Create(size_in_bytes, policy); - auto v2 = TraceBufferV2::Create(size_in_bytes, policy); - if (!v1 || !v2) - return nullptr; - - std::unique_ptr instance( - new TraceBufferV1WithV2Shadow()); - instance->v1_ = std::move(v1); - instance->v2_ = std::move(v2); - return instance; -} - -void TraceBufferV1WithV2Shadow::CopyChunkUntrusted( - ProducerID producer_id_trusted, - const ClientIdentity& client_identity_trusted, - WriterID writer_id, - ChunkID chunk_id, - uint16_t num_fragments, - uint8_t chunk_flags, - bool chunk_complete, - const uint8_t* src, - size_t size) { - v1_->CopyChunkUntrusted(producer_id_trusted, client_identity_trusted, - writer_id, chunk_id, num_fragments, chunk_flags, - chunk_complete, src, size); - v2_->CopyChunkUntrusted(producer_id_trusted, client_identity_trusted, - writer_id, chunk_id, num_fragments, chunk_flags, - chunk_complete, src, size); -} - -bool TraceBufferV1WithV2Shadow::TryPatchChunkContents( - ProducerID producer_id, - WriterID writer_id, - ChunkID chunk_id, - const Patch* patches, - size_t patches_size, - bool other_patches_pending) { - patches_attempted_++; - bool v1_result = - v1_->TryPatchChunkContents(producer_id, writer_id, chunk_id, patches, - patches_size, other_patches_pending); - bool v2_result = - v2_->TryPatchChunkContents(producer_id, writer_id, chunk_id, patches, - patches_size, other_patches_pending); - if (v1_result) - v1_patches_succeeded_++; - if (v2_result) - v2_patches_succeeded_++; - return v1_result; -} - -void TraceBufferV1WithV2Shadow::BeginRead() { - v1_->BeginRead(); - - if (packets_seen_ > kMaxPacketHashes) - return; - - // Read all V2 packets eagerly and store their hashes. - v2_->BeginRead(); - - for (;;) { - TracePacket packet; - PacketSequenceProperties seq_props{}; - uint32_t prev_dropped = 0; - if (!v2_->ReadNextTracePacket(&packet, &seq_props, &prev_dropped)) - break; - auto hash = ComputePacketHash(packet, seq_props); - IncrementWithSaturation(&packet_hashes_[hash].seen_in_v2); - } -} - -bool TraceBufferV1WithV2Shadow::ReadNextTracePacket( - TracePacket* packet, - PacketSequenceProperties* sequence_properties, - uint32_t* previous_packet_on_sequence_dropped) { - bool result = v1_->ReadNextTracePacket(packet, sequence_properties, - previous_packet_on_sequence_dropped); - if (result && packets_seen_ < kMaxPacketHashes) { - auto hash = ComputePacketHash(*packet, *sequence_properties); - IncrementWithSaturation(&packet_hashes_[hash].seen_in_v1); - ++packets_seen_; - } - return result; -} - -std::unique_ptr TraceBufferV1WithV2Shadow::CloneReadOnly() const { - auto v1_clone = v1_->CloneReadOnly(); - auto v2_clone = v2_->CloneReadOnly(); - if (!v1_clone || !v2_clone) - return nullptr; - - std::unique_ptr clone( - new TraceBufferV1WithV2Shadow()); - clone->v1_ = std::move(v1_clone); - clone->v2_ = std::move(v2_clone); - // Carry over patch stats; clone starts with fresh comparison state. - clone->patches_attempted_ = patches_attempted_; - clone->v1_patches_succeeded_ = v1_patches_succeeded_; - clone->v2_patches_succeeded_ = v2_patches_succeeded_; - return clone; -} - -const TraceStats::BufferStats& TraceBufferV1WithV2Shadow::stats() const { - UpdateShadowStats(); - return stats_; -} - -void TraceBufferV1WithV2Shadow::UpdateShadowStats() const { - // Copy V1's stats as the base. - stats_ = v1_->stats(); - - // Count packets. - uint64_t packets_in_both = 0; - uint64_t packets_only_v1 = 0; - uint64_t packets_only_v2 = 0; - for (auto it = packet_hashes_.GetIterator(); it; ++it) { - HashPacketCounts& counts = it.value(); - if (counts.seen_in_v1 <= counts.seen_in_v2) { - packets_in_both += counts.seen_in_v1; - packets_only_v2 += counts.seen_in_v2 - counts.seen_in_v1; - } else { - packets_in_both += counts.seen_in_v2; - packets_only_v1 += counts.seen_in_v1 - counts.seen_in_v2; - } - } - - // Populate shadow buffer stats. - auto* shadow_stats = stats_.mutable_shadow_buffer_stats(); - shadow_stats->set_stats_version(2); - shadow_stats->set_packets_seen(packets_seen_); - shadow_stats->set_packets_in_both(packets_in_both); - shadow_stats->set_packets_only_v1(packets_only_v1); - shadow_stats->set_packets_only_v2(packets_only_v2); - shadow_stats->set_patches_attempted(patches_attempted_); - shadow_stats->set_v1_patches_succeeded(v1_patches_succeeded_); - shadow_stats->set_v2_patches_succeeded(v2_patches_succeeded_); -} - -void TraceBufferV1WithV2Shadow::set_read_only() { - v1_->set_read_only(); - v2_->set_read_only(); -} - -const TraceBuffer::WriterStats& TraceBufferV1WithV2Shadow::writer_stats() - const { - return v1_->writer_stats(); -} - -size_t TraceBufferV1WithV2Shadow::size() const { - return v1_->size(); -} - -size_t TraceBufferV1WithV2Shadow::used_size() const { - return v1_->used_size(); -} - -size_t TraceBufferV1WithV2Shadow::GetMemoryUsageBytes() const { - return v1_->GetMemoryUsageBytes() + v2_->GetMemoryUsageBytes(); -} - -TraceBuffer::OverwritePolicy TraceBufferV1WithV2Shadow::overwrite_policy() - const { - return v1_->overwrite_policy(); -} - -bool TraceBufferV1WithV2Shadow::has_data() const { - return v1_->has_data(); -} - -} // namespace perfetto -// gen_amalgamated begin source: src/tracing/service/trace_buffer_v2.cc -/* - * Copyright (C) 2025 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - // gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v2.h" #include @@ -64098,9 +64481,13 @@ void TraceBufferV2::CopyChunkUntrusted( std::optional maybe_frag = frag_iter.NextFragmentInChunk(); if (!maybe_frag.has_value()) { // Either we found less fragments than what the header said, or some - // fragment is out of bounds. - stats_.set_abi_violations(stats_.abi_violations() + 1); - PERFETTO_DCHECK(suppress_client_dchecks_for_testing_); + // fragment is out of bounds. The exception is a TraceWriter that + // deliberately aborted the packet (kPacketSizeDropPacket), which is not + // an ABI violation and is accounted via trace_writer_packet_loss. + if (!frag_iter.trace_writer_data_drop()) { + stats_.set_abi_violations(stats_.abi_violations() + 1); + PERFETTO_DCHECK(suppress_client_dchecks_for_testing_); + } break; } Frag& f = *maybe_frag; @@ -64218,24 +64605,68 @@ void TraceBufferV2::CopyChunkUntrusted( PERFETTO_DCHECK(suppress_client_dchecks_for_testing_); return; } - // Only clear kChunkIncomplete on real IPC recommits (chunk_complete=true). - // During scraping the producer may still be writing, so the chunk should - // remain incomplete until the producer explicitly commits it. - if (chunk_complete) - recommit_chunk->flags &= ~kChunkIncomplete; - if (all_frags_size == recommit_chunk->payload_size) { - TRACE_BUFFER_V2_DLOG(" skipping recommit of identical chunk"); + + // Decide whether to relocate this re-commit rather than rewrite it in + // place. A scraped chunk that has been fully read keeps its copy at the + // offset where it was scraped, which can sit arbitrarily close to the + // write cursor, so the recovered packets could be overwritten before the + // next read. Relocating skips the already-consumed payload as in the + // re-admit of evicted chunks above. See b/518755701 for more details. + + // The copy came from a scrape, so more payload may still be coming. + const bool copy_is_scraped = recommit_chunk->flags & kChunkIncomplete; + + // Nothing for the erase to lose, nothing for the relocation to duplicate. + const bool copy_fully_consumed = recommit_chunk->payload_avail == 0; + + // The producer's final commit (not another scrape), with new fragments. + const bool commit_adds_new_data = + chunk_complete && all_frags_size > recommit_chunk->payload_size; + + // EraseCurrentChunk() only supports the first chunk of a sequence. Later + // chunks may stay physically ahead of the relocated one, which is fine: + // reads follow chunk_list, which is ordered by ChunkID and not by offset. + const bool copy_is_first_chunk_of_seq = + *chunk_list.begin() == OffsetOf(recommit_chunk); + + // Only a ring buffer laps, so only there can the stale copy be overwritten. + // On kDiscard, routing the commit through the write path below could also + // hit the end-of-buffer DiscardWrite(), dropping the very fragments we are + // recovering and sealing the buffer for good. + const bool buffer_can_lap = overwrite_policy_ == kOverwrite; + + const bool should_relocate_chunk = + copy_is_scraped && copy_fully_consumed && commit_adds_new_data && + copy_is_first_chunk_of_seq && buffer_can_lap; + + if (PERFETTO_LIKELY(!should_relocate_chunk)) { + // Only clear kChunkIncomplete on real IPC recommits + // (chunk_complete=true). During scraping the producer may still be + // writing, so the chunk should remain incomplete until the producer + // explicitly commits it. + if (chunk_complete) + recommit_chunk->flags &= ~kChunkIncomplete; + if (all_frags_size == recommit_chunk->payload_size) { + TRACE_BUFFER_V2_DLOG(" skipping recommit of identical chunk"); + return; + } + uint16_t payload_consumed = + recommit_chunk->payload_size - recommit_chunk->payload_avail; + recommit_chunk->payload_size = all_frags_size_u16; + recommit_chunk->payload_avail = all_frags_size_u16 - payload_consumed; + memcpy(recommit_chunk->fragments_begin(), src, all_frags_size); + recommit_chunk->flags |= chunk_flags; + stats_.set_chunks_rewritten(stats_.chunks_rewritten() + 1); return; } - uint16_t payload_consumed = - recommit_chunk->payload_size - recommit_chunk->payload_avail; - recommit_chunk->payload_size = all_frags_size_u16; - recommit_chunk->payload_avail = all_frags_size_u16 - payload_consumed; - memcpy(recommit_chunk->fragments_begin(), src, all_frags_size); - recommit_chunk->flags |= chunk_flags; - stats_.set_chunks_rewritten(stats_.chunks_rewritten() + 1); - return; - } + + // Erase the stale copy and fall through to the write path below, which + // re-creates the chunk at the write cursor. + TRACE_BUFFER_V2_DLOG(" Relocating consumed scraped chunk %u", chunk_id); + stats_.set_chunks_relocated(stats_.chunks_relocated() + 1); + previously_consumed_payload = recommit_chunk->payload_size; + internal::ChunkSeqIterator(this, &seq).EraseCurrentChunk(); + } // if (recommit_chunk) // If there isn't enough room from the given write position: write a padding // record to clear the end of the buffer, wrap and start at offset 0. @@ -64259,8 +64690,9 @@ void TraceBufferV2::CopyChunkUntrusted( // Deletes all chunks from |wptr_| to |wptr_| + |record_size|. DeleteNextChunksFor(tbchunk_outer_size); - // If the DeleteNextChunksFor happens to delete a chunk in the same sequence, - // the insert_pos becomes invalid and we need to recompute that. + // |insert_pos| is invalid if any chunk was removed from this sequence since + // it was computed: either by the DeleteNextChunksFor above, or by the + // relocation erase. // Why don't we compute the insert_pos here? Because we also need to check // for re-commits (which are rare, but possible) and don't want to iterate // over the chunk list twice in most cases. @@ -65293,6 +65725,11 @@ struct TracingSession { // session. bool IsCloneAllowed(uid_t clone_uid) const; + // Records |src|'s current state into concurrent_session_events, dropping the + // event once the buffer hits the limit. The cap bounds memory, as the buffer + // is drained only on ReadBuffers(). + void AddConcurrentSessionEventWithLimit(const TracingSession& src); + const TracingSessionID id; // The consumer that started the session. @@ -65355,9 +65792,6 @@ struct TracingSession { // Whether we emitted the ProtoVM instances. bool did_emit_protovm_instances_ = false; - // Whether we should compress TracePackets after reading them. - bool compress_deflate = false; - // The number of received triggers we've emitted into the trace output. size_t num_triggers_emitted_into_trace = 0; @@ -65426,6 +65860,26 @@ struct TracingSession { State state = DISABLED; + // BOOTTIME (ns) when this session entered its current state. Maintained + // solely by SetSessionState(), which every state transition goes through. + // Used as the timestamp when this session is snapshotted into another + // session's concurrent_session_events. + int64_t current_state_start_ns = 0; + + // State changes of other concurrently active sessions. Emitted as + // ConcurrentSessionEvent packets and cleared on ReadBuffers(), like + // lifecycle_events. + struct ConcurrentSessionEvent { + int64_t timestamp = 0; // BOOTTIME (ns) of the state change. + TracingSessionID session_id = 0; // Id of the session that changed state. + State state = DISABLED; // The state it transitioned to. + uid_t consumer_uid = 0; // Uid of its consumer. + uint32_t num_data_sources = 0; // Its data source count. + std::string name; // Its unique_session_name (or empty). + }; + + std::vector concurrent_session_events; + // If the consumer detached the session, this variable defines the key used // for identifying the session later when reattaching. std::string detach_key; @@ -65544,6 +65998,9 @@ namespace protos { namespace gen { enum TraceStats_FinalFlushOutcome : int; } +namespace pbzero { +class TracePacket; +} } // namespace protos class Consumer; @@ -65752,10 +66209,18 @@ class TracingServiceImpl : public TracingService { void EmitStats(TracingSession*, std::vector*); TraceStats GetTraceStats(TracingSession*); void EmitLifecycleEvents(TracingSession*, std::vector*); + // The only way to change a session's state. Broadcasts the change into the + // other opted-in sessions' concurrent_session_events. + void SetSessionState(TracingSession*, TracingSession::State); + void EmitConcurrentSessionEvents(TracingSession*, std::vector*); void EmitUuid(TracingSession*, std::vector*); void MaybeEmitTraceConfig(TracingSession*, std::vector*); void EmitSystemInfo(std::vector*); void EmitTraceProvenance(TracingSession*, std::vector*); + // Sets the common header fields on a service-emitted packet (trusted uid + + // service sequence id), and, for a single-machine in-process session, stamps + // the local machine id so the trace has no separate host machine. + void SetServiceTracePacketHeader(protos::pbzero::TracePacket*); void MaybeEmitRemoteSystemInfo(std::vector*); void MaybeEmitCloneTrigger(TracingSession*, std::vector*); void MaybeEmitReceivedTriggers(TracingSession*, std::vector*); @@ -65862,6 +66327,12 @@ class TracingServiceImpl : public TracingService { std::multimap data_sources_; std::map producers_; std::map relay_clients_; + + // Machine to attribute the service's own packets to. Adopted from an + // in-process producer (see ConnectProducer) so a single-machine in-process + // trace carries no separate host machine. Stays kDefaultMachineID for regular + // host/relay sessions, where service packets remain on the host machine. + MachineID local_machine_id_ = kDefaultMachineID; std::map tracing_sessions_; std::map> buffers_; std::map session_to_last_trace_s_; @@ -66838,11 +67309,16 @@ inline base::StatusOr CreateSchedPolicyFromConfig( // gen_amalgamated expanded: #include "src/tracing/service/random.h" // gen_amalgamated expanded: #include "src/tracing/service/trace_buffer.h" // gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1.h" -// gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v1_with_v2_shadow.h" // gen_amalgamated expanded: #include "src/tracing/service/trace_buffer_v2.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_endpoints_impl.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_session.h" // gen_amalgamated expanded: #include "src/tracing/service/tracing_service_structs.h" +#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) +// gen_amalgamated expanded: #include "src/tracing/service/zlib_compressor.h" +#endif +#if PERFETTO_BUILDFLAG(PERFETTO_ZSTD) +// gen_amalgamated expanded: #include "src/tracing/service/zstd_compressor.h" +#endif // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.pbzero.h" @@ -66853,6 +67329,7 @@ inline base::StatusOr CreateSchedPolicyFromConfig( // gen_amalgamated expanded: #include "protos/perfetto/protovm/vm_program.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/clock_snapshot.pbzero.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/extension_descriptor.pbzero.h" +// gen_amalgamated expanded: #include "protos/perfetto/trace/perfetto/concurrent_session_event.pbzero.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/perfetto/trace_provenance.pbzero.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/perfetto/tracing_service_event.pbzero.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/remote_clock_sync.pbzero.h" @@ -67144,6 +67621,17 @@ TracingServiceImpl::ConnectProducer(Producer* producer, smb_scraping_enabled)); auto it_and_inserted = producers_.emplace(id, endpoint.get()); PERFETTO_DCHECK(it_and_inserted.second); + + // Remember an in-process producer's machine so the service can attribute its + // own packets to it (see SetServiceTracePacketHeader), leaving a + // single-machine in-process trace with no separate host machine. Relayed + // producers connect with in_process=false and carry a remote machine id; they + // must not redirect the host service's own packets, so only an in-process + // producer is adopted here. A default machine id is fine to store; the stamp + // decision is made at emit time. + if (in_process) + local_machine_id_ = client_identity.machine_id(); + endpoint->shmem_size_hint_bytes_ = shared_memory_size_hint_bytes; endpoint->shmem_page_size_hint_bytes_ = shared_memory_page_size_hint_bytes; @@ -67802,6 +68290,18 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer, weak_runner_.task_runner())) .first->second; + // Snapshot the current state of every other session into the newly created + // one, so its trace records which sessions were already active when it + // started. Each snapshot is timestamped with when that session entered its + // current state. + if (cfg.builtin_data_sources().enable_concurrent_session_events()) { + for (auto& [src_id, src] : tracing_sessions_) { + if (src_id == tsid) + continue; + tracing_session->AddConcurrentSessionEventWithLimit(src); + } + } + tracing_session->trace_uuid = uuid; if (trace_filter) @@ -67881,15 +68381,14 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer, cfg.fflush_post_write() == TraceConfig::FFLUSH_ENABLED; } - if (cfg.compression_type() == TraceConfig::COMPRESSION_TYPE_DEFLATE) { - if (init_opts_.compressor_fn) { - tracing_session->compress_deflate = true; - } else { - PERFETTO_LOG( - "COMPRESSION_TYPE_DEFLATE is not supported in the current build " - "configuration. Skipping compression"); - } +#if !PERFETTO_BUILDFLAG(PERFETTO_ZLIB) && !PERFETTO_BUILDFLAG(PERFETTO_ZSTD) + if (cfg.compression_type() != TraceConfig::COMPRESSION_TYPE_UNSPECIFIED || + cfg.has_compression()) { + PERFETTO_LOG( + "Compression was requested but this build has no compressor. " + "Skipping compression"); } +#endif // Initialize the log buffers. bool did_allocate_all_buffers = true; @@ -67930,9 +68429,6 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer, case TraceConfig::BufferConfig::TRACE_BUFFER_V2: new_buffer = TraceBufferV2::Create(buf_size, policy); break; - case TraceConfig::BufferConfig::TRACE_BUFFER_V2_SHADOW_MODE: - new_buffer = TraceBufferV1WithV2Shadow::Create(buf_size, policy); - break; case TraceConfig::BufferConfig::MODE_UNSPECIFIED: new_buffer = TraceBufferV1::Create(buf_size, policy); break; @@ -68019,7 +68515,7 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer, // is handled few lines above (search for TriggerMode_MAX). } - tracing_session->state = TracingSession::CONFIGURED; + SetSessionState(tracing_session, TracingSession::CONFIGURED); PERFETTO_LOG( "Configured tracing session %" PRIu64 ", #sources:%zu, duration:%u ms%s, #buffers:%d, total " @@ -68189,7 +68685,7 @@ void TracingServiceImpl::StartTracing(TracingSessionID tsid) { return; } - tracing_session->state = TracingSession::STARTED; + SetSessionState(tracing_session, TracingSession::STARTED); // We store the start of trace snapshot separately as it's important to make // sure we can interpret all the data in the trace and storing it in the ring @@ -68428,7 +68924,7 @@ void TracingServiceImpl::DisableTracing(TracingSessionID tsid, if (tracing_session->AllDataSourceInstancesStopped()) return DisableTracingNotifyConsumerAndFlushFile(tracing_session, error); - tracing_session->state = TracingSession::DISABLING_WAITING_STOP_ACKS; + SetSessionState(tracing_session, TracingSession::DISABLING_WAITING_STOP_ACKS); weak_runner_.PostDelayedTask([this, tsid] { OnDisableTracingTimeout(tsid); }, tracing_session->data_source_stop_timeout_ms()); @@ -68489,8 +68985,7 @@ void TracingServiceImpl::OnAllDataSourceStartedTimeout(TracingSessionID tsid) { protozero::HeapBuffered packet; packet->set_timestamp(static_cast(timestamp)); - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); size_t i = 0; protos::pbzero::TracingServiceEvent::DataSources* slow_data_sources = @@ -68790,7 +69285,7 @@ void TracingServiceImpl::DisableTracingNotifyConsumerAndFlushFile( *producer, inst_kv.second); } } - tracing_session->state = TracingSession::DISABLED; + SetSessionState(tracing_session, TracingSession::DISABLED); // Scrape any remaining chunks that weren't flushed by the producers. for (auto& producer_id_and_producer : producers_) @@ -68803,6 +69298,7 @@ void TracingServiceImpl::DisableTracingNotifyConsumerAndFlushFile( if (tracing_session->write_into_file) { tracing_session->write_period_ms = 0; + tracing_session->should_emit_stats = true; // Buffers are scraped, no need to flush before reading into file. ReadBuffersIntoFile(tracing_session->id, /* async_flush_buffers_before_read = */ false); @@ -68964,8 +69460,7 @@ void TracingServiceImpl::OnFlushTimeout(TracingSessionID tsid, protozero::HeapBuffered packet; packet->set_timestamp(static_cast(timestamp)); - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); size_t i = 0; protos::pbzero::TracingServiceEvent::DataSources* event = @@ -69432,6 +69927,11 @@ std::vector TracingServiceImpl::ReadBuffers( if (!tracing_session->config.builtin_data_sources().disable_service_events()) EmitLifecycleEvents(tracing_session, &packets); + if (tracing_session->config.builtin_data_sources() + .enable_concurrent_session_events()) { + EmitConcurrentSessionEvents(tracing_session, &packets); + } + // In a multi-machine tracing session, emit clock synchronization messages for // remote machines. if (!tracing_session->config.builtin_data_sources() @@ -69496,6 +69996,8 @@ std::vector TracingServiceImpl::ReadBuffers( slice.own_data(), slice.size); const auto& client_identity_trusted = sequence_properties.client_identity_trusted; + // Producer data, not a service packet: keeps the producer's own sequence + // and machine id, so it can't use SetServiceTracePacketHeader. trusted_packet->set_trusted_uid( static_cast(client_identity_trusted.uid())); trusted_packet->set_trusted_packet_sequence_id( @@ -69541,6 +70043,8 @@ std::vector TracingServiceImpl::ReadBuffers( EmitLifecycleEvents(tracing_session, &packets); } + MaybeFilterPackets(tracing_session, &packets); + // Only emit the stats when there is no more trace data is available to read. // That way, any problems that occur while reading from the buffers are // reflected in the emitted stats. This is particularly important for use @@ -69549,10 +70053,14 @@ std::vector TracingServiceImpl::ReadBuffers( if (!*has_more && tracing_session->should_emit_stats) { EmitStats(tracing_session, &packets); tracing_session->should_emit_stats = false; + if (tracing_session->trace_filter) { + size_t stats_packet_size = packets.back().size(); + tracing_session->filter_input_packets++; + tracing_session->filter_input_bytes += stats_packet_size; + tracing_session->filter_output_bytes += stats_packet_size; + } } - MaybeFilterPackets(tracing_session, &packets); - MaybeCompressPackets(tracing_session, &packets); if (!*has_more) { @@ -69628,12 +70136,30 @@ void TracingServiceImpl::MaybeFilterPackets(TracingSession* tracing_session, void TracingServiceImpl::MaybeCompressPackets( TracingSession* tracing_session, - std::vector* packets) { - if (!tracing_session->compress_deflate) { + [[maybe_unused]] std::vector* packets) { + // Compress with the codec the config selects, preferring the newest (highest + // proto field number) this build supports. Leaves the packets uncompressed if + // none is available. + // + // The branches below run highest-field-number-first, so a new codec's branch + // goes at the top. + [[maybe_unused]] const auto& compression = + tracing_session->config.compression(); +#if PERFETTO_BUILDFLAG(PERFETTO_ZSTD) + if (compression.has_zstd()) { + ZstdCompressFn(packets, compression.zstd().level()); return; } - - init_opts_.compressor_fn(packets); +#endif +#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) + // Deflate also serves the legacy compression_type = DEFLATE, so configs + // predating `compression` still get compressed. + if (compression.has_deflate() || tracing_session->config.compression_type() == + TraceConfig::COMPRESSION_TYPE_DEFLATE) { + ZlibCompressFn(packets); + return; + } +#endif } bool TracingServiceImpl::WriteIntoFile(TracingSession* tracing_session, @@ -69737,6 +70263,12 @@ void TracingServiceImpl::FreeBuffers(TracingSessionID tsid, bool is_long_trace = (tracing_session->config.write_into_file() && tracing_session->config.file_write_period_ms() < kMillisPerDay); + + // DisableTracing() above ignores cloned sessions: record their teardown + // here so other sessions observing this one see a terminal DISABLED state. + if (tracing_session->state == TracingSession::CLONED_READ_ONLY) + SetSessionState(tracing_session, TracingSession::DISABLED); + auto pending_clones = std::move(tracing_session->pending_clones); tracing_sessions_.erase(tsid); tracing_session = nullptr; @@ -70455,7 +70987,7 @@ void TracingServiceImpl::UpdateMemoryGuardrail() { } } - // Set the guard rail to 32MB + the sum of all the buffers over a 30 second + // Set the guard rail to 64MB + the sum of all the buffers over a 30 second // interval. uint64_t guardrail = base::kWatchdogDefaultMemorySlack + total_buffer_bytes; base::Watchdog::GetInstance()->SetMemoryLimit(guardrail, 30 * 1000); @@ -70612,6 +71144,19 @@ bool TracingServiceImpl::SnapshotClocks( return true; } +void TracingServiceImpl::SetServiceTracePacketHeader( + protos::pbzero::TracePacket* tp) { + tp->set_trusted_uid(static_cast(uid_)); + tp->set_trusted_packet_sequence_id(kServicePacketSequenceID); + // When a local machine was adopted (an in-process producer with a non-default + // machine id; see ConnectProducer), attribute the service's own packets to it + // so the trace has no separate host machine. Host and relay sessions leave + // local_machine_id_ at the default and keep these packets on the host + // machine. + if (local_machine_id_ != kDefaultMachineID) + tp->set_machine_id(local_machine_id_); +} + void TracingServiceImpl::EmitClockSnapshot( TracingSession* tracing_session, TracingSession::ClockSnapshotData snapshot_data, @@ -70635,8 +71180,7 @@ void TracingServiceImpl::EmitClockSnapshot( c->set_timestamp(clock_id_and_ts.timestamp); } - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); SerializeAndAppendPacket(packets, packet.SerializeAsArray()); } @@ -70649,6 +71193,9 @@ void TracingServiceImpl::EmitSyncMarker(std::vector* packets) { // calls. The ResynchronizeTraceStreamUsingSyncMarker test verifies the ABI. protozero::StaticBuffered packet( &sync_marker_packet_[0], sizeof(sync_marker_packet_)); + // Can't use SetServiceTracePacketHeader: fixed ABI (marker written last, + // after uid) and cached/reused across machines, so it must not gain a + // machine_id field. It's a stream-resync marker; host is fine. packet->set_trusted_uid(static_cast(uid_)); packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); @@ -70663,8 +71210,7 @@ void TracingServiceImpl::EmitSyncMarker(std::vector* packets) { void TracingServiceImpl::EmitStats(TracingSession* tracing_session, std::vector* packets) { protozero::HeapBuffered packet; - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); GetTraceStats(tracing_session).Serialize(packet->set_trace_stats()); SerializeAndAppendPacket(packets, packet.SerializeAsArray()); } @@ -70754,8 +71300,7 @@ TraceStats TracingServiceImpl::GetTraceStats(TracingSession* tracing_session) { void TracingServiceImpl::EmitUuid(TracingSession* tracing_session, std::vector* packets) { protozero::HeapBuffered packet; - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); auto* uuid = packet->set_trace_uuid(); uuid->set_lsb(tracing_session->trace_uuid.lsb()); uuid->set_msb(tracing_session->trace_uuid.msb()); @@ -70768,8 +71313,7 @@ void TracingServiceImpl::MaybeEmitTraceConfig( if (tracing_session->did_emit_initial_packets) return; protozero::HeapBuffered packet; - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); tracing_session->config.Serialize(packet->set_trace_config()); SerializeAndAppendPacket(packets, packet.SerializeAsArray()); } @@ -70818,8 +71362,7 @@ void TracingServiceImpl::EmitSystemInfo(std::vector* packets) { if (!sys_info.android_serial_console.empty()) info->set_android_serial_console(sys_info.android_serial_console); - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); SerializeAndAppendPacket(packets, packet.SerializeAsArray()); } @@ -70851,8 +71394,7 @@ void TracingServiceImpl::EmitTraceProvenance( sequence_proto->set_producer_id(static_cast(producer_id)); } } - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); SerializeAndAppendPacket(packets, packet.SerializeAsArray()); } @@ -70880,6 +71422,8 @@ void TracingServiceImpl::MaybeEmitRemoteSystemInfo( packet->AppendBytes(kTracePacketSystemInfoFieldId, system_info.data(), system_info.size()); + // Relay path: stamps each remote machine's own id, not the adopted local + // one, so it can't use SetServiceTracePacketHeader. packet->set_machine_id(machine_id); packet->set_trusted_uid(static_cast(uid_)); packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); @@ -70898,8 +71442,7 @@ void TracingServiceImpl::EmitLifecycleEvents( for (int64_t ts : event.timestamps) { protozero::HeapBuffered packet; packet->set_timestamp(static_cast(ts)); - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); auto* service_event = packet->set_service_event(); service_event->AppendVarInt(event.field_id, 1); @@ -70925,8 +71468,7 @@ void TracingServiceImpl::EmitLifecycleEvents( protozero::HeapBuffered packet; int64_t ts = tracing_session->buffer_cloned_timestamps[i]; packet->set_timestamp(static_cast(ts)); - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); auto* service_event = packet->set_service_event(); service_event->set_buffer_cloned(static_cast(i)); @@ -70948,6 +71490,88 @@ void TracingServiceImpl::EmitLifecycleEvents( SerializeAndAppendPacket(packets, std::move(pair.second)); } +void TracingServiceImpl::SetSessionState(TracingSession* session, + TracingSession::State new_state) { + PERFETTO_DCHECK_THREAD(thread_checker_); + + if (session->state == new_state) + return; + + session->state = new_state; + session->current_state_start_ns = clock_->GetBootTimeNs().count(); + + // Broadcast this state change into every other session that opted into + // concurrent session events, so their trace logs that this session changed + // state while they were running. + for (auto& [dst_id, dst] : tracing_sessions_) { + if (!dst.config.builtin_data_sources().enable_concurrent_session_events()) + continue; + if (dst_id == session->id) + continue; + + // Skip CLONED_READ_ONLY sessions, whose buffers are a frozen snapshot and + // must never change, and DISABLED ones (terminal, or not yet configured). + // Every other state (CONFIGURED, STARTED, DISABLING_WAITING_STOP_ACKS) is a + // live trace still being recorded or finalized, and will be read. + if (dst.state == TracingSession::CLONED_READ_ONLY || + dst.state == TracingSession::DISABLED) { + continue; + } + + dst.AddConcurrentSessionEventWithLimit(*session); + } +} + +void TracingServiceImpl::EmitConcurrentSessionEvents( + TracingSession* tracing_session, + std::vector* packets) { + auto& events = tracing_session->concurrent_session_events; + if (events.empty()) + return; + + // Sort by timestamp so this sequence has monotonic timestamps, like the + // other service-emitted sequences. + std::sort(events.begin(), events.end(), + [](const TracingSession::ConcurrentSessionEvent& a, + const TracingSession::ConcurrentSessionEvent& b) { + return a.timestamp < b.timestamp; + }); + + auto to_proto_state = [](TracingSession::State state) { + using protos::pbzero::ConcurrentSessionEvent; + switch (state) { + case TracingSession::DISABLED: + return ConcurrentSessionEvent::STATE_DISABLED; + case TracingSession::CONFIGURED: + return ConcurrentSessionEvent::STATE_CONFIGURED; + case TracingSession::STARTED: + return ConcurrentSessionEvent::STATE_STARTED; + case TracingSession::DISABLING_WAITING_STOP_ACKS: + return ConcurrentSessionEvent::STATE_DISABLING_WAITING_STOP_ACKS; + case TracingSession::CLONED_READ_ONLY: + return ConcurrentSessionEvent::STATE_CLONED_READ_ONLY; + } + PERFETTO_FATAL("For GCC"); + }; + + for (const auto& event : events) { + protozero::HeapBuffered packet; + packet->set_timestamp(static_cast(event.timestamp)); + SetServiceTracePacketHeader(packet.get()); + auto* session_event = packet->set_concurrent_session_event(); + session_event->set_state(to_proto_state(event.state)); + if (!event.name.empty()) { + session_event->set_session_name(event.name); + } + session_event->set_session_id(event.session_id); + session_event->set_consumer_uid(static_cast(event.consumer_uid)); + session_event->set_num_data_sources(event.num_data_sources); + SerializeAndAppendPacket(packets, packet.SerializeAsArray()); + } + + events.clear(); +} + void TracingServiceImpl::MaybeEmitRemoteClockSync( TracingSession* tracing_session, std::vector* packets) { @@ -71041,9 +71665,7 @@ void TracingServiceImpl::MaybeEmitProtoVmInstances( } if (maybe_packet) { - maybe_packet.value()->set_trusted_uid(static_cast(uid_)); - maybe_packet.value()->set_trusted_packet_sequence_id( - kServicePacketSequenceID); + SetServiceTracePacketHeader(maybe_packet->get()); SerializeAndAppendPacket(packets, maybe_packet->SerializeAsArray()); } @@ -71055,8 +71677,7 @@ void TracingServiceImpl::EmitExtensionDescriptors( std::vector* packets) { for (const auto& desc : init_opts_.extension_descriptors) { protozero::HeapBuffered packet; - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); auto* ext = packet->set_extension_descriptor(); if (desc.gzipped) { ext->set_extension_set_gzip(desc.start, desc.size); @@ -71088,8 +71709,7 @@ void TracingServiceImpl::MaybeEmitCloneTrigger( trigger->set_stop_delay_ms(info.trigger_delay_ms); packet->set_timestamp(info.boot_time_ns); - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); SerializeAndAppendPacket(packets, packet.SerializeAsArray()); } } @@ -71110,8 +71730,7 @@ void TracingServiceImpl::MaybeEmitReceivedTriggers( trigger->set_stop_delay_ms(info.trigger_delay_ms); packet->set_timestamp(info.boot_time_ns); - packet->set_trusted_uid(static_cast(uid_)); - packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); + SetServiceTracePacketHeader(packet.get()); SerializeAndAppendPacket(packets, packet.SerializeAsArray()); ++tracing_session->num_triggers_emitted_into_trace; } @@ -71266,9 +71885,6 @@ base::Status TracingServiceImpl::FlushAndCloneSession( case TraceBuffer::kV2: buf = TraceBufferV2::Create(buf_size, buf_policy); break; - case TraceBuffer::kV1WithV2Shadow: - buf = TraceBufferV1WithV2Shadow::Create(buf_size, buf_policy); - break; } if (!buf) { // This is extremely rare but could happen on 32-bit. If the new buffer @@ -71449,9 +72065,6 @@ bool TracingServiceImpl::DoCloneBuffers(const TracingSession& src, case TraceBuffer::kV2: src_buf = TraceBufferV2::Create(buf_size, buf_policy); break; - case TraceBuffer::kV1WithV2Shadow: - src_buf = TraceBufferV1WithV2Shadow::Create(buf_size, buf_policy); - break; } if (!src_buf) { // If the allocation fails put the buffer back and let the code below @@ -71519,7 +72132,7 @@ base::Status TracingServiceImpl::FinishCloneSession( // that triggered it. See the corresponding code in perfetto_cmd.cc which // reads at triggering_subscription_id(). const int64_t orig_uuid_lsb = src->trace_uuid.lsb(); - cloned_session->state = TracingSession::CLONED_READ_ONLY; + SetSessionState(cloned_session, TracingSession::CLONED_READ_ONLY); cloned_session->trace_uuid = base::Uuidv4(); cloned_session->trace_uuid.set_lsb(orig_uuid_lsb); *new_uuid = cloned_session->trace_uuid; @@ -71554,13 +72167,13 @@ base::Status TracingServiceImpl::FinishCloneSession( std::vector(src->lifecycle_events); cloned_session->slow_start_event = src->slow_start_event; cloned_session->last_flush_events = src->last_flush_events; + cloned_session->concurrent_session_events = src->concurrent_session_events; cloned_session->initial_clock_snapshot = src->initial_clock_snapshot; cloned_session->clock_snapshot_ring_buffer = src->clock_snapshot_ring_buffer; cloned_session->invalid_packets = src->invalid_packets; cloned_session->flushes_requested = src->flushes_requested; cloned_session->flushes_succeeded = src->flushes_succeeded; cloned_session->flushes_failed = src->flushes_failed; - cloned_session->compress_deflate = src->compress_deflate; if (src->trace_filter && !skip_trace_filter) { // Copy the trace filter, unless it's a clone-for-bugreport (b/317065412). cloned_session->trace_filter.reset( @@ -71705,221 +72318,25 @@ bool TracingSession::AllDataSourceInstancesStopped() { }); } -} // namespace perfetto::tracing_service -// gen_amalgamated begin source: src/tracing/service/zlib_compressor.cc -// gen_amalgamated begin header: src/tracing/service/zlib_compressor.h -/* - * Copyright (C) 2023 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ -#define SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ - -#include - -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" -// gen_amalgamated expanded: #include "perfetto/ext/tracing/core/trace_packet.h" - -namespace perfetto { - -#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) -// Matches TracingServiceImpl::kMaxTracePacketSliceSize. Exposed for testing. -static constexpr size_t kZlibCompressSliceSize = 128 * 1024 - 512; - -void ZlibCompressFn(std::vector*); -#endif - -} // namespace perfetto - -#endif // SRC_TRACING_SERVICE_ZLIB_COMPRESSOR_H_ -/* - * Copyright (C) 2023 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// gen_amalgamated expanded: #include "src/tracing/service/zlib_compressor.h" - -// gen_amalgamated expanded: #include "perfetto/base/build_config.h" - -// File compiles to nothing when the buildflag is off (e.g. SDK opt-out). -#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) - -#include - -// gen_amalgamated expanded: #include "protos/perfetto/trace/trace.pbzero.h" -// gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h" +void TracingSession::AddConcurrentSessionEventWithLimit( + const TracingSession& src) { + static constexpr size_t kMaxConcurrentSessionEvents = 4096; -namespace perfetto { - -namespace { - -struct Preamble { - uint32_t size; - std::array buf; -}; - -template -Preamble GetPreamble(size_t sz) { - Preamble preamble; - uint8_t* ptr = preamble.buf.data(); - constexpr uint32_t tag = protozero::proto_utils::MakeTagLengthDelimited(id); - ptr = protozero::proto_utils::WriteVarInt(tag, ptr); - ptr = protozero::proto_utils::WriteVarInt(sz, ptr); - preamble.size = - static_cast(reinterpret_cast(ptr) - - reinterpret_cast(preamble.buf.data())); - PERFETTO_DCHECK(preamble.size < preamble.buf.size()); - return preamble; -} - -Slice PreambleToSlice(const Preamble& preamble) { - Slice slice = Slice::Allocate(preamble.size); - memcpy(slice.own_data(), preamble.buf.data(), preamble.size); - return slice; -} - -// A compressor for `TracePacket`s that uses zlib. The class is exposed for -// testing. -class ZlibPacketCompressor { - public: - ZlibPacketCompressor(); - ~ZlibPacketCompressor(); - - // Can be called multiple times, before Finish() is called. - void PushPacket(const TracePacket& packet); - - // Returned the compressed data. Can be called at most once. After this call, - // the object is unusable (PushPacket should not be called) and must be - // destroyed. - TracePacket Finish(); - - private: - void PushData(const void* data, uint32_t size); - void NewOutputSlice(); - void PushCurSlice(); - - z_stream stream_; - size_t total_new_slices_size_ = 0; - std::vector new_slices_; - std::unique_ptr cur_slice_; -}; - -ZlibPacketCompressor::ZlibPacketCompressor() { - memset(&stream_, 0, sizeof(stream_)); - int status = deflateInit(&stream_, 6); - PERFETTO_CHECK(status == Z_OK); -} - -ZlibPacketCompressor::~ZlibPacketCompressor() { - int status = deflateEnd(&stream_); - PERFETTO_CHECK(status == Z_OK); -} - -void ZlibPacketCompressor::PushPacket(const TracePacket& packet) { - // We need to be able to tokenize packets in the compressed stream, so we - // prefix a proto preamble to each packet. The compressed stream looks like a - // valid Trace proto. - Preamble preamble = - GetPreamble(packet.size()); - PushData(preamble.buf.data(), preamble.size); - for (const Slice& slice : packet.slices()) { - PushData(slice.start, static_cast(slice.size)); - } -} - -void ZlibPacketCompressor::PushData(const void* data, uint32_t size) { - stream_.next_in = const_cast(static_cast(data)); - stream_.avail_in = static_cast(size); - while (stream_.avail_in != 0) { - if (stream_.avail_out == 0) { - NewOutputSlice(); - } - int status = deflate(&stream_, Z_NO_FLUSH); - PERFETTO_CHECK(status == Z_OK); - } -} - -TracePacket ZlibPacketCompressor::Finish() { - for (;;) { - int status = deflate(&stream_, Z_FINISH); - if (status == Z_STREAM_END) - break; - PERFETTO_CHECK(status == Z_OK || status == Z_BUF_ERROR); - NewOutputSlice(); - } - - PushCurSlice(); - - TracePacket packet; - packet.AddSlice(PreambleToSlice( - GetPreamble( - total_new_slices_size_))); - for (auto& slice : new_slices_) { - packet.AddSlice(std::move(slice)); - } - return packet; -} - -void ZlibPacketCompressor::NewOutputSlice() { - PushCurSlice(); - cur_slice_ = std::make_unique(kZlibCompressSliceSize); - stream_.next_out = reinterpret_cast(cur_slice_.get()); - stream_.avail_out = kZlibCompressSliceSize; -} - -void ZlibPacketCompressor::PushCurSlice() { - if (cur_slice_) { - total_new_slices_size_ += kZlibCompressSliceSize - stream_.avail_out; - new_slices_.push_back(Slice::TakeOwnership( - std::move(cur_slice_), kZlibCompressSliceSize - stream_.avail_out)); - } -} - -} // namespace - -void ZlibCompressFn(std::vector* packets) { - if (packets->empty()) { + if (concurrent_session_events.size() >= kMaxConcurrentSessionEvents) return; - } - - ZlibPacketCompressor stream; - - for (const TracePacket& packet : *packets) { - stream.PushPacket(packet); - } - - TracePacket packet = stream.Finish(); - packets->clear(); - packets->push_back(std::move(packet)); + ConcurrentSessionEvent event{}; + event.timestamp = src.current_state_start_ns; + event.session_id = src.id; + event.state = src.state; + event.consumer_uid = src.consumer_uid; + event.num_data_sources = + static_cast(src.data_source_instances.size()); + event.name = src.config.unique_session_name(); + concurrent_session_events.emplace_back(std::move(event)); } -} // namespace perfetto - -#endif // PERFETTO_BUILDFLAG(PERFETTO_ZLIB) +} // namespace perfetto::tracing_service // gen_amalgamated begin source: src/tracing/internal/in_process_tracing_backend.cc /* * Copyright (C) 2019 The Android Open Source Project @@ -71948,10 +72365,6 @@ void ZlibCompressFn(std::vector* packets) { // gen_amalgamated expanded: #include "src/tracing/core/in_process_shared_memory.h" -#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) -// gen_amalgamated expanded: #include "src/tracing/service/zlib_compressor.h" -#endif - // TODO(primiano): When the in-process backend is used, we should never end up // in a situation where the thread where the TracingService and Producer live // writes a packet and hence can get into the GetNewChunk() stall. @@ -71997,13 +72410,6 @@ TracingService* InProcessTracingBackend::GetOrCreateService( std::unique_ptr shm( new InProcessSharedMemory::Factory()); TracingService::InitOpts init_opts = {}; -#if PERFETTO_BUILDFLAG(PERFETTO_ZLIB) - // Wire the zlib compressor so TraceConfig.compression_type = - // COMPRESSION_TYPE_DEFLATE takes effect on the in-process backend's - // service, mirroring what src/traced/service/service.cc does for the - // system backend. - init_opts.compressor_fn = &ZlibCompressFn; -#endif service_ = TracingService::CreateInstance(std::move(shm), task_runner, init_opts); service_->SetSMBScrapingEnabled(true); @@ -72079,6 +72485,7 @@ TracingService* InProcessTracingBackend::GetOrCreateService( // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_input_event_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_game_intervention_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_aflags_config.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/common/trace_attributes.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/semantic_type.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/builtin_clock.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/trace_stats.gen.h" diff --git a/deps/perfetto/sdk/perfetto.h b/deps/perfetto/sdk/perfetto.h index e439c2084e3b..5bf6732f9b76 100644 --- a/deps/perfetto/sdk/perfetto.h +++ b/deps/perfetto/sdk/perfetto.h @@ -64,6 +64,7 @@ #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_INSTRUMENTS() (0) #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LOCAL_SYMBOLIZER() (0) #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZSTD() (1) #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TRACED_PERF() (0) #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_HEAPPROFD() (0) #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STDERR_CRASH_DUMP() (0) @@ -104,6 +105,7 @@ static const struct PerfettoBuildFlag kPerfettoBuildFlags[] = { {"PERFETTO_TP_HTTPD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_HTTPD()}, {"PERFETTO_TP_INSTRUMENTS", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_INSTRUMENTS()}, {"PERFETTO_ZLIB", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB()}, + {"PERFETTO_ZSTD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZSTD()}, {"PERFETTO_TRACED_PERF", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TRACED_PERF()}, {"PERFETTO_HEAPPROFD", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_HEAPPROFD()}, {"PERFETTO_STDERR_CRASH_DUMP", PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STDERR_CRASH_DUMP()}, @@ -379,18 +381,31 @@ static const int kPerfettoBuildFlagsCount = sizeof(kPerfettoBuildFlags) / sizeof #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB() 0 #endif +#undef PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZSTD +#if defined(PERFETTO_SDK_ENABLE_ZSTD) && (PERFETTO_SDK_ENABLE_ZSTD == 1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZSTD() 1 +#else +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZSTD() 0 +#endif + #endif // PERFETTO_BUILDFLAG(PERFETTO_AMALGAMATED_SDK) -// Unlike PERFETTO_SDK_ENABLE_ZLIB above (amalgamated SDK opt-in), this is a -// file-scope opt-out that applies to every build. Define it to compile out the -// optional zlib compressor. Static libs like libperfetto_client_experimental -// get linked into many binaries, so keeping the compressor out means those -// binaries don't have to link libz. See tools/gen_android_bp. +// Unlike the PERFETTO_SDK_ENABLE_* opt-ins above (amalgamated SDK), these are +// file-scope opt-outs that apply to every build. Define them to compile out the +// optional zlib/zstd compressors. Static libs like +// libperfetto_client_experimental get linked into many binaries, so keeping a +// compressor out means those binaries don't have to link libz/libzstd. See +// tools/gen_android_bp. #if defined(PERFETTO_FORCE_DISABLE_ZLIB) #undef PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB() 0 #endif +#if defined(PERFETTO_FORCE_DISABLE_ZSTD) +#undef PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZSTD +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZSTD() 0 +#endif + #endif // INCLUDE_PERFETTO_BASE_BUILD_CONFIG_H_ // gen_amalgamated begin header: include/perfetto/base/logging.h // gen_amalgamated begin header: include/perfetto/base/compiler.h @@ -670,23 +685,22 @@ inline void ignore_result(const T&...) {} // PERFETTO_SDK_EXPORT: Exports a symbol from the perfetto SDK shared library. // -// This is controlled by two defines (that likely come from the compiler command -// line): -// * PERFETTO_SDK_DISABLE_SHLIB_EXPORT: If this is defined, no export -// annotations are added. This might be useful when static linking. -// * PERFETTO_SDK_SHLIB_IMPLEMENTATION: This must be defined when compiling the -// shared library itself (in order to export the symbols), but must be -// undefined when compiling objects that use the shared library (in order to -// import the symbols). -#if !defined(PERFETTO_SDK_DISABLE_SHLIB_EXPORT) -#if defined(PERFETTO_SHLIB_SDK_IMPLEMENTATION) +// The SDK is linked statically by default and PERFETTO_SDK_EXPORT expands to +// nothing. This is controlled by two defines (that likely come from the +// compiler command line): +// * PERFETTO_SDK_SHLIB_IMPLEMENTATION: This must be defined when compiling +// objects that implement the SDK shared library (in order to export the +// symbols). This includes the case where those objects are linked into a +// larger shared library that re-exports the SDK ABI. +// * PERFETTO_SDK_SHLIB: This must be defined when compiling objects that use +// the SDK as a shared library (in order to import the symbols). +#if defined(PERFETTO_SDK_SHLIB_IMPLEMENTATION) #define PERFETTO_SDK_EXPORT PERFETTO_INTERNAL_DLL_EXPORT -#else +#elif defined(PERFETTO_SDK_SHLIB) #define PERFETTO_SDK_EXPORT PERFETTO_INTERNAL_DLL_IMPORT -#endif -#else // defined(PERFETTO_SDK_DISABLE_SHLIB_EXPORT) +#else #define PERFETTO_SDK_EXPORT -#endif // defined(PERFETTO_SDK_DISABLE_SHLIB_EXPORT) +#endif #endif // INCLUDE_PERFETTO_PUBLIC_ABI_EXPORT_H_ /* @@ -5453,8 +5467,8 @@ class LogMessage; class Screenshot; class SourceLocation; class TaskExecution; -class TrackEvent_Callstack; -class TrackEvent_Callstack_Frame; +class TrackEvent_InlineCallstack; +class TrackEvent_InlineCallstack_Frame; class TrackEvent_LegacyEvent; namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent { enum FlowDirection : int32_t; @@ -5790,7 +5804,7 @@ class TrackEventDefaults : public ::protozero::Message { } }; -class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder { +class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder { public: TrackEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TrackEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -5837,6 +5851,8 @@ class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_callstack_iid() const { return at<56>().valid(); } uint64_t callstack_iid() const { return at<56>().as_uint64(); } + bool has_callstack_weight() const { return at<57>().valid(); } + double callstack_weight() const { return at<57>().as_double(); } bool has_debug_annotations() const { return at<4>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(4); } bool has_task_execution() const { return at<5>().valid(); } @@ -5918,6 +5934,7 @@ class TrackEvent : public ::protozero::Message { kCorrelationIdStrIidFieldNumber = 54, kCallstackFieldNumber = 55, kCallstackIidFieldNumber = 56, + kCallstackWeightFieldNumber = 57, kDebugAnnotationsFieldNumber = 4, kTaskExecutionFieldNumber = 5, kLogMessageFieldNumber = 21, @@ -5948,7 +5965,7 @@ class TrackEvent : public ::protozero::Message { }; static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent"; } - using Callstack = ::perfetto::protos::pbzero::TrackEvent_Callstack; + using InlineCallstack = ::perfetto::protos::pbzero::TrackEvent_InlineCallstack; using LegacyEvent = ::perfetto::protos::pbzero::TrackEvent_LegacyEvent; using Type = ::perfetto::protos::pbzero::TrackEvent_Type; @@ -6327,11 +6344,11 @@ class TrackEvent : public ::protozero::Message { 55, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kMessage, - TrackEvent_Callstack, + TrackEvent_InlineCallstack, TrackEvent>; static constexpr FieldMetadata_Callstack kCallstack{}; - template T* set_callstack() { + template T* set_callstack() { return BeginNestedMessage(55); } @@ -6354,6 +6371,24 @@ class TrackEvent : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_CallstackWeight = + ::protozero::proto_utils::FieldMetadata< + 57, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + TrackEvent>; + + static constexpr FieldMetadata_CallstackWeight kCallstackWeight{}; + void set_callstack_weight(double value) { + static constexpr uint32_t field_id = FieldMetadata_CallstackWeight::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + using FieldMetadata_DebugAnnotations = ::protozero::proto_utils::FieldMetadata< 4, @@ -7137,45 +7172,45 @@ class TrackEvent_LegacyEvent : public ::protozero::Message { } }; -class TrackEvent_Callstack_Decoder : public ::protozero::TypedProtoDecoder { +class TrackEvent_InlineCallstack_Decoder : public ::protozero::TypedProtoDecoder { public: - TrackEvent_Callstack_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TrackEvent_Callstack_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TrackEvent_Callstack_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + TrackEvent_InlineCallstack_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEvent_InlineCallstack_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEvent_InlineCallstack_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} bool has_frames() const { return at<1>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> frames() const { return GetRepeated<::protozero::ConstBytes>(1); } }; -class TrackEvent_Callstack : public ::protozero::Message { +class TrackEvent_InlineCallstack : public ::protozero::Message { public: - using Decoder = TrackEvent_Callstack_Decoder; + using Decoder = TrackEvent_InlineCallstack_Decoder; enum : int32_t { kFramesFieldNumber = 1, }; - static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent.Callstack"; } + static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent.InlineCallstack"; } - using Frame = ::perfetto::protos::pbzero::TrackEvent_Callstack_Frame; + using Frame = ::perfetto::protos::pbzero::TrackEvent_InlineCallstack_Frame; using FieldMetadata_Frames = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - TrackEvent_Callstack_Frame, - TrackEvent_Callstack>; + TrackEvent_InlineCallstack_Frame, + TrackEvent_InlineCallstack>; static constexpr FieldMetadata_Frames kFrames{}; - template T* add_frames() { + template T* add_frames() { return BeginNestedMessage(1); } }; -class TrackEvent_Callstack_Frame_Decoder : public ::protozero::TypedProtoDecoder { +class TrackEvent_InlineCallstack_Frame_Decoder : public ::protozero::TypedProtoDecoder { public: - TrackEvent_Callstack_Frame_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TrackEvent_Callstack_Frame_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TrackEvent_Callstack_Frame_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + TrackEvent_InlineCallstack_Frame_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEvent_InlineCallstack_Frame_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEvent_InlineCallstack_Frame_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} bool has_function_name() const { return at<1>().valid(); } ::protozero::ConstChars function_name() const { return at<1>().as_string(); } bool has_source_file() const { return at<2>().valid(); } @@ -7184,15 +7219,15 @@ class TrackEvent_Callstack_Frame_Decoder : public ::protozero::TypedProtoDecoder uint32_t line_number() const { return at<3>().as_uint32(); } }; -class TrackEvent_Callstack_Frame : public ::protozero::Message { +class TrackEvent_InlineCallstack_Frame : public ::protozero::Message { public: - using Decoder = TrackEvent_Callstack_Frame_Decoder; + using Decoder = TrackEvent_InlineCallstack_Frame_Decoder; enum : int32_t { kFunctionNameFieldNumber = 1, kSourceFileFieldNumber = 2, kLineNumberFieldNumber = 3, }; - static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent.Callstack.Frame"; } + static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent.InlineCallstack.Frame"; } using FieldMetadata_FunctionName = @@ -7201,7 +7236,7 @@ class TrackEvent_Callstack_Frame : public ::protozero::Message { ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kString, std::string, - TrackEvent_Callstack_Frame>; + TrackEvent_InlineCallstack_Frame>; static constexpr FieldMetadata_FunctionName kFunctionName{}; void set_function_name(const char* data, size_t size) { @@ -7225,7 +7260,7 @@ class TrackEvent_Callstack_Frame : public ::protozero::Message { ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kString, std::string, - TrackEvent_Callstack_Frame>; + TrackEvent_InlineCallstack_Frame>; static constexpr FieldMetadata_SourceFile kSourceFile{}; void set_source_file(const char* data, size_t size) { @@ -7249,7 +7284,7 @@ class TrackEvent_Callstack_Frame : public ::protozero::Message { ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kUint32, uint32_t, - TrackEvent_Callstack_Frame>; + TrackEvent_InlineCallstack_Frame>; static constexpr FieldMetadata_LineNumber kLineNumber{}; void set_line_number(uint32_t value) { @@ -7724,7 +7759,8 @@ namespace perfetto { namespace protos { namespace gen { class TraceConfig; -class TraceConfig_Note; +class TraceAttributes; +class TraceAttributes_Attribute; class PriorityBoostConfig; class TraceConfig_SessionSemaphore; class TraceConfig_CmdTraceStartDelay; @@ -7733,6 +7769,9 @@ class TraceConfig_TraceFilter; class TraceConfig_TraceFilter_StringFilterChain; class TraceConfig_TraceFilter_StringFilterRule; class TraceConfig_IncidentReportConfig; +class TraceConfig_CompressionConfig; +class TraceConfig_CompressionConfig_Zstd; +class TraceConfig_CompressionConfig_Deflate; class TraceConfig_IncrementalStateConfig; class TraceConfig_TriggerConfig; class TraceConfig_TriggerConfig_Trigger; @@ -7824,7 +7863,6 @@ enum TraceConfig_BufferConfig_FillPolicy : int { enum TraceConfig_BufferConfig_ExperimentalMode : int { TraceConfig_BufferConfig_ExperimentalMode_MODE_UNSPECIFIED = 0, TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2 = 1, - TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2_SHADOW_MODE = 2, }; class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj { @@ -7837,12 +7875,12 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj using GuardrailOverrides = TraceConfig_GuardrailOverrides; using TriggerConfig = TraceConfig_TriggerConfig; using IncrementalStateConfig = TraceConfig_IncrementalStateConfig; + using CompressionConfig = TraceConfig_CompressionConfig; using IncidentReportConfig = TraceConfig_IncidentReportConfig; using TraceFilter = TraceConfig_TraceFilter; using AndroidReportConfig = TraceConfig_AndroidReportConfig; using CmdTraceStartDelay = TraceConfig_CmdTraceStartDelay; using SessionSemaphore = TraceConfig_SessionSemaphore; - using Note = TraceConfig_Note; using LockdownModeOperation = TraceConfig_LockdownModeOperation; static constexpr auto LOCKDOWN_UNCHANGED = TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED; static constexpr auto LOCKDOWN_CLEAR = TraceConfig_LockdownModeOperation_LOCKDOWN_CLEAR; @@ -7901,6 +7939,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj kAllowUserBuildTracingFieldNumber = 19, kUniqueSessionNameFieldNumber = 22, kCompressionTypeFieldNumber = 24, + kCompressionFieldNumber = 47, kIncidentReportConfigFieldNumber = 25, kStatsdLoggingFieldNumber = 31, kTraceUuidMsbFieldNumber = 27, @@ -7914,7 +7953,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj kWriteFlushModeFieldNumber = 44, kFflushPostWriteFieldNumber = 45, kTraceAllMachinesFieldNumber = 43, - kNotesFieldNumber = 46, + kTraceAttributesFieldNumber = 48, }; TraceConfig(); @@ -8048,6 +8087,10 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj TraceConfig_CompressionType compression_type() const { return compression_type_; } void set_compression_type(TraceConfig_CompressionType value) { compression_type_ = value; _has_field_.set(24); } + bool has_compression() const { return _has_field_[47]; } + const TraceConfig_CompressionConfig& compression() const { return *compression_; } + TraceConfig_CompressionConfig* mutable_compression() { _has_field_.set(47); return compression_.get(); } + bool has_incident_report_config() const { return _has_field_[25]; } const TraceConfig_IncidentReportConfig& incident_report_config() const { return *incident_report_config_; } TraceConfig_IncidentReportConfig* mutable_incident_report_config() { _has_field_.set(25); return incident_report_config_.get(); } @@ -8102,11 +8145,9 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj bool trace_all_machines() const { return trace_all_machines_; } void set_trace_all_machines(bool value) { trace_all_machines_ = value; _has_field_.set(43); } - const std::vector& notes() const { return notes_; } - std::vector* mutable_notes() { return ¬es_; } - int notes_size() const; - void clear_notes(); - TraceConfig_Note* add_notes(); + bool has_trace_attributes() const { return _has_field_[48]; } + const TraceAttributes& trace_attributes() const { return *trace_attributes_; } + TraceAttributes* mutable_trace_attributes() { _has_field_.set(48); return trace_attributes_.get(); } private: std::vector buffers_; @@ -8136,6 +8177,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj bool allow_user_build_tracing_{}; std::string unique_session_name_{}; TraceConfig_CompressionType compression_type_{}; + ::protozero::CopyablePtr compression_; ::protozero::CopyablePtr incident_report_config_; TraceConfig_StatsdLogging statsd_logging_{}; int64_t trace_uuid_msb_{}; @@ -8149,54 +8191,13 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj TraceConfig_WriteFlushMode write_flush_mode_{}; TraceConfig_FFlushMode fflush_post_write_{}; bool trace_all_machines_{}; - std::vector notes_; + ::protozero::CopyablePtr trace_attributes_; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<47> _has_field_{}; -}; - - -class PERFETTO_EXPORT_COMPONENT TraceConfig_Note : public ::protozero::CppMessageObj { - public: - enum FieldNumbers { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, - }; - - TraceConfig_Note(); - ~TraceConfig_Note() override; - TraceConfig_Note(TraceConfig_Note&&) noexcept; - TraceConfig_Note& operator=(TraceConfig_Note&&); - TraceConfig_Note(const TraceConfig_Note&); - TraceConfig_Note& operator=(const TraceConfig_Note&); - bool operator==(const TraceConfig_Note&) const; - bool operator!=(const TraceConfig_Note& other) const { return !(*this == other); } - - bool ParseFromArray(const void*, size_t) override; - std::string SerializeAsString() const override; - std::vector SerializeAsArray() const override; - void Serialize(::protozero::Message*) const; - - bool has_key() const { return _has_field_[1]; } - const std::string& key() const { return key_; } - void set_key(const std::string& value) { key_ = value; _has_field_.set(1); } - - bool has_value() const { return _has_field_[2]; } - const std::string& value() const { return value_; } - void set_value(const std::string& value) { value_ = value; _has_field_.set(2); } - - private: - std::string key_{}; - std::string value_{}; - - // Allows to preserve unknown protobuf fields for compatibility - // with future versions of .proto files. - std::string unknown_fields_; - - std::bitset<3> _has_field_{}; + std::bitset<49> _has_field_{}; }; @@ -8566,6 +8567,113 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_IncidentReportConfig : public ::prot }; +class PERFETTO_EXPORT_COMPONENT TraceConfig_CompressionConfig : public ::protozero::CppMessageObj { + public: + using Deflate = TraceConfig_CompressionConfig_Deflate; + using Zstd = TraceConfig_CompressionConfig_Zstd; + enum FieldNumbers { + kDeflateFieldNumber = 1, + kZstdFieldNumber = 2, + }; + + TraceConfig_CompressionConfig(); + ~TraceConfig_CompressionConfig() override; + TraceConfig_CompressionConfig(TraceConfig_CompressionConfig&&) noexcept; + TraceConfig_CompressionConfig& operator=(TraceConfig_CompressionConfig&&); + TraceConfig_CompressionConfig(const TraceConfig_CompressionConfig&); + TraceConfig_CompressionConfig& operator=(const TraceConfig_CompressionConfig&); + bool operator==(const TraceConfig_CompressionConfig&) const; + bool operator!=(const TraceConfig_CompressionConfig& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_deflate() const { return _has_field_[1]; } + const TraceConfig_CompressionConfig_Deflate& deflate() const { return *deflate_; } + TraceConfig_CompressionConfig_Deflate* mutable_deflate() { _has_field_.set(1); return deflate_.get(); } + + bool has_zstd() const { return _has_field_[2]; } + const TraceConfig_CompressionConfig_Zstd& zstd() const { return *zstd_; } + TraceConfig_CompressionConfig_Zstd* mutable_zstd() { _has_field_.set(2); return zstd_.get(); } + + private: + ::protozero::CopyablePtr deflate_; + ::protozero::CopyablePtr zstd_; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<3> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT TraceConfig_CompressionConfig_Zstd : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kLevelFieldNumber = 1, + }; + + TraceConfig_CompressionConfig_Zstd(); + ~TraceConfig_CompressionConfig_Zstd() override; + TraceConfig_CompressionConfig_Zstd(TraceConfig_CompressionConfig_Zstd&&) noexcept; + TraceConfig_CompressionConfig_Zstd& operator=(TraceConfig_CompressionConfig_Zstd&&); + TraceConfig_CompressionConfig_Zstd(const TraceConfig_CompressionConfig_Zstd&); + TraceConfig_CompressionConfig_Zstd& operator=(const TraceConfig_CompressionConfig_Zstd&); + bool operator==(const TraceConfig_CompressionConfig_Zstd&) const; + bool operator!=(const TraceConfig_CompressionConfig_Zstd& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_level() const { return _has_field_[1]; } + int32_t level() const { return level_; } + void set_level(int32_t value) { level_ = value; _has_field_.set(1); } + + private: + int32_t level_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<2> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT TraceConfig_CompressionConfig_Deflate : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + }; + + TraceConfig_CompressionConfig_Deflate(); + ~TraceConfig_CompressionConfig_Deflate() override; + TraceConfig_CompressionConfig_Deflate(TraceConfig_CompressionConfig_Deflate&&) noexcept; + TraceConfig_CompressionConfig_Deflate& operator=(TraceConfig_CompressionConfig_Deflate&&); + TraceConfig_CompressionConfig_Deflate(const TraceConfig_CompressionConfig_Deflate&); + TraceConfig_CompressionConfig_Deflate& operator=(const TraceConfig_CompressionConfig_Deflate&); + bool operator==(const TraceConfig_CompressionConfig_Deflate&) const; + bool operator!=(const TraceConfig_CompressionConfig_Deflate& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + private: + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<2> _has_field_{}; +}; + + class PERFETTO_EXPORT_COMPONENT TraceConfig_IncrementalStateConfig : public ::protozero::CppMessageObj { public: enum FieldNumbers { @@ -8876,6 +8984,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BuiltinDataSource : public ::protoze kPreferSuspendClockForSnapshotFieldNumber = 7, kDisableChunkUsageHistogramsFieldNumber = 8, kDisableExtensionDescriptorsFieldNumber = 9, + kEnableConcurrentSessionEventsFieldNumber = 10, }; TraceConfig_BuiltinDataSource(); @@ -8928,6 +9037,10 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BuiltinDataSource : public ::protoze bool disable_extension_descriptors() const { return disable_extension_descriptors_; } void set_disable_extension_descriptors(bool value) { disable_extension_descriptors_ = value; _has_field_.set(9); } + bool has_enable_concurrent_session_events() const { return _has_field_[10]; } + bool enable_concurrent_session_events() const { return enable_concurrent_session_events_; } + void set_enable_concurrent_session_events(bool value) { enable_concurrent_session_events_ = value; _has_field_.set(10); } + private: bool disable_clock_snapshotting_{}; bool disable_trace_config_{}; @@ -8938,12 +9051,13 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BuiltinDataSource : public ::protoze bool prefer_suspend_clock_for_snapshot_{}; bool disable_chunk_usage_histograms_{}; bool disable_extension_descriptors_{}; + bool enable_concurrent_session_events_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<10> _has_field_{}; + std::bitset<11> _has_field_{}; }; @@ -9020,9 +9134,8 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig_BufferConfig : public ::protozero::C using ExperimentalMode = TraceConfig_BufferConfig_ExperimentalMode; static constexpr auto MODE_UNSPECIFIED = TraceConfig_BufferConfig_ExperimentalMode_MODE_UNSPECIFIED; static constexpr auto TRACE_BUFFER_V2 = TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2; - static constexpr auto TRACE_BUFFER_V2_SHADOW_MODE = TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2_SHADOW_MODE; static constexpr auto ExperimentalMode_MIN = TraceConfig_BufferConfig_ExperimentalMode_MODE_UNSPECIFIED; - static constexpr auto ExperimentalMode_MAX = TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2_SHADOW_MODE; + static constexpr auto ExperimentalMode_MAX = TraceConfig_BufferConfig_ExperimentalMode_TRACE_BUFFER_V2; enum FieldNumbers { kSizeKbFieldNumber = 1, kFillPolicyFieldNumber = 4, @@ -10642,7 +10755,8 @@ namespace internal { // So for each data source, for each instance, for each thread we keep one // TraceWriter. // The lookup is O(1): Given the TLS object, the TraceWriter is just tls[M][N]. -class TracingTLS : public Platform::ThreadLocalObject { +class PERFETTO_EXPORT_COMPONENT TracingTLS + : public Platform::ThreadLocalObject { public: ~TracingTLS() override; @@ -11171,8 +11285,6 @@ namespace perfetto { namespace protos { namespace pbzero { class AndroidAflags; -class AndroidCameraFrameEvent; -class AndroidCameraSessionStats; class AndroidEnergyEstimationBreakdown; class AndroidGameInterventionList; class AndroidLogPacket; @@ -11185,13 +11297,13 @@ class ChromeEventBundle; class ChromeMetadataPacket; class ChromeTrigger; class ClockSnapshot; +class ConcurrentSessionEvent; class CpuInfo; class CpuPerUidData; class DeobfuscationMapping; class EntityStateResidency; class EtwTraceEventBundle; class ExtensionDescriptor; -class FrameTimelineEvent; class FtraceEventBundle; class FtraceStats; class GenericGpuFrequencyEvent; @@ -11224,6 +11336,7 @@ class ProcessTree; class ProfilePacket; class RemoteClockSync; class SmapsPacket; +class StackSample; class StatsdAtom; class StreamingAllocation; class StreamingFree; @@ -11446,22 +11559,20 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_service_event() const { return at<69>().valid(); } ::protozero::ConstBytes service_event() const { return at<69>().as_bytes(); } + bool has_concurrent_session_event() const { return at<134>().valid(); } + ::protozero::ConstBytes concurrent_session_event() const { return at<134>().as_bytes(); } + bool has_stack_sample() const { return at<135>().valid(); } + ::protozero::ConstBytes stack_sample() const { return at<135>().as_bytes(); } bool has_initial_display_state() const { return at<70>().valid(); } ::protozero::ConstBytes initial_display_state() const { return at<70>().as_bytes(); } bool has_gpu_mem_total_event() const { return at<71>().valid(); } ::protozero::ConstBytes gpu_mem_total_event() const { return at<71>().as_bytes(); } bool has_memory_tracker_snapshot() const { return at<73>().valid(); } ::protozero::ConstBytes memory_tracker_snapshot() const { return at<73>().as_bytes(); } - bool has_frame_timeline_event() const { return at<76>().valid(); } - ::protozero::ConstBytes frame_timeline_event() const { return at<76>().as_bytes(); } bool has_android_energy_estimation_breakdown() const { return at<77>().valid(); } ::protozero::ConstBytes android_energy_estimation_breakdown() const { return at<77>().as_bytes(); } bool has_ui_state() const { return at<78>().valid(); } ::protozero::ConstBytes ui_state() const { return at<78>().as_bytes(); } - bool has_android_camera_frame_event() const { return at<80>().valid(); } - ::protozero::ConstBytes android_camera_frame_event() const { return at<80>().as_bytes(); } - bool has_android_camera_session_stats() const { return at<81>().valid(); } - ::protozero::ConstBytes android_camera_session_stats() const { return at<81>().as_bytes(); } bool has_translation_table() const { return at<82>().valid(); } ::protozero::ConstBytes translation_table() const { return at<82>().as_bytes(); } bool has_android_game_intervention_list() const { return at<83>().valid(); } @@ -11498,6 +11609,8 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_compressed_packets() const { return at<50>().valid(); } ::protozero::ConstBytes compressed_packets() const { return at<50>().as_bytes(); } + bool has_zstd_compressed_packets() const { return at<133>().valid(); } + ::protozero::ConstBytes zstd_compressed_packets() const { return at<133>().as_bytes(); } bool has_extension_descriptor() const { return at<72>().valid(); } ::protozero::ConstBytes extension_descriptor() const { return at<72>().as_bytes(); } bool has_etw_events() const { return at<95>().valid(); } @@ -11601,14 +11714,13 @@ class TracePacket : public ::protozero::Message { kCpuInfoFieldNumber = 67, kSmapsPacketFieldNumber = 68, kServiceEventFieldNumber = 69, + kConcurrentSessionEventFieldNumber = 134, + kStackSampleFieldNumber = 135, kInitialDisplayStateFieldNumber = 70, kGpuMemTotalEventFieldNumber = 71, kMemoryTrackerSnapshotFieldNumber = 73, - kFrameTimelineEventFieldNumber = 76, kAndroidEnergyEstimationBreakdownFieldNumber = 77, kUiStateFieldNumber = 78, - kAndroidCameraFrameEventFieldNumber = 80, - kAndroidCameraSessionStatsFieldNumber = 81, kTranslationTableFieldNumber = 82, kAndroidGameInterventionListFieldNumber = 83, kStatsdAtomFieldNumber = 84, @@ -11627,6 +11739,7 @@ class TracePacket : public ::protozero::Message { kFtraceEventsFieldNumber = 1, kSynchronizationMarkerFieldNumber = 36, kCompressedPacketsFieldNumber = 50, + kZstdCompressedPacketsFieldNumber = 133, kExtensionDescriptorFieldNumber = 72, kEtwEventsFieldNumber = 95, kV8JsCodeFieldNumber = 99, @@ -12319,6 +12432,34 @@ class TracePacket : public ::protozero::Message { } + using FieldMetadata_ConcurrentSessionEvent = + ::protozero::proto_utils::FieldMetadata< + 134, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ConcurrentSessionEvent, + TracePacket>; + + static constexpr FieldMetadata_ConcurrentSessionEvent kConcurrentSessionEvent{}; + template T* set_concurrent_session_event() { + return BeginNestedMessage(134); + } + + + using FieldMetadata_StackSample = + ::protozero::proto_utils::FieldMetadata< + 135, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StackSample, + TracePacket>; + + static constexpr FieldMetadata_StackSample kStackSample{}; + template T* set_stack_sample() { + return BeginNestedMessage(135); + } + + using FieldMetadata_InitialDisplayState = ::protozero::proto_utils::FieldMetadata< 70, @@ -12361,20 +12502,6 @@ class TracePacket : public ::protozero::Message { } - using FieldMetadata_FrameTimelineEvent = - ::protozero::proto_utils::FieldMetadata< - 76, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FrameTimelineEvent, - TracePacket>; - - static constexpr FieldMetadata_FrameTimelineEvent kFrameTimelineEvent{}; - template T* set_frame_timeline_event() { - return BeginNestedMessage(76); - } - - using FieldMetadata_AndroidEnergyEstimationBreakdown = ::protozero::proto_utils::FieldMetadata< 77, @@ -12403,34 +12530,6 @@ class TracePacket : public ::protozero::Message { } - using FieldMetadata_AndroidCameraFrameEvent = - ::protozero::proto_utils::FieldMetadata< - 80, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidCameraFrameEvent, - TracePacket>; - - static constexpr FieldMetadata_AndroidCameraFrameEvent kAndroidCameraFrameEvent{}; - template T* set_android_camera_frame_event() { - return BeginNestedMessage(80); - } - - - using FieldMetadata_AndroidCameraSessionStats = - ::protozero::proto_utils::FieldMetadata< - 81, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidCameraSessionStats, - TracePacket>; - - static constexpr FieldMetadata_AndroidCameraSessionStats kAndroidCameraSessionStats{}; - template T* set_android_camera_session_stats() { - return BeginNestedMessage(81); - } - - using FieldMetadata_TranslationTable = ::protozero::proto_utils::FieldMetadata< 82, @@ -12703,6 +12802,30 @@ class TracePacket : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_ZstdCompressedPackets = + ::protozero::proto_utils::FieldMetadata< + 133, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + TracePacket>; + + static constexpr FieldMetadata_ZstdCompressedPackets kZstdCompressedPackets{}; + void set_zstd_compressed_packets(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_ZstdCompressedPackets::kFieldId, data, size); + } + void set_zstd_compressed_packets(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_ZstdCompressedPackets::kFieldId, bytes.data, bytes.size); + } + void set_zstd_compressed_packets(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ZstdCompressedPackets::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + using FieldMetadata_ExtensionDescriptor = ::protozero::proto_utils::FieldMetadata< 72, @@ -16301,15 +16424,35 @@ class has_traced_value_support { } // namespace internal +// A type T is writable into a trace if one of the following is defined: +// - T::WriteIntoTracedValue(TracedValue) const +// - T::WriteIntoTrace(TracedValue) const +// - perfetto::TraceFormatTraits::WriteIntoTracedValue(TracedValue, const T&) +// - perfetto::TraceFormatTraits::WriteIntoTrace(TracedValue, const T&) +// The member forms are preferred for code that can depend on perfetto directly; +// the TraceFormatTraits forms are for types owned by code that cannot. See the +// examples at the top of this file. Primitives, strings, pointers, STL +// containers and protozero enums are supported out of the box. +// +// If the static_assert below fires, the most common causes are: +// - No conversion is defined for T. +// - The conversion method is not const, or does not take TracedValue by value. +// - The method name is misspelled: only WriteIntoTrace and WriteIntoTracedValue +// are recognised. +// - The TraceFormatTraits specialisation is not in the perfetto namespace. +// - The header defining the conversion is not included at the TRACE_EVENT call +// site. +// - T is a pointer or smart pointer to a type that is itself not writable. +// - T is a plain enum with no conversion (only protozero enums are automatic). template void WriteIntoTracedValue(TracedValue context, T&& value) { - // TODO(altimin): Add a URL to documentation and a list of common failure - // patterns. static_assert( internal::has_traced_value_support::value, "The provided type (passed to TRACE_EVENT argument / TracedArray::Append " "/ TracedDictionary::Add) does not support being written in a trace " - "format. Please see the comment in traced_value.h for more details."); + "format. Please see the comment above WriteIntoTracedValue in " + "traced_value.h for the list of supported conversions and common " + "failure patterns."); // Should be kept in sync with check_traced_value_support_t! internal::WriteImpl(base::priority_tag(), @@ -19572,6 +19715,10 @@ class InternedV8WasmScript; class LogMessageBody; class Mapping; class SourceLocation; +class StackSample_AsyncContextDescriptor; +class StackSample_CounterDescriptor; +class StackSample_ExecutionContext; +class StackSample_TaskContext; class UnsymbolizedSourceLocation; } // Namespace pbzero. } // Namespace protos. @@ -19581,7 +19728,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class InternedData_Decoder : public ::protozero::TypedProtoDecoder { +class InternedData_Decoder : public ::protozero::TypedProtoDecoder { public: InternedData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit InternedData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -19594,14 +19741,10 @@ class InternedData_Decoder : public ::protozero::TypedProtoDecoder debug_annotation_names() const { return GetRepeated<::protozero::ConstBytes>(3); } bool has_debug_annotation_value_type_names() const { return at<27>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_value_type_names() const { return GetRepeated<::protozero::ConstBytes>(27); } - bool has_source_locations() const { return at<4>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> source_locations() const { return GetRepeated<::protozero::ConstBytes>(4); } - bool has_unsymbolized_source_locations() const { return at<28>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> unsymbolized_source_locations() const { return GetRepeated<::protozero::ConstBytes>(28); } - bool has_log_message_body() const { return at<20>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> log_message_body() const { return GetRepeated<::protozero::ConstBytes>(20); } - bool has_histogram_names() const { return at<25>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> histogram_names() const { return GetRepeated<::protozero::ConstBytes>(25); } + bool has_debug_annotation_string_values() const { return at<29>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_string_values() const { return GetRepeated<::protozero::ConstBytes>(29); } + bool has_correlation_id_str() const { return at<43>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> correlation_id_str() const { return GetRepeated<::protozero::ConstBytes>(43); } bool has_build_ids() const { return at<16>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> build_ids() const { return GetRepeated<::protozero::ConstBytes>(16); } bool has_mapping_paths() const { return at<17>().valid(); } @@ -19616,16 +19759,32 @@ class InternedData_Decoder : public ::protozero::TypedProtoDecoder frames() const { return GetRepeated<::protozero::ConstBytes>(6); } bool has_callstacks() const { return at<7>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> callstacks() const { return GetRepeated<::protozero::ConstBytes>(7); } + bool has_stack_sample_task_contexts() const { return at<48>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stack_sample_task_contexts() const { return GetRepeated<::protozero::ConstBytes>(48); } + bool has_stack_sample_execution_contexts() const { return at<49>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stack_sample_execution_contexts() const { return GetRepeated<::protozero::ConstBytes>(49); } + bool has_stack_sample_counter_descriptors() const { return at<50>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stack_sample_counter_descriptors() const { return GetRepeated<::protozero::ConstBytes>(50); } + bool has_stack_sample_async_context_descriptors() const { return at<51>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stack_sample_async_context_descriptors() const { return GetRepeated<::protozero::ConstBytes>(51); } + bool has_source_locations() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> source_locations() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_unsymbolized_source_locations() const { return at<28>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> unsymbolized_source_locations() const { return GetRepeated<::protozero::ConstBytes>(28); } + bool has_log_message_body() const { return at<20>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> log_message_body() const { return GetRepeated<::protozero::ConstBytes>(20); } + bool has_histogram_names() const { return at<25>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> histogram_names() const { return GetRepeated<::protozero::ConstBytes>(25); } bool has_vulkan_memory_keys() const { return at<22>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> vulkan_memory_keys() const { return GetRepeated<::protozero::ConstBytes>(22); } bool has_graphics_contexts() const { return at<23>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> graphics_contexts() const { return GetRepeated<::protozero::ConstBytes>(23); } bool has_gpu_specifications() const { return at<24>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> gpu_specifications() const { return GetRepeated<::protozero::ConstBytes>(24); } + bool has_gpu_counter_descriptors() const { return at<47>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> gpu_counter_descriptors() const { return GetRepeated<::protozero::ConstBytes>(47); } bool has_kernel_symbols() const { return at<26>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> kernel_symbols() const { return GetRepeated<::protozero::ConstBytes>(26); } - bool has_debug_annotation_string_values() const { return at<29>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_string_values() const { return GetRepeated<::protozero::ConstBytes>(29); } bool has_v8_js_function_name() const { return at<31>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_js_function_name() const { return GetRepeated<::protozero::ConstBytes>(31); } bool has_v8_js_function() const { return at<32>().valid(); } @@ -19636,26 +19795,6 @@ class InternedData_Decoder : public ::protozero::TypedProtoDecoder v8_wasm_script() const { return GetRepeated<::protozero::ConstBytes>(34); } bool has_v8_isolate() const { return at<35>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_isolate() const { return GetRepeated<::protozero::ConstBytes>(35); } - bool has_protolog_string_args() const { return at<36>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> protolog_string_args() const { return GetRepeated<::protozero::ConstBytes>(36); } - bool has_protolog_stacktrace() const { return at<37>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> protolog_stacktrace() const { return GetRepeated<::protozero::ConstBytes>(37); } - bool has_viewcapture_package_name() const { return at<38>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_package_name() const { return GetRepeated<::protozero::ConstBytes>(38); } - bool has_viewcapture_window_name() const { return at<39>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_window_name() const { return GetRepeated<::protozero::ConstBytes>(39); } - bool has_viewcapture_view_id() const { return at<40>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_view_id() const { return GetRepeated<::protozero::ConstBytes>(40); } - bool has_viewcapture_class_name() const { return at<41>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_class_name() const { return GetRepeated<::protozero::ConstBytes>(41); } - bool has_viewcapture_content_description() const { return at<45>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_content_description() const { return GetRepeated<::protozero::ConstBytes>(45); } - bool has_viewcapture_text() const { return at<46>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_text() const { return GetRepeated<::protozero::ConstBytes>(46); } - bool has_correlation_id_str() const { return at<43>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> correlation_id_str() const { return GetRepeated<::protozero::ConstBytes>(43); } - bool has_gpu_counter_descriptors() const { return at<47>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> gpu_counter_descriptors() const { return GetRepeated<::protozero::ConstBytes>(47); } }; class InternedData : public ::protozero::Message { @@ -19666,10 +19805,8 @@ class InternedData : public ::protozero::Message { kEventNamesFieldNumber = 2, kDebugAnnotationNamesFieldNumber = 3, kDebugAnnotationValueTypeNamesFieldNumber = 27, - kSourceLocationsFieldNumber = 4, - kUnsymbolizedSourceLocationsFieldNumber = 28, - kLogMessageBodyFieldNumber = 20, - kHistogramNamesFieldNumber = 25, + kDebugAnnotationStringValuesFieldNumber = 29, + kCorrelationIdStrFieldNumber = 43, kBuildIdsFieldNumber = 16, kMappingPathsFieldNumber = 17, kSourcePathsFieldNumber = 18, @@ -19677,26 +19814,24 @@ class InternedData : public ::protozero::Message { kMappingsFieldNumber = 19, kFramesFieldNumber = 6, kCallstacksFieldNumber = 7, + kStackSampleTaskContextsFieldNumber = 48, + kStackSampleExecutionContextsFieldNumber = 49, + kStackSampleCounterDescriptorsFieldNumber = 50, + kStackSampleAsyncContextDescriptorsFieldNumber = 51, + kSourceLocationsFieldNumber = 4, + kUnsymbolizedSourceLocationsFieldNumber = 28, + kLogMessageBodyFieldNumber = 20, + kHistogramNamesFieldNumber = 25, kVulkanMemoryKeysFieldNumber = 22, kGraphicsContextsFieldNumber = 23, kGpuSpecificationsFieldNumber = 24, + kGpuCounterDescriptorsFieldNumber = 47, kKernelSymbolsFieldNumber = 26, - kDebugAnnotationStringValuesFieldNumber = 29, kV8JsFunctionNameFieldNumber = 31, kV8JsFunctionFieldNumber = 32, kV8JsScriptFieldNumber = 33, kV8WasmScriptFieldNumber = 34, kV8IsolateFieldNumber = 35, - kProtologStringArgsFieldNumber = 36, - kProtologStacktraceFieldNumber = 37, - kViewcapturePackageNameFieldNumber = 38, - kViewcaptureWindowNameFieldNumber = 39, - kViewcaptureViewIdFieldNumber = 40, - kViewcaptureClassNameFieldNumber = 41, - kViewcaptureContentDescriptionFieldNumber = 45, - kViewcaptureTextFieldNumber = 46, - kCorrelationIdStrFieldNumber = 43, - kGpuCounterDescriptorsFieldNumber = 47, }; static constexpr const char* GetName() { return ".perfetto.protos.InternedData"; } @@ -19757,59 +19892,31 @@ class InternedData : public ::protozero::Message { } - using FieldMetadata_SourceLocations = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - SourceLocation, - InternedData>; - - static constexpr FieldMetadata_SourceLocations kSourceLocations{}; - template T* add_source_locations() { - return BeginNestedMessage(4); - } - - - using FieldMetadata_UnsymbolizedSourceLocations = - ::protozero::proto_utils::FieldMetadata< - 28, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - UnsymbolizedSourceLocation, - InternedData>; - - static constexpr FieldMetadata_UnsymbolizedSourceLocations kUnsymbolizedSourceLocations{}; - template T* add_unsymbolized_source_locations() { - return BeginNestedMessage(28); - } - - - using FieldMetadata_LogMessageBody = + using FieldMetadata_DebugAnnotationStringValues = ::protozero::proto_utils::FieldMetadata< - 20, + 29, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - LogMessageBody, + InternedString, InternedData>; - static constexpr FieldMetadata_LogMessageBody kLogMessageBody{}; - template T* add_log_message_body() { - return BeginNestedMessage(20); + static constexpr FieldMetadata_DebugAnnotationStringValues kDebugAnnotationStringValues{}; + template T* add_debug_annotation_string_values() { + return BeginNestedMessage(29); } - using FieldMetadata_HistogramNames = + using FieldMetadata_CorrelationIdStr = ::protozero::proto_utils::FieldMetadata< - 25, + 43, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - HistogramName, + InternedString, InternedData>; - static constexpr FieldMetadata_HistogramNames kHistogramNames{}; - template T* add_histogram_names() { - return BeginNestedMessage(25); + static constexpr FieldMetadata_CorrelationIdStr kCorrelationIdStr{}; + template T* add_correlation_id_str() { + return BeginNestedMessage(43); } @@ -19911,283 +20018,255 @@ class InternedData : public ::protozero::Message { } - using FieldMetadata_VulkanMemoryKeys = - ::protozero::proto_utils::FieldMetadata< - 22, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, - InternedData>; - - static constexpr FieldMetadata_VulkanMemoryKeys kVulkanMemoryKeys{}; - template T* add_vulkan_memory_keys() { - return BeginNestedMessage(22); - } - - - using FieldMetadata_GraphicsContexts = - ::protozero::proto_utils::FieldMetadata< - 23, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedGraphicsContext, - InternedData>; - - static constexpr FieldMetadata_GraphicsContexts kGraphicsContexts{}; - template T* add_graphics_contexts() { - return BeginNestedMessage(23); - } - - - using FieldMetadata_GpuSpecifications = + using FieldMetadata_StackSampleTaskContexts = ::protozero::proto_utils::FieldMetadata< - 24, + 48, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedGpuRenderStageSpecification, + StackSample_TaskContext, InternedData>; - static constexpr FieldMetadata_GpuSpecifications kGpuSpecifications{}; - template T* add_gpu_specifications() { - return BeginNestedMessage(24); + static constexpr FieldMetadata_StackSampleTaskContexts kStackSampleTaskContexts{}; + template T* add_stack_sample_task_contexts() { + return BeginNestedMessage(48); } - using FieldMetadata_KernelSymbols = + using FieldMetadata_StackSampleExecutionContexts = ::protozero::proto_utils::FieldMetadata< - 26, + 49, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + StackSample_ExecutionContext, InternedData>; - static constexpr FieldMetadata_KernelSymbols kKernelSymbols{}; - template T* add_kernel_symbols() { - return BeginNestedMessage(26); + static constexpr FieldMetadata_StackSampleExecutionContexts kStackSampleExecutionContexts{}; + template T* add_stack_sample_execution_contexts() { + return BeginNestedMessage(49); } - using FieldMetadata_DebugAnnotationStringValues = + using FieldMetadata_StackSampleCounterDescriptors = ::protozero::proto_utils::FieldMetadata< - 29, + 50, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + StackSample_CounterDescriptor, InternedData>; - static constexpr FieldMetadata_DebugAnnotationStringValues kDebugAnnotationStringValues{}; - template T* add_debug_annotation_string_values() { - return BeginNestedMessage(29); + static constexpr FieldMetadata_StackSampleCounterDescriptors kStackSampleCounterDescriptors{}; + template T* add_stack_sample_counter_descriptors() { + return BeginNestedMessage(50); } - using FieldMetadata_V8JsFunctionName = + using FieldMetadata_StackSampleAsyncContextDescriptors = ::protozero::proto_utils::FieldMetadata< - 31, + 51, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedV8String, + StackSample_AsyncContextDescriptor, InternedData>; - static constexpr FieldMetadata_V8JsFunctionName kV8JsFunctionName{}; - template T* add_v8_js_function_name() { - return BeginNestedMessage(31); + static constexpr FieldMetadata_StackSampleAsyncContextDescriptors kStackSampleAsyncContextDescriptors{}; + template T* add_stack_sample_async_context_descriptors() { + return BeginNestedMessage(51); } - using FieldMetadata_V8JsFunction = + using FieldMetadata_SourceLocations = ::protozero::proto_utils::FieldMetadata< - 32, + 4, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedV8JsFunction, + SourceLocation, InternedData>; - static constexpr FieldMetadata_V8JsFunction kV8JsFunction{}; - template T* add_v8_js_function() { - return BeginNestedMessage(32); + static constexpr FieldMetadata_SourceLocations kSourceLocations{}; + template T* add_source_locations() { + return BeginNestedMessage(4); } - using FieldMetadata_V8JsScript = + using FieldMetadata_UnsymbolizedSourceLocations = ::protozero::proto_utils::FieldMetadata< - 33, + 28, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedV8JsScript, + UnsymbolizedSourceLocation, InternedData>; - static constexpr FieldMetadata_V8JsScript kV8JsScript{}; - template T* add_v8_js_script() { - return BeginNestedMessage(33); + static constexpr FieldMetadata_UnsymbolizedSourceLocations kUnsymbolizedSourceLocations{}; + template T* add_unsymbolized_source_locations() { + return BeginNestedMessage(28); } - using FieldMetadata_V8WasmScript = + using FieldMetadata_LogMessageBody = ::protozero::proto_utils::FieldMetadata< - 34, + 20, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedV8WasmScript, + LogMessageBody, InternedData>; - static constexpr FieldMetadata_V8WasmScript kV8WasmScript{}; - template T* add_v8_wasm_script() { - return BeginNestedMessage(34); + static constexpr FieldMetadata_LogMessageBody kLogMessageBody{}; + template T* add_log_message_body() { + return BeginNestedMessage(20); } - using FieldMetadata_V8Isolate = + using FieldMetadata_HistogramNames = ::protozero::proto_utils::FieldMetadata< - 35, + 25, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedV8Isolate, + HistogramName, InternedData>; - static constexpr FieldMetadata_V8Isolate kV8Isolate{}; - template T* add_v8_isolate() { - return BeginNestedMessage(35); + static constexpr FieldMetadata_HistogramNames kHistogramNames{}; + template T* add_histogram_names() { + return BeginNestedMessage(25); } - using FieldMetadata_ProtologStringArgs = + using FieldMetadata_VulkanMemoryKeys = ::protozero::proto_utils::FieldMetadata< - 36, + 22, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, InternedString, InternedData>; - static constexpr FieldMetadata_ProtologStringArgs kProtologStringArgs{}; - template T* add_protolog_string_args() { - return BeginNestedMessage(36); + static constexpr FieldMetadata_VulkanMemoryKeys kVulkanMemoryKeys{}; + template T* add_vulkan_memory_keys() { + return BeginNestedMessage(22); } - using FieldMetadata_ProtologStacktrace = + using FieldMetadata_GraphicsContexts = ::protozero::proto_utils::FieldMetadata< - 37, + 23, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + InternedGraphicsContext, InternedData>; - static constexpr FieldMetadata_ProtologStacktrace kProtologStacktrace{}; - template T* add_protolog_stacktrace() { - return BeginNestedMessage(37); + static constexpr FieldMetadata_GraphicsContexts kGraphicsContexts{}; + template T* add_graphics_contexts() { + return BeginNestedMessage(23); } - using FieldMetadata_ViewcapturePackageName = + using FieldMetadata_GpuSpecifications = ::protozero::proto_utils::FieldMetadata< - 38, + 24, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + InternedGpuRenderStageSpecification, InternedData>; - static constexpr FieldMetadata_ViewcapturePackageName kViewcapturePackageName{}; - template T* add_viewcapture_package_name() { - return BeginNestedMessage(38); + static constexpr FieldMetadata_GpuSpecifications kGpuSpecifications{}; + template T* add_gpu_specifications() { + return BeginNestedMessage(24); } - using FieldMetadata_ViewcaptureWindowName = + using FieldMetadata_GpuCounterDescriptors = ::protozero::proto_utils::FieldMetadata< - 39, + 47, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + InternedGpuCounterDescriptor, InternedData>; - static constexpr FieldMetadata_ViewcaptureWindowName kViewcaptureWindowName{}; - template T* add_viewcapture_window_name() { - return BeginNestedMessage(39); + static constexpr FieldMetadata_GpuCounterDescriptors kGpuCounterDescriptors{}; + template T* add_gpu_counter_descriptors() { + return BeginNestedMessage(47); } - using FieldMetadata_ViewcaptureViewId = + using FieldMetadata_KernelSymbols = ::protozero::proto_utils::FieldMetadata< - 40, + 26, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, InternedString, InternedData>; - static constexpr FieldMetadata_ViewcaptureViewId kViewcaptureViewId{}; - template T* add_viewcapture_view_id() { - return BeginNestedMessage(40); + static constexpr FieldMetadata_KernelSymbols kKernelSymbols{}; + template T* add_kernel_symbols() { + return BeginNestedMessage(26); } - using FieldMetadata_ViewcaptureClassName = + using FieldMetadata_V8JsFunctionName = ::protozero::proto_utils::FieldMetadata< - 41, + 31, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + InternedV8String, InternedData>; - static constexpr FieldMetadata_ViewcaptureClassName kViewcaptureClassName{}; - template T* add_viewcapture_class_name() { - return BeginNestedMessage(41); + static constexpr FieldMetadata_V8JsFunctionName kV8JsFunctionName{}; + template T* add_v8_js_function_name() { + return BeginNestedMessage(31); } - using FieldMetadata_ViewcaptureContentDescription = + using FieldMetadata_V8JsFunction = ::protozero::proto_utils::FieldMetadata< - 45, + 32, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + InternedV8JsFunction, InternedData>; - static constexpr FieldMetadata_ViewcaptureContentDescription kViewcaptureContentDescription{}; - template T* add_viewcapture_content_description() { - return BeginNestedMessage(45); + static constexpr FieldMetadata_V8JsFunction kV8JsFunction{}; + template T* add_v8_js_function() { + return BeginNestedMessage(32); } - using FieldMetadata_ViewcaptureText = + using FieldMetadata_V8JsScript = ::protozero::proto_utils::FieldMetadata< - 46, + 33, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + InternedV8JsScript, InternedData>; - static constexpr FieldMetadata_ViewcaptureText kViewcaptureText{}; - template T* add_viewcapture_text() { - return BeginNestedMessage(46); + static constexpr FieldMetadata_V8JsScript kV8JsScript{}; + template T* add_v8_js_script() { + return BeginNestedMessage(33); } - using FieldMetadata_CorrelationIdStr = + using FieldMetadata_V8WasmScript = ::protozero::proto_utils::FieldMetadata< - 43, + 34, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedString, + InternedV8WasmScript, InternedData>; - static constexpr FieldMetadata_CorrelationIdStr kCorrelationIdStr{}; - template T* add_correlation_id_str() { - return BeginNestedMessage(43); + static constexpr FieldMetadata_V8WasmScript kV8WasmScript{}; + template T* add_v8_wasm_script() { + return BeginNestedMessage(34); } - using FieldMetadata_GpuCounterDescriptors = + using FieldMetadata_V8Isolate = ::protozero::proto_utils::FieldMetadata< - 47, + 35, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - InternedGpuCounterDescriptor, + InternedV8Isolate, InternedData>; - static constexpr FieldMetadata_GpuCounterDescriptors kGpuCounterDescriptors{}; - template T* add_gpu_counter_descriptors() { - return BeginNestedMessage(47); + static constexpr FieldMetadata_V8Isolate kV8Isolate{}; + template T* add_v8_isolate() { + return BeginNestedMessage(35); } }; @@ -22482,6 +22561,9 @@ class StopArgsImpl : public DataSourceBase::StopArgs { // perfetto.protos.ClockSnapshot. However, custom clock IDs (>=64) are // reserved for internal use by the SDK for the time being. // The timestamp value should be in nanoseconds regardless of the clock domain. +// +// See the "Custom timestamps and clocks" section in +// docs/instrumentation/track-events.md for a worked example. template struct TraceTimestampTraits; @@ -24191,10 +24273,11 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) { // debug_annotation->set_string_value("value"); // }); // -// |time_in_nanoseconds| should be an uint64_t by default. To support custom -// timestamp types, -// |perfetto::TraceTimestampTraits::ConvertTimestampToTraceTimeNs| -// should be defined. See |ConvertTimestampToTraceTimeNs| for more details. +// |time_in_nanoseconds| is a uint64_t on the trace clock by default. To pass +// a custom timestamp type, or a timestamp on a different clock, specialize +// |perfetto::TraceTimestampTraits| and define a static +// ConvertTimestampToTraceTimeNs in it. See the "Custom timestamps and clocks" +// section in docs/instrumentation/track-events.md for a full example. // // 3. Arbitrary number of debug annotations: // @@ -29335,7 +29418,6 @@ class TraceStats; class TraceStats_FilterStats; class TraceStats_WriterStats; class TraceStats_BufferStats; -class TraceStats_BufferStats_ShadowBufferStats; enum TraceStats_FinalFlushOutcome : int; } // namespace perfetto } // namespace protos @@ -29630,7 +29712,6 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_WriterStats : public ::protozero::Cpp class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::CppMessageObj { public: - using ShadowBufferStats = TraceStats_BufferStats_ShadowBufferStats; enum FieldNumbers { kBufferSizeFieldNumber = 12, kBytesWrittenFieldNumber = 1, @@ -29640,6 +29721,7 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp kPaddingBytesClearedFieldNumber = 16, kChunksWrittenFieldNumber = 2, kChunksRewrittenFieldNumber = 10, + kChunksRelocatedFieldNumber = 20, kChunksOverwrittenFieldNumber = 3, kChunksDiscardedFieldNumber = 18, kChunksReadFieldNumber = 17, @@ -29651,7 +29733,6 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp kReadaheadsFailedFieldNumber = 8, kAbiViolationsFieldNumber = 9, kTraceWriterPacketLossFieldNumber = 19, - kShadowBufferStatsFieldNumber = 21, }; TraceStats_BufferStats(); @@ -29700,6 +29781,10 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp uint64_t chunks_rewritten() const { return chunks_rewritten_; } void set_chunks_rewritten(uint64_t value) { chunks_rewritten_ = value; _has_field_.set(10); } + bool has_chunks_relocated() const { return _has_field_[20]; } + uint64_t chunks_relocated() const { return chunks_relocated_; } + void set_chunks_relocated(uint64_t value) { chunks_relocated_ = value; _has_field_.set(20); } + bool has_chunks_overwritten() const { return _has_field_[3]; } uint64_t chunks_overwritten() const { return chunks_overwritten_; } void set_chunks_overwritten(uint64_t value) { chunks_overwritten_ = value; _has_field_.set(3); } @@ -29744,10 +29829,6 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp uint64_t trace_writer_packet_loss() const { return trace_writer_packet_loss_; } void set_trace_writer_packet_loss(uint64_t value) { trace_writer_packet_loss_ = value; _has_field_.set(19); } - bool has_shadow_buffer_stats() const { return _has_field_[21]; } - const TraceStats_BufferStats_ShadowBufferStats& shadow_buffer_stats() const { return *shadow_buffer_stats_; } - TraceStats_BufferStats_ShadowBufferStats* mutable_shadow_buffer_stats() { _has_field_.set(21); return shadow_buffer_stats_.get(); } - private: uint64_t buffer_size_{}; uint64_t bytes_written_{}; @@ -29757,6 +29838,7 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp uint64_t padding_bytes_cleared_{}; uint64_t chunks_written_{}; uint64_t chunks_rewritten_{}; + uint64_t chunks_relocated_{}; uint64_t chunks_overwritten_{}; uint64_t chunks_discarded_{}; uint64_t chunks_read_{}; @@ -29768,90 +29850,12 @@ class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats : public ::protozero::Cpp uint64_t readaheads_failed_{}; uint64_t abi_violations_{}; uint64_t trace_writer_packet_loss_{}; - ::protozero::CopyablePtr shadow_buffer_stats_; - - // Allows to preserve unknown protobuf fields for compatibility - // with future versions of .proto files. - std::string unknown_fields_; - - std::bitset<22> _has_field_{}; -}; - - -class PERFETTO_EXPORT_COMPONENT TraceStats_BufferStats_ShadowBufferStats : public ::protozero::CppMessageObj { - public: - enum FieldNumbers { - kPacketsSeenFieldNumber = 1, - kPacketsInBothFieldNumber = 2, - kPacketsOnlyV1FieldNumber = 3, - kPacketsOnlyV2FieldNumber = 4, - kPatchesAttemptedFieldNumber = 5, - kV1PatchesSucceededFieldNumber = 6, - kV2PatchesSucceededFieldNumber = 7, - kStatsVersionFieldNumber = 8, - }; - - TraceStats_BufferStats_ShadowBufferStats(); - ~TraceStats_BufferStats_ShadowBufferStats() override; - TraceStats_BufferStats_ShadowBufferStats(TraceStats_BufferStats_ShadowBufferStats&&) noexcept; - TraceStats_BufferStats_ShadowBufferStats& operator=(TraceStats_BufferStats_ShadowBufferStats&&); - TraceStats_BufferStats_ShadowBufferStats(const TraceStats_BufferStats_ShadowBufferStats&); - TraceStats_BufferStats_ShadowBufferStats& operator=(const TraceStats_BufferStats_ShadowBufferStats&); - bool operator==(const TraceStats_BufferStats_ShadowBufferStats&) const; - bool operator!=(const TraceStats_BufferStats_ShadowBufferStats& other) const { return !(*this == other); } - - bool ParseFromArray(const void*, size_t) override; - std::string SerializeAsString() const override; - std::vector SerializeAsArray() const override; - void Serialize(::protozero::Message*) const; - - bool has_packets_seen() const { return _has_field_[1]; } - uint64_t packets_seen() const { return packets_seen_; } - void set_packets_seen(uint64_t value) { packets_seen_ = value; _has_field_.set(1); } - - bool has_packets_in_both() const { return _has_field_[2]; } - uint64_t packets_in_both() const { return packets_in_both_; } - void set_packets_in_both(uint64_t value) { packets_in_both_ = value; _has_field_.set(2); } - - bool has_packets_only_v1() const { return _has_field_[3]; } - uint64_t packets_only_v1() const { return packets_only_v1_; } - void set_packets_only_v1(uint64_t value) { packets_only_v1_ = value; _has_field_.set(3); } - - bool has_packets_only_v2() const { return _has_field_[4]; } - uint64_t packets_only_v2() const { return packets_only_v2_; } - void set_packets_only_v2(uint64_t value) { packets_only_v2_ = value; _has_field_.set(4); } - - bool has_patches_attempted() const { return _has_field_[5]; } - uint64_t patches_attempted() const { return patches_attempted_; } - void set_patches_attempted(uint64_t value) { patches_attempted_ = value; _has_field_.set(5); } - - bool has_v1_patches_succeeded() const { return _has_field_[6]; } - uint64_t v1_patches_succeeded() const { return v1_patches_succeeded_; } - void set_v1_patches_succeeded(uint64_t value) { v1_patches_succeeded_ = value; _has_field_.set(6); } - - bool has_v2_patches_succeeded() const { return _has_field_[7]; } - uint64_t v2_patches_succeeded() const { return v2_patches_succeeded_; } - void set_v2_patches_succeeded(uint64_t value) { v2_patches_succeeded_ = value; _has_field_.set(7); } - - bool has_stats_version() const { return _has_field_[8]; } - uint32_t stats_version() const { return stats_version_; } - void set_stats_version(uint32_t value) { stats_version_ = value; _has_field_.set(8); } - - private: - uint64_t packets_seen_{}; - uint64_t packets_in_both_{}; - uint64_t packets_only_v1_{}; - uint64_t packets_only_v2_{}; - uint64_t patches_attempted_{}; - uint64_t v1_patches_succeeded_{}; - uint64_t v2_patches_succeeded_{}; - uint32_t stats_version_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<9> _has_field_{}; + std::bitset<21> _has_field_{}; }; } // namespace perfetto @@ -37624,7 +37628,6 @@ namespace perfetto { namespace protos { namespace pbzero { class TraceStats_BufferStats; -class TraceStats_BufferStats_ShadowBufferStats; class TraceStats_FilterStats; class TraceStats_WriterStats; namespace perfetto_pbzero_enum_TraceStats { @@ -38274,7 +38277,7 @@ class TraceStats_WriterStats : public ::protozero::Message { } }; -class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder { +class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder { public: TraceStats_BufferStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TraceStats_BufferStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -38295,6 +38298,8 @@ class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder().as_uint64(); } bool has_chunks_rewritten() const { return at<10>().valid(); } uint64_t chunks_rewritten() const { return at<10>().as_uint64(); } + bool has_chunks_relocated() const { return at<20>().valid(); } + uint64_t chunks_relocated() const { return at<20>().as_uint64(); } bool has_chunks_overwritten() const { return at<3>().valid(); } uint64_t chunks_overwritten() const { return at<3>().as_uint64(); } bool has_chunks_discarded() const { return at<18>().valid(); } @@ -38317,8 +38322,6 @@ class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder().as_uint64(); } bool has_trace_writer_packet_loss() const { return at<19>().valid(); } uint64_t trace_writer_packet_loss() const { return at<19>().as_uint64(); } - bool has_shadow_buffer_stats() const { return at<21>().valid(); } - ::protozero::ConstBytes shadow_buffer_stats() const { return at<21>().as_bytes(); } }; class TraceStats_BufferStats : public ::protozero::Message { @@ -38333,6 +38336,7 @@ class TraceStats_BufferStats : public ::protozero::Message { kPaddingBytesClearedFieldNumber = 16, kChunksWrittenFieldNumber = 2, kChunksRewrittenFieldNumber = 10, + kChunksRelocatedFieldNumber = 20, kChunksOverwrittenFieldNumber = 3, kChunksDiscardedFieldNumber = 18, kChunksReadFieldNumber = 17, @@ -38344,11 +38348,9 @@ class TraceStats_BufferStats : public ::protozero::Message { kReadaheadsFailedFieldNumber = 8, kAbiViolationsFieldNumber = 9, kTraceWriterPacketLossFieldNumber = 19, - kShadowBufferStatsFieldNumber = 21, }; static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.BufferStats"; } - using ShadowBufferStats = ::perfetto::protos::pbzero::TraceStats_BufferStats_ShadowBufferStats; using FieldMetadata_BufferSize = ::protozero::proto_utils::FieldMetadata< @@ -38494,6 +38496,24 @@ class TraceStats_BufferStats : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_ChunksRelocated = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ChunksRelocated kChunksRelocated{}; + void set_chunks_relocated(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunksRelocated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + using FieldMetadata_ChunksOverwritten = ::protozero::proto_utils::FieldMetadata< 3, @@ -38691,204 +38711,6 @@ class TraceStats_BufferStats : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } - - using FieldMetadata_ShadowBufferStats = - ::protozero::proto_utils::FieldMetadata< - 21, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TraceStats_BufferStats_ShadowBufferStats, - TraceStats_BufferStats>; - - static constexpr FieldMetadata_ShadowBufferStats kShadowBufferStats{}; - template T* set_shadow_buffer_stats() { - return BeginNestedMessage(21); - } - -}; - -class TraceStats_BufferStats_ShadowBufferStats_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceStats_BufferStats_ShadowBufferStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceStats_BufferStats_ShadowBufferStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceStats_BufferStats_ShadowBufferStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_packets_seen() const { return at<1>().valid(); } - uint64_t packets_seen() const { return at<1>().as_uint64(); } - bool has_packets_in_both() const { return at<2>().valid(); } - uint64_t packets_in_both() const { return at<2>().as_uint64(); } - bool has_packets_only_v1() const { return at<3>().valid(); } - uint64_t packets_only_v1() const { return at<3>().as_uint64(); } - bool has_packets_only_v2() const { return at<4>().valid(); } - uint64_t packets_only_v2() const { return at<4>().as_uint64(); } - bool has_patches_attempted() const { return at<5>().valid(); } - uint64_t patches_attempted() const { return at<5>().as_uint64(); } - bool has_v1_patches_succeeded() const { return at<6>().valid(); } - uint64_t v1_patches_succeeded() const { return at<6>().as_uint64(); } - bool has_v2_patches_succeeded() const { return at<7>().valid(); } - uint64_t v2_patches_succeeded() const { return at<7>().as_uint64(); } - bool has_stats_version() const { return at<8>().valid(); } - uint32_t stats_version() const { return at<8>().as_uint32(); } -}; - -class TraceStats_BufferStats_ShadowBufferStats : public ::protozero::Message { - public: - using Decoder = TraceStats_BufferStats_ShadowBufferStats_Decoder; - enum : int32_t { - kPacketsSeenFieldNumber = 1, - kPacketsInBothFieldNumber = 2, - kPacketsOnlyV1FieldNumber = 3, - kPacketsOnlyV2FieldNumber = 4, - kPatchesAttemptedFieldNumber = 5, - kV1PatchesSucceededFieldNumber = 6, - kV2PatchesSucceededFieldNumber = 7, - kStatsVersionFieldNumber = 8, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.BufferStats.ShadowBufferStats"; } - - - using FieldMetadata_PacketsSeen = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TraceStats_BufferStats_ShadowBufferStats>; - - static constexpr FieldMetadata_PacketsSeen kPacketsSeen{}; - void set_packets_seen(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_PacketsSeen::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PacketsInBoth = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TraceStats_BufferStats_ShadowBufferStats>; - - static constexpr FieldMetadata_PacketsInBoth kPacketsInBoth{}; - void set_packets_in_both(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_PacketsInBoth::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PacketsOnlyV1 = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TraceStats_BufferStats_ShadowBufferStats>; - - static constexpr FieldMetadata_PacketsOnlyV1 kPacketsOnlyV1{}; - void set_packets_only_v1(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_PacketsOnlyV1::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PacketsOnlyV2 = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TraceStats_BufferStats_ShadowBufferStats>; - - static constexpr FieldMetadata_PacketsOnlyV2 kPacketsOnlyV2{}; - void set_packets_only_v2(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_PacketsOnlyV2::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PatchesAttempted = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TraceStats_BufferStats_ShadowBufferStats>; - - static constexpr FieldMetadata_PatchesAttempted kPatchesAttempted{}; - void set_patches_attempted(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_PatchesAttempted::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_V1PatchesSucceeded = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TraceStats_BufferStats_ShadowBufferStats>; - - static constexpr FieldMetadata_V1PatchesSucceeded kV1PatchesSucceeded{}; - void set_v1_patches_succeeded(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_V1PatchesSucceeded::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_V2PatchesSucceeded = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TraceStats_BufferStats_ShadowBufferStats>; - - static constexpr FieldMetadata_V2PatchesSucceeded kV2PatchesSucceeded{}; - void set_v2_patches_succeeded(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_V2PatchesSucceeded::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StatsVersion = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceStats_BufferStats_ShadowBufferStats>; - - static constexpr FieldMetadata_StatsVersion kStatsVersion{}; - void set_stats_version(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_StatsVersion::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } }; } // Namespace. @@ -40806,6 +40628,7 @@ class PERFETTO_EXPORT_COMPONENT DisplayVideoConfig : public ::protozero::CppMess kFormatFieldNumber = 2, kKeyFrameIntervalSecsFieldNumber = 3, kMaxStreamSizeBytesFieldNumber = 4, + kBitrateBpsFieldNumber = 5, }; DisplayVideoConfig(); @@ -40838,17 +40661,22 @@ class PERFETTO_EXPORT_COMPONENT DisplayVideoConfig : public ::protozero::CppMess uint64_t max_stream_size_bytes() const { return max_stream_size_bytes_; } void set_max_stream_size_bytes(uint64_t value) { max_stream_size_bytes_ = value; _has_field_.set(4); } + bool has_bitrate_bps() const { return _has_field_[5]; } + uint32_t bitrate_bps() const { return bitrate_bps_; } + void set_bitrate_bps(uint32_t value) { bitrate_bps_ = value; _has_field_.set(5); } + private: float scale_{}; DisplayVideoConfig_Format format_{}; uint32_t key_frame_interval_secs_{}; uint64_t max_stream_size_bytes_{}; + uint32_t bitrate_bps_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<5> _has_field_{}; + std::bitset<6> _has_field_{}; }; } // namespace perfetto @@ -43494,6 +43322,7 @@ class PERFETTO_EXPORT_COMPONENT ProcessStatsConfig : public ::protozero::CppMess kRecordProcessRuntimeFieldNumber = 12, kRecordProcessDmabufRssFieldNumber = 13, kResolveProcessFdsFieldNumber = 9, + kSkipMainThreadMessageFieldNumber = 14, }; ProcessStatsConfig(); @@ -43553,6 +43382,10 @@ class PERFETTO_EXPORT_COMPONENT ProcessStatsConfig : public ::protozero::CppMess bool resolve_process_fds() const { return resolve_process_fds_; } void set_resolve_process_fds(bool value) { resolve_process_fds_ = value; _has_field_.set(9); } + bool has_skip_main_thread_message() const { return _has_field_[14]; } + bool skip_main_thread_message() const { return skip_main_thread_message_; } + void set_skip_main_thread_message(bool value) { skip_main_thread_message_ = value; _has_field_.set(14); } + private: std::vector quirks_; bool scan_all_processes_on_start_{}; @@ -43564,12 +43397,13 @@ class PERFETTO_EXPORT_COMPONENT ProcessStatsConfig : public ::protozero::CppMess bool record_process_runtime_{}; bool record_process_dmabuf_rss_{}; bool resolve_process_fds_{}; + bool skip_main_thread_message_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<14> _has_field_{}; + std::bitset<15> _has_field_{}; }; } // namespace perfetto @@ -45537,14 +45371,400 @@ enum AtomId : int { ATOM_NOTIFICATION_MEMORY_USE = 10174, ATOM_HDR_CAPABILITIES = 10175, ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT = 10176, - ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED = 910, - ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED = 820, - ATOM_THERMAL_STATUS_CALLED = 772, - ATOM_THERMAL_HEADROOM_CALLED = 773, - ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED = 774, - ATOM_ADPF_HINT_SESSION_TID_CLEANUP = 839, - ATOM_THERMAL_HEADROOM_THRESHOLDS = 10201, - ATOM_ADPF_SESSION_SNAPSHOT = 10218, + ATOM_WIFI_AWARE_NDP_REPORTED = 638, + ATOM_WIFI_AWARE_ATTACH_REPORTED = 639, + ATOM_WIFI_SELF_RECOVERY_TRIGGERED = 661, + ATOM_SOFT_AP_STARTED = 680, + ATOM_SOFT_AP_STOPPED = 681, + ATOM_WIFI_LOCK_RELEASED = 687, + ATOM_WIFI_LOCK_DEACTIVATED = 688, + ATOM_WIFI_CONFIG_SAVED = 689, + ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED = 690, + ATOM_WIFI_AWARE_HAL_API_CALLED = 691, + ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED = 692, + ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED = 693, + ATOM_WIFI_THREAD_TASK_EXECUTED = 694, + ATOM_WIFI_STATE_CHANGED = 700, + ATOM_PNO_SCAN_STARTED = 719, + ATOM_PNO_SCAN_STOPPED = 720, + ATOM_WIFI_IS_UNUSABLE_REPORTED = 722, + ATOM_WIFI_AP_CAPABILITIES_REPORTED = 723, + ATOM_SOFT_AP_STATE_CHANGED = 805, + ATOM_SCORER_PREDICTION_RESULT_REPORTED = 884, + ATOM_WIFI_AWARE_CAPABILITIES = 10190, + ATOM_WIFI_MODULE_INFO = 10193, + ATOM_WIFI_SETTING_INFO = 10194, + ATOM_WIFI_COMPLEX_SETTING_INFO = 10195, + ATOM_WIFI_CONFIGURED_NETWORK_INFO = 10198, + ATOM_WEAR_POWER_MENU_OPENED = 731, + ATOM_WEAR_ASSISTANT_OPENED = 755, + ATOM_FIRST_OVERLAY_STATE_CHANGED = 917, + ATOM_WS_WEAR_TIME_SESSION = 610, + ATOM_WS_INCOMING_CALL_ACTION_REPORTED = 626, + ATOM_WS_CALL_DISCONNECTION_REPORTED = 627, + ATOM_WS_CALL_DURATION_REPORTED = 628, + ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED = 629, + ATOM_WS_CALL_INTERACTION_REPORTED = 630, + ATOM_WS_ON_BODY_STATE_CHANGED = 787, + ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED = 802, + ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED = 803, + ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED = 804, + ATOM_WS_REMOTE_EVENT_USAGE_REPORTED = 920, + ATOM_WS_NOTIFICATION_MANAGED_DISMISSAL_SYNC = 941, + ATOM_WS_BUGREPORT_EVENT_REPORTED = 964, + ATOM_WS_STANDALONE_MODE_SNAPSHOT = 10197, + ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT = 10206, + ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT = 10225, + ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT = 10227, + ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED = 619, + ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED = 620, + ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED = 621, + ATOM_WEAR_TIME_SYNC_REQUESTED = 911, + ATOM_WEAR_TIME_UPDATE_STARTED = 912, + ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED = 913, + ATOM_WEAR_TIME_CHANGED = 914, + ATOM_WEAR_SETUP_WIZARD_DEVICE_STATUS_REPORTED = 953, + ATOM_WEAR_SETUP_WIZARD_PAIRING_COMPLETED = 954, + ATOM_WEAR_SETUP_WIZARD_CONNECTION_ESTABLISHED = 955, + ATOM_WEAR_SETUP_WIZARD_CHECKIN_COMPLETED = 956, + ATOM_WEAR_SETUP_WIZARD_COMPANION_TIME_REPORTED = 957, + ATOM_WEAR_SETUP_WIZARD_STATUS_REPORTED = 958, + ATOM_WEAR_SETUP_WIZARD_HEARTBEAT_REPORTED = 959, + ATOM_WEAR_SETUP_WIZARD_FRP_TRIGGERED = 960, + ATOM_WEAR_SETUP_WIZARD_SYSTEM_UPDATE_TRIGGERED = 961, + ATOM_WEAR_SETUP_WIZARD_PHONE_SWITCH_TRIGGERED = 962, + ATOM_RENDERER_INITIALIZED = 736, + ATOM_SCHEMA_VERSION_RECEIVED = 737, + ATOM_LAYOUT_INSPECTED = 741, + ATOM_LAYOUT_EXPRESSION_INSPECTED = 742, + ATOM_LAYOUT_ANIMATIONS_INSPECTED = 743, + ATOM_MATERIAL_COMPONENTS_INSPECTED = 744, + ATOM_TILE_REQUESTED = 745, + ATOM_STATE_RESPONSE_RECEIVED = 746, + ATOM_TILE_RESPONSE_RECEIVED = 747, + ATOM_INFLATION_FINISHED = 748, + ATOM_INFLATION_FAILED = 749, + ATOM_IGNORED_INFLATION_FAILURES_REPORTED = 750, + ATOM_DRAWABLE_RENDERED = 751, + ATOM_WEAR_MODE_STATE_CHANGED = 715, + ATOM_MEDIA_ACTION_REPORTED = 608, + ATOM_MEDIA_CONTROLS_LAUNCHED = 609, + ATOM_MEDIA_SESSION_STATE_CHANGED = 677, + ATOM_MEDIA_CONTROL_API_USAGE_REPORTED = 966, + ATOM_MEDIA_SUBSCRIPTION_CHANGED = 990, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY = 757, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE = 758, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT = 759, + ATOM_MEDIATOR_UPDATED = 721, + ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER = 10196, + ATOM_SYSPROXY_CONNECTION_UPDATED = 786, + ATOM_WEAR_COMPANION_CONNECTION_STATE = 921, + ATOM_SYSPROXY_SERVICE_STATE_UPDATED = 949, + ATOM_UWB_ACTIVITY_INFO = 10188, + ATOM_TEST_UPROBESTATS_ATOM_REPORTED = 915, + ATOM_TV_LOW_POWER_STANDBY_POLICY = 679, + ATOM_EXTERNAL_TV_INPUT_EVENT = 717, + ATOM_BOOT_INTEGRITY_INFO_REPORTED = 775, + ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED = 738, + ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED = 739, + ATOM_THREADNETWORK_DEVICE_INFO_REPORTED = 740, + ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED = 713, + ATOM_EMERGENCY_NUMBERS_INFO = 10180, + ATOM_DATA_NETWORK_VALIDATION = 10207, + ATOM_DATA_RAT_STATE_CHANGED = 854, + ATOM_CONNECTED_CHANNEL_CHANGED = 882, + ATOM_CELLULAR_IDENTIFIER_DISCLOSED = 800, + ATOM_SATELLITE_CONTROLLER = 10182, + ATOM_SATELLITE_SESSION = 10183, + ATOM_SATELLITE_INCOMING_DATAGRAM = 10184, + ATOM_SATELLITE_OUTGOING_DATAGRAM = 10185, + ATOM_SATELLITE_PROVISION = 10186, + ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER = 10187, + ATOM_CARRIER_ROAMING_SATELLITE_SESSION = 10211, + ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS = 10212, + ATOM_CONTROLLER_STATS_PER_PACKAGE = 10213, + ATOM_SATELLITE_ENTITLEMENT = 10214, + ATOM_SATELLITE_CONFIG_UPDATER = 10215, + ATOM_SATELLITE_ACCESS_CONTROLLER = 10219, + ATOM_QUALIFIED_RAT_LIST_CHANGED = 634, + ATOM_QNS_IMS_CALL_DROP_STATS = 635, + ATOM_QNS_FALLBACK_RESTRICTION_CHANGED = 636, + ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO = 10177, + ATOM_QNS_HANDOVER_TIME_MILLIS = 10178, + ATOM_QNS_HANDOVER_PINGPONG = 10179, + ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED = 923, + ATOM_EMERGENCY_NUMBER_DIALED = 637, + ATOM_CALL_STATS = 10221, + ATOM_CALL_AUDIO_ROUTE_STATS = 10222, + ATOM_TELECOM_API_STATS = 10223, + ATOM_TELECOM_ERROR_STATS = 10224, + ATOM_LOCKSCREEN_SHORTCUT_SELECTED = 611, + ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED = 612, + ATOM_LAUNCHER_IMPRESSION_EVENT_V2 = 716, + ATOM_DISPLAY_SWITCH_LATENCY_TRACKED = 753, + ATOM_NOTIFICATION_LISTENER_SERVICE = 829, + ATOM_NAV_HANDLE_TOUCH_POINTS = 869, + ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED = 908, + ATOM_PERIPHERAL_TUTORIAL_LAUNCHED = 942, + ATOM_CONTEXTUAL_EDUCATION_TRIGGERED = 971, + ATOM_COMMUNAL_HUB_SNAPSHOT = 10226, + ATOM_TEST_EXTENSION_ATOM_REPORTED = 660, + ATOM_TEST_RESTRICTED_ATOM_REPORTED = 672, + ATOM_STATS_SOCKET_LOSS_REPORTED = 752, + ATOM_SETTINGS_SPA_REPORTED = 622, + ATOM_SELINUX_AUDIT_LOG = 799, + ATOM_SANDBOX_API_CALLED = 488, + ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED = 735, + ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION = 796, + ATOM_SANDBOX_SDK_STORAGE = 10159, + ATOM_RKPD_POOL_STATS = 664, + ATOM_RKPD_CLIENT_OPERATION = 665, + ATOM_RANGING_SESSION_CONFIGURED = 993, + ATOM_RANGING_SESSION_STARTED = 994, + ATOM_RANGING_SESSION_CLOSED = 995, + ATOM_RANGING_TECHNOLOGY_STARTED = 996, + ATOM_RANGING_TECHNOLOGY_STOPPED = 997, + ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED = 784, + ATOM_BACKUP_SETUP_STATUS_REPORTED = 785, + ATOM_SCREEN_OFF_REPORTED = 776, + ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED = 836, + ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED = 837, + ATOM_SCREEN_DIM_REPORTED = 867, + ATOM_ATOM_9999 = 9999, + ATOM_ATOM_99999 = 99999, + ATOM_PHOTOPICKER_SESSION_INFO_REPORTED = 886, + ATOM_PHOTOPICKER_API_INFO_REPORTED = 887, + ATOM_PHOTOPICKER_UI_EVENT_LOGGED = 888, + ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED = 889, + ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED = 890, + ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED = 891, + ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED = 892, + ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED = 893, + ATOM_PHOTOPICKER_PAGE_INFO_LOGGED = 894, + ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED = 895, + ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED = 896, + ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED = 897, + ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED = 898, + ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED = 899, + ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED = 645, + ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED = 646, + ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION = 647, + ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED = 648, + ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED = 649, + ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED = 827, + ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED = 828, + ATOM_PRESSURE_STALL_INFORMATION = 10229, + ATOM_PDF_LOAD_REPORTED = 859, + ATOM_PDF_API_USAGE_REPORTED = 860, + ATOM_PDF_SEARCH_REPORTED = 861, + ATOM_COMPONENT_STATE_CHANGED_REPORTED = 863, + ATOM_ONDEVICEPERSONALIZATION_API_CALLED = 711, + ATOM_ONDEVICEPERSONALIZATION_TRACE_EVENT = 952, + ATOM_NFC_OBSERVE_MODE_STATE_CHANGED = 855, + ATOM_NFC_FIELD_CHANGED = 856, + ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED = 857, + ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED = 858, + ATOM_NFC_EXIT_FRAME_TABLE_CHANGED = 1036, + ATOM_NFC_AUTO_TRANSACT_REPORTED = 1038, + ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED = 901, + ATOM_MTE_STATE = 10181, + ATOM_ZRAM_MAINTENANCE_EXECUTED = 1015, + ATOM_ZRAM_SETUP_EXECUTED = 1029, + ATOM_ZRAM_MM_STAT_MMD = 10232, + ATOM_ZRAM_BD_STAT_MMD = 10233, + ATOM_MEDIA_EDITING_ENDED_REPORTED = 798, + ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED = 600, + ATOM_MEDIA_CODEC_STARTED = 641, + ATOM_MEDIA_CODEC_STOPPED = 642, + ATOM_MEDIA_CODEC_RENDERED = 684, + ATOM_EMERGENCY_STATE_CHANGED = 633, + ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED = 868, + ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED = 1002, + ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED = 1003, + ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED = 1004, + ATOM_KERNEL_OOM_KILL_OCCURRED = 754, + ATOM_KEYBOARD_CONFIGURED = 682, + ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED = 683, + ATOM_INPUTDEVICE_USAGE_REPORTED = 686, + ATOM_INPUT_EVENT_LATENCY_REPORTED = 932, + ATOM_TOUCHPAD_USAGE = 10191, + ATOM_IKE_SESSION_TERMINATED = 678, + ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED = 760, + ATOM_NEGOTIATED_SECURITY_ASSOCIATION = 821, + ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED = 761, + ATOM_HEALTH_CONNECT_UI_IMPRESSION = 623, + ATOM_HEALTH_CONNECT_UI_INTERACTION = 624, + ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED = 625, + ATOM_HEALTH_CONNECT_API_CALLED = 616, + ATOM_HEALTH_CONNECT_USAGE_STATS = 617, + ATOM_HEALTH_CONNECT_STORAGE_STATS = 618, + ATOM_HEALTH_CONNECT_API_INVOKED = 643, + ATOM_EXERCISE_ROUTE_API_CALLED = 654, + ATOM_HEALTH_CONNECT_EXPORT_INVOKED = 907, + ATOM_HEALTH_CONNECT_IMPORT_INVOKED = 918, + ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED = 919, + ATOM_HEALTH_CONNECT_PERMISSION_STATS = 963, + ATOM_HEALTH_CONNECT_PHR_API_INVOKED = 980, + ATOM_HEALTH_CONNECT_PHR_USAGE_STATS = 981, + ATOM_HEALTH_CONNECT_PHR_STORAGE_STATS = 984, + ATOM_HEALTH_CONNECT_RESTRICTED_ECOSYSTEM_STATS = 985, + ATOM_HEALTH_CONNECT_ECOSYSTEM_STATS = 986, + ATOM_HDMI_EARC_STATUS_REPORTED = 701, + ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED = 724, + ATOM_HDMI_POWER_STATE_CHANGE_ON_ACTIVE_SOURCE_LOST_TOGGLED = 991, + ATOM_BATTERY_HEALTH = 10220, + ATOM_BIOMETRIC_UNENROLLED = 944, + ATOM_BIOMETRIC_ENUMERATED = 945, + ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED = 584, + ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED = 816, + ATOM_FULL_SCREEN_INTENT_LAUNCHED = 631, + ATOM_BAL_ALLOWED = 632, + ATOM_IN_TASK_ACTIVITY_STARTED = 685, + ATOM_DEVICE_ORIENTATION_CHANGED = 906, + ATOM_CACHED_APPS_HIGH_WATERMARK = 10189, + ATOM_STYLUS_PREDICTION_METRICS_REPORTED = 718, + ATOM_USER_RISK_EVENT_REPORTED = 725, + ATOM_MEDIA_PROJECTION_STATE_CHANGED = 729, + ATOM_MEDIA_PROJECTION_TARGET_CHANGED = 730, + ATOM_EXCESSIVE_BINDER_PROXY_COUNT_REPORTED = 853, + ATOM_PROXY_BYTES_TRANSFER_BY_FG_BG = 10200, + ATOM_MOBILE_BYTES_TRANSFER_BY_PROC_STATE = 10204, + ATOM_BIOMETRIC_FRR_NOTIFICATION = 817, + ATOM_SENSITIVE_CONTENT_MEDIA_PROJECTION_SESSION = 830, + ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_SESSION = 831, + ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_APPLIED = 832, + ATOM_SENSITIVE_NOTIFICATION_REDACTION = 833, + ATOM_SENSITIVE_CONTENT_APP_PROTECTION = 835, + ATOM_APP_RESTRICTION_STATE_CHANGED = 866, + ATOM_BATTERY_USAGE_STATS_PER_UID = 10209, + ATOM_POSTGC_MEMORY_SNAPSHOT = 924, + ATOM_POWER_SAVE_TEMP_ALLOWLIST_CHANGED = 926, + ATOM_APP_OP_ACCESS_TRACKED = 931, + ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED = 933, + ATOM_DEVICE_IDLE_TEMP_ALLOWLIST_UPDATED = 940, + ATOM_APP_OP_NOTE_OP_OR_CHECK_OP_BINDER_API_CALLED = 943, + ATOM_FRAMEWORK_WAKELOCK_INFO = 10230, + ATOM_JANK_FRAME_COUNT_BY_WIDGET_REPORTED = 950, + ATOM_INTENT_CREATOR_TOKEN_ADDED = 978, + ATOM_NOTIFICATION_CHANNEL_CLASSIFICATION = 983, + ATOM_CAMERA_STATUS_FOR_COMPATIBILITY_CHANGED = 999, + ATOM_FEDERATED_COMPUTE_API_CALLED = 712, + ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED = 771, + ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED = 838, + ATOM_FEDERATED_COMPUTE_TRACE_EVENT_REPORTED = 992, + ATOM_EXPRESS_EVENT_REPORTED = 528, + ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED = 593, + ATOM_EXPRESS_UID_EVENT_REPORTED = 644, + ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED = 658, + ATOM_DREAM_SETTING_CHANGED = 705, + ATOM_DREAM_SETTING_SNAPSHOT = 10192, + ATOM_DND_STATE_CHANGED = 657, + ATOM_EXTERNAL_DISPLAY_STATE_CHANGED = 806, + ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED = 792, + ATOM_DEVICE_POLICY_MANAGEMENT_MODE = 10216, + ATOM_DEVICE_POLICY_STATE = 10217, + ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED = 726, + ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED = 727, + ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED = 728, + ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED = 789, + ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED = 790, + ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED = 791, + ATOM_DESKTOP_MODE_UI_CHANGED = 818, + ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE = 819, + ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED = 935, + ATOM_CRONET_ENGINE_CREATED = 703, + ATOM_CRONET_TRAFFIC_REPORTED = 704, + ATOM_CRONET_ENGINE_BUILDER_INITIALIZED = 762, + ATOM_CRONET_HTTP_FLAGS_INITIALIZED = 763, + ATOM_CRONET_INITIALIZED = 764, + ATOM_CREDENTIAL_MANAGER_API_CALLED = 585, + ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED = 651, + ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED = 652, + ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED = 653, + ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED = 667, + ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED = 668, + ATOM_CREDENTIAL_MANAGER_GET_REPORTED = 669, + ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED = 670, + ATOM_CREDENTIAL_MANAGER_APIV2_CALLED = 671, + ATOM_CPU_POLICY = 10199, + ATOM_VPN_CONNECTION_STATE_CHANGED = 850, + ATOM_VPN_CONNECTION_REPORTED = 851, + ATOM_IP_CLIENT_RA_INFO_REPORTED = 778, + ATOM_APF_SESSION_INFO_REPORTED = 777, + ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED = 979, + ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED = 783, + ATOM_DAILY_KEEPALIVE_INFO_REPORTED = 650, + ATOM_NETWORK_REQUEST_STATE_CHANGED = 779, + ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED = 925, + ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_STATE_CHANGED = 972, + ATOM_HARDWARE_RENDERER_EVENT = 946, + ATOM_TEXTURE_VIEW_EVENT = 947, + ATOM_SURFACE_CONTROL_EVENT = 948, + ATOM_IMAGE_DECODED = 977, + ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED = 934, + ATOM_CONSCRYPT_SERVICE_USED = 965, + ATOM_CERTIFICATE_TRANSPARENCY_VERIFICATION_REPORTED = 989, + ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT = 900, + ATOM_BROADCAST_SENT = 922, + ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED = 613, + ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION = 614, + ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION = 615, + ATOM_BLUETOOTH_LE_SESSION_CONNECTED = 656, + ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED = 666, + ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED = 696, + ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED = 781, + ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED = 782, + ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID = 862, + ATOM_LE_APP_SCAN_STATE_CHANGED = 870, + ATOM_LE_RADIO_SCAN_STOPPED = 871, + ATOM_LE_SCAN_RESULT_RECEIVED = 872, + ATOM_LE_SCAN_ABUSED = 873, + ATOM_LE_ADV_STATE_CHANGED = 874, + ATOM_LE_ADV_ERROR_REPORTED = 875, + ATOM_A2DP_SESSION_REPORTED = 904, + ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED = 916, + ATOM_BROADCAST_AUDIO_SESSION_REPORTED = 927, + ATOM_BROADCAST_AUDIO_SYNC_REPORTED = 928, + ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE = 982, + ATOM_BLUETOOTH_LE_CONNECTION = 988, + ATOM_HEARING_DEVICE_ACTIVE_EVENT_REPORTED = 1021, + ATOM_BACKPORTED_FIX_STATUS_REPORTED = 987, + ATOM_PLUGIN_INITIALIZED = 655, + ATOM_CAR_SYSTEM_UI_DATA_SUBSCRIPTION_EVENT_REPORTED = 974, + ATOM_CAR_SETTINGS_DATA_SUBSCRIPTION_EVENT_REPORTED = 975, + ATOM_CAR_QC_LIB_EVENT_REPORTED = 976, + ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED = 852, + ATOM_CAR_RECENTS_EVENT_REPORTED = 770, + ATOM_CAR_CALM_MODE_EVENT_REPORTED = 797, + ATOM_AUTOFILL_UI_EVENT_REPORTED = 603, + ATOM_AUTOFILL_FILL_REQUEST_REPORTED = 604, + ATOM_AUTOFILL_FILL_RESPONSE_REPORTED = 605, + ATOM_AUTOFILL_SAVE_EVENT_REPORTED = 606, + ATOM_AUTOFILL_SESSION_COMMITTED = 607, + ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED = 659, + ATOM_ODREFRESH_REPORTED = 366, + ATOM_ODSIGN_REPORTED = 548, + ATOM_BACKGROUND_DEXOPT_JOB_ENDED = 467, + ATOM_PREREBOOT_DEXOPT_JOB_ENDED = 883, + ATOM_ART_DATUM_REPORTED = 332, + ATOM_ART_DEVICE_DATUM_REPORTED = 550, + ATOM_ART_DATUM_DELTA_REPORTED = 565, + ATOM_ART_DEX2OAT_REPORTED = 929, + ATOM_ART_DEVICE_STATUS = 10205, + ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED = 385, + ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED = 579, + ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED = 825, + ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED = 826, + ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED = 909, + ATOM_APP_FUNCTIONS_REQUEST_REPORTED = 998, + ATOM_APEX_INSTALLATION_REQUESTED = 732, + ATOM_APEX_INSTALLATION_STAGED = 733, + ATOM_APEX_INSTALLATION_ENDED = 734, + ATOM_AI_WALLPAPERS_BUTTON_PRESSED = 706, + ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED = 707, + ATOM_AI_WALLPAPERS_TERM_SELECTED = 708, + ATOM_AI_WALLPAPERS_WALLPAPER_SET = 709, + ATOM_AI_WALLPAPERS_SESSION_SUMMARY = 710, ATOM_JSSCRIPTENGINE_LATENCY_REPORTED = 483, ATOM_AD_SERVICES_API_CALLED = 435, ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED = 436, @@ -45616,351 +45836,19 @@ enum AtomId : int { ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED = 903, ATOM_UPDATE_SIGNALS_PROCESS_REPORTED = 905, ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED = 930, - ATOM_AI_WALLPAPERS_BUTTON_PRESSED = 706, - ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED = 707, - ATOM_AI_WALLPAPERS_TERM_SELECTED = 708, - ATOM_AI_WALLPAPERS_WALLPAPER_SET = 709, - ATOM_AI_WALLPAPERS_SESSION_SUMMARY = 710, - ATOM_APEX_INSTALLATION_REQUESTED = 732, - ATOM_APEX_INSTALLATION_STAGED = 733, - ATOM_APEX_INSTALLATION_ENDED = 734, - ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED = 385, - ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED = 579, - ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED = 825, - ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED = 826, - ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED = 909, - ATOM_ART_DATUM_REPORTED = 332, - ATOM_ART_DEVICE_DATUM_REPORTED = 550, - ATOM_ART_DATUM_DELTA_REPORTED = 565, - ATOM_ART_DEX2OAT_REPORTED = 929, - ATOM_ART_DEVICE_STATUS = 10205, - ATOM_BACKGROUND_DEXOPT_JOB_ENDED = 467, - ATOM_PREREBOOT_DEXOPT_JOB_ENDED = 883, - ATOM_ODREFRESH_REPORTED = 366, - ATOM_ODSIGN_REPORTED = 548, - ATOM_AUTOFILL_UI_EVENT_REPORTED = 603, - ATOM_AUTOFILL_FILL_REQUEST_REPORTED = 604, - ATOM_AUTOFILL_FILL_RESPONSE_REPORTED = 605, - ATOM_AUTOFILL_SAVE_EVENT_REPORTED = 606, - ATOM_AUTOFILL_SESSION_COMMITTED = 607, - ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED = 659, - ATOM_CAR_RECENTS_EVENT_REPORTED = 770, - ATOM_CAR_CALM_MODE_EVENT_REPORTED = 797, - ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED = 852, - ATOM_PLUGIN_INITIALIZED = 655, - ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED = 613, - ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION = 614, - ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION = 615, - ATOM_BLUETOOTH_LE_SESSION_CONNECTED = 656, - ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED = 666, - ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED = 696, - ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED = 781, - ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED = 782, - ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID = 862, - ATOM_LE_APP_SCAN_STATE_CHANGED = 870, - ATOM_LE_RADIO_SCAN_STOPPED = 871, - ATOM_LE_SCAN_RESULT_RECEIVED = 872, - ATOM_LE_SCAN_ABUSED = 873, - ATOM_LE_ADV_STATE_CHANGED = 874, - ATOM_LE_ADV_ERROR_REPORTED = 875, - ATOM_A2DP_SESSION_REPORTED = 904, - ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED = 916, - ATOM_BROADCAST_AUDIO_SESSION_REPORTED = 927, - ATOM_BROADCAST_AUDIO_SYNC_REPORTED = 928, - ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE = 982, - ATOM_BLUETOOTH_LE_CONNECTION = 988, - ATOM_BROADCAST_SENT = 922, - ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT = 900, - ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED = 934, - ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_FAILED = 972, - ATOM_DAILY_KEEPALIVE_INFO_REPORTED = 650, - ATOM_NETWORK_REQUEST_STATE_CHANGED = 779, - ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED = 925, - ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED = 783, - ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED = 979, - ATOM_APF_SESSION_INFO_REPORTED = 777, - ATOM_IP_CLIENT_RA_INFO_REPORTED = 778, - ATOM_VPN_CONNECTION_STATE_CHANGED = 850, - ATOM_VPN_CONNECTION_REPORTED = 851, - ATOM_CPU_POLICY = 10199, - ATOM_CREDENTIAL_MANAGER_API_CALLED = 585, - ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED = 651, - ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED = 652, - ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED = 653, - ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED = 667, - ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED = 668, - ATOM_CREDENTIAL_MANAGER_GET_REPORTED = 669, - ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED = 670, - ATOM_CREDENTIAL_MANAGER_APIV2_CALLED = 671, - ATOM_CRONET_ENGINE_CREATED = 703, - ATOM_CRONET_TRAFFIC_REPORTED = 704, - ATOM_CRONET_ENGINE_BUILDER_INITIALIZED = 762, - ATOM_CRONET_HTTP_FLAGS_INITIALIZED = 763, - ATOM_CRONET_INITIALIZED = 764, - ATOM_DESKTOP_MODE_UI_CHANGED = 818, - ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE = 819, - ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED = 935, - ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED = 726, - ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED = 727, - ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED = 728, - ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED = 789, - ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED = 790, - ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED = 791, - ATOM_DEVICE_POLICY_MANAGEMENT_MODE = 10216, - ATOM_DEVICE_POLICY_STATE = 10217, - ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED = 792, - ATOM_EXTERNAL_DISPLAY_STATE_CHANGED = 806, - ATOM_DND_STATE_CHANGED = 657, - ATOM_DREAM_SETTING_CHANGED = 705, - ATOM_DREAM_SETTING_SNAPSHOT = 10192, - ATOM_EXPRESS_EVENT_REPORTED = 528, - ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED = 593, - ATOM_EXPRESS_UID_EVENT_REPORTED = 644, - ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED = 658, - ATOM_FEDERATED_COMPUTE_API_CALLED = 712, - ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED = 771, - ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED = 838, - ATOM_FULL_SCREEN_INTENT_LAUNCHED = 631, - ATOM_BAL_ALLOWED = 632, - ATOM_IN_TASK_ACTIVITY_STARTED = 685, - ATOM_DEVICE_ORIENTATION_CHANGED = 906, - ATOM_CACHED_APPS_HIGH_WATERMARK = 10189, - ATOM_STYLUS_PREDICTION_METRICS_REPORTED = 718, - ATOM_USER_RISK_EVENT_REPORTED = 725, - ATOM_MEDIA_PROJECTION_STATE_CHANGED = 729, - ATOM_MEDIA_PROJECTION_TARGET_CHANGED = 730, - ATOM_EXCESSIVE_BINDER_PROXY_COUNT_REPORTED = 853, - ATOM_PROXY_BYTES_TRANSFER_BY_FG_BG = 10200, - ATOM_MOBILE_BYTES_TRANSFER_BY_PROC_STATE = 10204, - ATOM_BIOMETRIC_FRR_NOTIFICATION = 817, - ATOM_SENSITIVE_CONTENT_MEDIA_PROJECTION_SESSION = 830, - ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_SESSION = 831, - ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_APPLIED = 832, - ATOM_SENSITIVE_NOTIFICATION_REDACTION = 833, - ATOM_SENSITIVE_CONTENT_APP_PROTECTION = 835, - ATOM_APP_RESTRICTION_STATE_CHANGED = 866, - ATOM_BATTERY_USAGE_STATS_PER_UID = 10209, - ATOM_POSTGC_MEMORY_SNAPSHOT = 924, - ATOM_POWER_SAVE_TEMP_ALLOWLIST_CHANGED = 926, - ATOM_APP_OP_ACCESS_TRACKED = 931, - ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED = 933, - ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED = 584, - ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED = 816, - ATOM_BATTERY_HEALTH = 10220, - ATOM_HDMI_EARC_STATUS_REPORTED = 701, - ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED = 724, - ATOM_HEALTH_CONNECT_API_CALLED = 616, - ATOM_HEALTH_CONNECT_USAGE_STATS = 617, - ATOM_HEALTH_CONNECT_STORAGE_STATS = 618, - ATOM_HEALTH_CONNECT_API_INVOKED = 643, - ATOM_EXERCISE_ROUTE_API_CALLED = 654, - ATOM_HEALTH_CONNECT_EXPORT_INVOKED = 907, - ATOM_HEALTH_CONNECT_IMPORT_INVOKED = 918, - ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED = 919, - ATOM_HEALTH_CONNECT_UI_IMPRESSION = 623, - ATOM_HEALTH_CONNECT_UI_INTERACTION = 624, - ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED = 625, - ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED = 761, - ATOM_IKE_SESSION_TERMINATED = 678, - ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED = 760, - ATOM_NEGOTIATED_SECURITY_ASSOCIATION = 821, - ATOM_KEYBOARD_CONFIGURED = 682, - ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED = 683, - ATOM_INPUTDEVICE_USAGE_REPORTED = 686, - ATOM_INPUT_EVENT_LATENCY_REPORTED = 932, - ATOM_TOUCHPAD_USAGE = 10191, - ATOM_KERNEL_OOM_KILL_OCCURRED = 754, - ATOM_EMERGENCY_STATE_CHANGED = 633, - ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED = 868, - ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED = 1002, - ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED = 1003, - ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED = 1004, - ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED = 600, - ATOM_MEDIA_CODEC_STARTED = 641, - ATOM_MEDIA_CODEC_STOPPED = 642, - ATOM_MEDIA_CODEC_RENDERED = 684, - ATOM_MEDIA_EDITING_ENDED_REPORTED = 798, - ATOM_MTE_STATE = 10181, - ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED = 901, - ATOM_NFC_OBSERVE_MODE_STATE_CHANGED = 855, - ATOM_NFC_FIELD_CHANGED = 856, - ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED = 857, - ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED = 858, - ATOM_ONDEVICEPERSONALIZATION_API_CALLED = 711, - ATOM_COMPONENT_STATE_CHANGED_REPORTED = 863, - ATOM_PDF_LOAD_REPORTED = 859, - ATOM_PDF_API_USAGE_REPORTED = 860, - ATOM_PDF_SEARCH_REPORTED = 861, - ATOM_PRESSURE_STALL_INFORMATION = 10229, - ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED = 645, - ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED = 646, - ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION = 647, - ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED = 648, - ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED = 649, - ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED = 827, - ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED = 828, - ATOM_PHOTOPICKER_SESSION_INFO_REPORTED = 886, - ATOM_PHOTOPICKER_API_INFO_REPORTED = 887, - ATOM_PHOTOPICKER_UI_EVENT_LOGGED = 888, - ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED = 889, - ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED = 890, - ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED = 891, - ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED = 892, - ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED = 893, - ATOM_PHOTOPICKER_PAGE_INFO_LOGGED = 894, - ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED = 895, - ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED = 896, - ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED = 897, - ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED = 898, - ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED = 899, - ATOM_ATOM_9999 = 9999, - ATOM_ATOM_99999 = 99999, - ATOM_SCREEN_OFF_REPORTED = 776, - ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED = 836, - ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED = 837, - ATOM_SCREEN_DIM_REPORTED = 867, - ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED = 784, - ATOM_BACKUP_SETUP_STATUS_REPORTED = 785, - ATOM_RANGING_SESSION_CONFIGURED = 993, - ATOM_RANGING_SESSION_STARTED = 994, - ATOM_RANGING_SESSION_CLOSED = 995, - ATOM_RANGING_TECHNOLOGY_STARTED = 996, - ATOM_RANGING_TECHNOLOGY_STOPPED = 997, - ATOM_RKPD_POOL_STATS = 664, - ATOM_RKPD_CLIENT_OPERATION = 665, - ATOM_SANDBOX_API_CALLED = 488, - ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED = 735, - ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION = 796, - ATOM_SANDBOX_SDK_STORAGE = 10159, - ATOM_SELINUX_AUDIT_LOG = 799, - ATOM_SETTINGS_SPA_REPORTED = 622, - ATOM_TEST_EXTENSION_ATOM_REPORTED = 660, - ATOM_TEST_RESTRICTED_ATOM_REPORTED = 672, - ATOM_STATS_SOCKET_LOSS_REPORTED = 752, - ATOM_LOCKSCREEN_SHORTCUT_SELECTED = 611, - ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED = 612, - ATOM_LAUNCHER_IMPRESSION_EVENT_V2 = 716, - ATOM_DISPLAY_SWITCH_LATENCY_TRACKED = 753, - ATOM_NOTIFICATION_LISTENER_SERVICE = 829, - ATOM_NAV_HANDLE_TOUCH_POINTS = 869, - ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED = 908, - ATOM_COMMUNAL_HUB_SNAPSHOT = 10226, - ATOM_EMERGENCY_NUMBER_DIALED = 637, - ATOM_CALL_STATS = 10221, - ATOM_CALL_AUDIO_ROUTE_STATS = 10222, - ATOM_TELECOM_API_STATS = 10223, - ATOM_TELECOM_ERROR_STATS = 10224, - ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED = 713, - ATOM_EMERGENCY_NUMBERS_INFO = 10180, - ATOM_DATA_NETWORK_VALIDATION = 10207, - ATOM_DATA_RAT_STATE_CHANGED = 854, - ATOM_CONNECTED_CHANNEL_CHANGED = 882, - ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED = 923, - ATOM_QUALIFIED_RAT_LIST_CHANGED = 634, - ATOM_QNS_IMS_CALL_DROP_STATS = 635, - ATOM_QNS_FALLBACK_RESTRICTION_CHANGED = 636, - ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO = 10177, - ATOM_QNS_HANDOVER_TIME_MILLIS = 10178, - ATOM_QNS_HANDOVER_PINGPONG = 10179, - ATOM_SATELLITE_CONTROLLER = 10182, - ATOM_SATELLITE_SESSION = 10183, - ATOM_SATELLITE_INCOMING_DATAGRAM = 10184, - ATOM_SATELLITE_OUTGOING_DATAGRAM = 10185, - ATOM_SATELLITE_PROVISION = 10186, - ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER = 10187, - ATOM_CARRIER_ROAMING_SATELLITE_SESSION = 10211, - ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS = 10212, - ATOM_CONTROLLER_STATS_PER_PACKAGE = 10213, - ATOM_SATELLITE_ENTITLEMENT = 10214, - ATOM_SATELLITE_CONFIG_UPDATER = 10215, - ATOM_SATELLITE_ACCESS_CONTROLLER = 10219, - ATOM_CELLULAR_IDENTIFIER_DISCLOSED = 800, - ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED = 738, - ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED = 739, - ATOM_THREADNETWORK_DEVICE_INFO_REPORTED = 740, - ATOM_BOOT_INTEGRITY_INFO_REPORTED = 775, - ATOM_TV_LOW_POWER_STANDBY_POLICY = 679, - ATOM_EXTERNAL_TV_INPUT_EVENT = 717, - ATOM_TEST_UPROBESTATS_ATOM_REPORTED = 915, - ATOM_UWB_ACTIVITY_INFO = 10188, - ATOM_MEDIATOR_UPDATED = 721, - ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER = 10196, - ATOM_SYSPROXY_CONNECTION_UPDATED = 786, - ATOM_WEAR_COMPANION_CONNECTION_STATE = 921, - ATOM_MEDIA_ACTION_REPORTED = 608, - ATOM_MEDIA_CONTROLS_LAUNCHED = 609, - ATOM_MEDIA_SESSION_STATE_CHANGED = 677, - ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY = 757, - ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE = 758, - ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT = 759, - ATOM_WEAR_MODE_STATE_CHANGED = 715, - ATOM_RENDERER_INITIALIZED = 736, - ATOM_SCHEMA_VERSION_RECEIVED = 737, - ATOM_LAYOUT_INSPECTED = 741, - ATOM_LAYOUT_EXPRESSION_INSPECTED = 742, - ATOM_LAYOUT_ANIMATIONS_INSPECTED = 743, - ATOM_MATERIAL_COMPONENTS_INSPECTED = 744, - ATOM_TILE_REQUESTED = 745, - ATOM_STATE_RESPONSE_RECEIVED = 746, - ATOM_TILE_RESPONSE_RECEIVED = 747, - ATOM_INFLATION_FINISHED = 748, - ATOM_INFLATION_FAILED = 749, - ATOM_IGNORED_INFLATION_FAILURES_REPORTED = 750, - ATOM_DRAWABLE_RENDERED = 751, - ATOM_WEAR_TIME_SYNC_REQUESTED = 911, - ATOM_WEAR_TIME_UPDATE_STARTED = 912, - ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED = 913, - ATOM_WEAR_TIME_CHANGED = 914, - ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED = 619, - ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED = 620, - ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED = 621, - ATOM_WS_WEAR_TIME_SESSION = 610, - ATOM_WS_INCOMING_CALL_ACTION_REPORTED = 626, - ATOM_WS_CALL_DISCONNECTION_REPORTED = 627, - ATOM_WS_CALL_DURATION_REPORTED = 628, - ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED = 629, - ATOM_WS_CALL_INTERACTION_REPORTED = 630, - ATOM_WS_ON_BODY_STATE_CHANGED = 787, - ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED = 802, - ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED = 803, - ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED = 804, - ATOM_WS_REMOTE_EVENT_USAGE_REPORTED = 920, - ATOM_WS_BUGREPORT_REQUESTED = 936, - ATOM_WS_BUGREPORT_TRIGGERED = 937, - ATOM_WS_BUGREPORT_FINISHED = 938, - ATOM_WS_BUGREPORT_RESULT_RECEIVED = 939, - ATOM_WS_STANDALONE_MODE_SNAPSHOT = 10197, - ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT = 10206, - ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT = 10225, - ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT = 10227, - ATOM_WEAR_POWER_MENU_OPENED = 731, - ATOM_WEAR_ASSISTANT_OPENED = 755, - ATOM_FIRST_OVERLAY_STATE_CHANGED = 917, - ATOM_WIFI_AWARE_NDP_REPORTED = 638, - ATOM_WIFI_AWARE_ATTACH_REPORTED = 639, - ATOM_WIFI_SELF_RECOVERY_TRIGGERED = 661, - ATOM_SOFT_AP_STARTED = 680, - ATOM_SOFT_AP_STOPPED = 681, - ATOM_WIFI_LOCK_RELEASED = 687, - ATOM_WIFI_LOCK_DEACTIVATED = 688, - ATOM_WIFI_CONFIG_SAVED = 689, - ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED = 690, - ATOM_WIFI_AWARE_HAL_API_CALLED = 691, - ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED = 692, - ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED = 693, - ATOM_WIFI_THREAD_TASK_EXECUTED = 694, - ATOM_WIFI_STATE_CHANGED = 700, - ATOM_PNO_SCAN_STARTED = 719, - ATOM_PNO_SCAN_STOPPED = 720, - ATOM_WIFI_IS_UNUSABLE_REPORTED = 722, - ATOM_WIFI_AP_CAPABILITIES_REPORTED = 723, - ATOM_SOFT_AP_STATE_CHANGED = 805, - ATOM_SCORER_PREDICTION_RESULT_REPORTED = 884, - ATOM_WIFI_AWARE_CAPABILITIES = 10190, - ATOM_WIFI_MODULE_INFO = 10193, - ATOM_WIFI_SETTING_INFO = 10194, - ATOM_WIFI_COMPLEX_SETTING_INFO = 10195, - ATOM_WIFI_CONFIGURED_NETWORK_INFO = 10198, + ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_SCHEDULE_ATTEMPTED = 967, + ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_PERFORMED = 968, + ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_PERFORMED_ATTEMPTED_FAILURE_REPORTED = 969, + ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_BACKGROUND_JOB_RAN = 970, + ATOM_THERMAL_STATUS_CALLED = 772, + ATOM_THERMAL_HEADROOM_CALLED = 773, + ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED = 774, + ATOM_ADPF_HINT_SESSION_TID_CLEANUP = 839, + ATOM_THERMAL_HEADROOM_THRESHOLDS = 10201, + ATOM_ADPF_SESSION_SNAPSHOT = 10218, + ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED = 820, + ATOM_ACCOUNT_MANAGER_EVENT = 951, + ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED = 910, }; } // namespace perfetto } // namespace protos @@ -46637,7 +46525,8 @@ class ChromeFieldTracingConfig; class ScenarioConfig; class NestedScenarioConfig; class TraceConfig; -class TraceConfig_Note; +class TraceAttributes; +class TraceAttributes_Attribute; class PriorityBoostConfig; class TraceConfig_SessionSemaphore; class TraceConfig_CmdTraceStartDelay; @@ -46646,6 +46535,9 @@ class TraceConfig_TraceFilter; class TraceConfig_TraceFilter_StringFilterChain; class TraceConfig_TraceFilter_StringFilterRule; class TraceConfig_IncidentReportConfig; +class TraceConfig_CompressionConfig; +class TraceConfig_CompressionConfig_Zstd; +class TraceConfig_CompressionConfig_Deflate; class TraceConfig_IncrementalStateConfig; class TraceConfig_TriggerConfig; class TraceConfig_TriggerConfig_Trigger; @@ -47464,7 +47356,8 @@ namespace gen { class StressTestConfig; class StressTestConfig_WriterTiming; class TraceConfig; -class TraceConfig_Note; +class TraceAttributes; +class TraceAttributes_Attribute; class PriorityBoostConfig; class TraceConfig_SessionSemaphore; class TraceConfig_CmdTraceStartDelay; @@ -47473,6 +47366,9 @@ class TraceConfig_TraceFilter; class TraceConfig_TraceFilter_StringFilterChain; class TraceConfig_TraceFilter_StringFilterRule; class TraceConfig_IncidentReportConfig; +class TraceConfig_CompressionConfig; +class TraceConfig_CompressionConfig_Zstd; +class TraceConfig_CompressionConfig_Deflate; class TraceConfig_IncrementalStateConfig; class TraceConfig_TriggerConfig; class TraceConfig_TriggerConfig_Trigger; @@ -49052,7 +48948,7 @@ const char* DisplayVideoConfig_Format_Name(::perfetto::protos::pbzero::DisplayVi return "PBZERO_UNKNOWN_ENUM_VALUE"; } -class DisplayVideoConfig_Decoder : public ::protozero::TypedProtoDecoder { +class DisplayVideoConfig_Decoder : public ::protozero::TypedProtoDecoder { public: DisplayVideoConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit DisplayVideoConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -49065,6 +48961,8 @@ class DisplayVideoConfig_Decoder : public ::protozero::TypedProtoDecoder().as_uint32(); } bool has_max_stream_size_bytes() const { return at<4>().valid(); } uint64_t max_stream_size_bytes() const { return at<4>().as_uint64(); } + bool has_bitrate_bps() const { return at<5>().valid(); } + uint32_t bitrate_bps() const { return at<5>().as_uint32(); } }; class DisplayVideoConfig : public ::protozero::Message { @@ -49075,6 +48973,7 @@ class DisplayVideoConfig : public ::protozero::Message { kFormatFieldNumber = 2, kKeyFrameIntervalSecsFieldNumber = 3, kMaxStreamSizeBytesFieldNumber = 4, + kBitrateBpsFieldNumber = 5, }; static constexpr const char* GetName() { return ".perfetto.protos.DisplayVideoConfig"; } @@ -49158,6 +49057,24 @@ class DisplayVideoConfig : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } + + using FieldMetadata_BitrateBps = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayVideoConfig>; + + static constexpr FieldMetadata_BitrateBps kBitrateBps{}; + void set_bitrate_bps(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BitrateBps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } }; } // Namespace. @@ -53448,7 +53365,7 @@ const char* ProcessStatsConfig_Quirks_Name(::perfetto::protos::pbzero::ProcessSt return "PBZERO_UNKNOWN_ENUM_VALUE"; } -class ProcessStatsConfig_Decoder : public ::protozero::TypedProtoDecoder { +class ProcessStatsConfig_Decoder : public ::protozero::TypedProtoDecoder { public: ProcessStatsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit ProcessStatsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -53473,6 +53390,8 @@ class ProcessStatsConfig_Decoder : public ::protozero::TypedProtoDecoder().as_bool(); } bool has_resolve_process_fds() const { return at<9>().valid(); } bool resolve_process_fds() const { return at<9>().as_bool(); } + bool has_skip_main_thread_message() const { return at<14>().valid(); } + bool skip_main_thread_message() const { return at<14>().as_bool(); } }; class ProcessStatsConfig : public ::protozero::Message { @@ -53489,6 +53408,7 @@ class ProcessStatsConfig : public ::protozero::Message { kRecordProcessRuntimeFieldNumber = 12, kRecordProcessDmabufRssFieldNumber = 13, kResolveProcessFdsFieldNumber = 9, + kSkipMainThreadMessageFieldNumber = 14, }; static constexpr const char* GetName() { return ".perfetto.protos.ProcessStatsConfig"; } @@ -53680,6 +53600,24 @@ class ProcessStatsConfig : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } + + using FieldMetadata_SkipMainThreadMessage = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessStatsConfig>; + + static constexpr FieldMetadata_SkipMainThreadMessage kSkipMainThreadMessage{}; + void set_skip_main_thread_message(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SkipMainThreadMessage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } }; } // Namespace. @@ -56850,14 +56788,400 @@ enum AtomId : int32_t { ATOM_NOTIFICATION_MEMORY_USE = 10174, ATOM_HDR_CAPABILITIES = 10175, ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT = 10176, - ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED = 910, - ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED = 820, - ATOM_THERMAL_STATUS_CALLED = 772, - ATOM_THERMAL_HEADROOM_CALLED = 773, - ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED = 774, - ATOM_ADPF_HINT_SESSION_TID_CLEANUP = 839, - ATOM_THERMAL_HEADROOM_THRESHOLDS = 10201, - ATOM_ADPF_SESSION_SNAPSHOT = 10218, + ATOM_WIFI_AWARE_NDP_REPORTED = 638, + ATOM_WIFI_AWARE_ATTACH_REPORTED = 639, + ATOM_WIFI_SELF_RECOVERY_TRIGGERED = 661, + ATOM_SOFT_AP_STARTED = 680, + ATOM_SOFT_AP_STOPPED = 681, + ATOM_WIFI_LOCK_RELEASED = 687, + ATOM_WIFI_LOCK_DEACTIVATED = 688, + ATOM_WIFI_CONFIG_SAVED = 689, + ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED = 690, + ATOM_WIFI_AWARE_HAL_API_CALLED = 691, + ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED = 692, + ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED = 693, + ATOM_WIFI_THREAD_TASK_EXECUTED = 694, + ATOM_WIFI_STATE_CHANGED = 700, + ATOM_PNO_SCAN_STARTED = 719, + ATOM_PNO_SCAN_STOPPED = 720, + ATOM_WIFI_IS_UNUSABLE_REPORTED = 722, + ATOM_WIFI_AP_CAPABILITIES_REPORTED = 723, + ATOM_SOFT_AP_STATE_CHANGED = 805, + ATOM_SCORER_PREDICTION_RESULT_REPORTED = 884, + ATOM_WIFI_AWARE_CAPABILITIES = 10190, + ATOM_WIFI_MODULE_INFO = 10193, + ATOM_WIFI_SETTING_INFO = 10194, + ATOM_WIFI_COMPLEX_SETTING_INFO = 10195, + ATOM_WIFI_CONFIGURED_NETWORK_INFO = 10198, + ATOM_WEAR_POWER_MENU_OPENED = 731, + ATOM_WEAR_ASSISTANT_OPENED = 755, + ATOM_FIRST_OVERLAY_STATE_CHANGED = 917, + ATOM_WS_WEAR_TIME_SESSION = 610, + ATOM_WS_INCOMING_CALL_ACTION_REPORTED = 626, + ATOM_WS_CALL_DISCONNECTION_REPORTED = 627, + ATOM_WS_CALL_DURATION_REPORTED = 628, + ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED = 629, + ATOM_WS_CALL_INTERACTION_REPORTED = 630, + ATOM_WS_ON_BODY_STATE_CHANGED = 787, + ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED = 802, + ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED = 803, + ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED = 804, + ATOM_WS_REMOTE_EVENT_USAGE_REPORTED = 920, + ATOM_WS_NOTIFICATION_MANAGED_DISMISSAL_SYNC = 941, + ATOM_WS_BUGREPORT_EVENT_REPORTED = 964, + ATOM_WS_STANDALONE_MODE_SNAPSHOT = 10197, + ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT = 10206, + ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT = 10225, + ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT = 10227, + ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED = 619, + ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED = 620, + ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED = 621, + ATOM_WEAR_TIME_SYNC_REQUESTED = 911, + ATOM_WEAR_TIME_UPDATE_STARTED = 912, + ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED = 913, + ATOM_WEAR_TIME_CHANGED = 914, + ATOM_WEAR_SETUP_WIZARD_DEVICE_STATUS_REPORTED = 953, + ATOM_WEAR_SETUP_WIZARD_PAIRING_COMPLETED = 954, + ATOM_WEAR_SETUP_WIZARD_CONNECTION_ESTABLISHED = 955, + ATOM_WEAR_SETUP_WIZARD_CHECKIN_COMPLETED = 956, + ATOM_WEAR_SETUP_WIZARD_COMPANION_TIME_REPORTED = 957, + ATOM_WEAR_SETUP_WIZARD_STATUS_REPORTED = 958, + ATOM_WEAR_SETUP_WIZARD_HEARTBEAT_REPORTED = 959, + ATOM_WEAR_SETUP_WIZARD_FRP_TRIGGERED = 960, + ATOM_WEAR_SETUP_WIZARD_SYSTEM_UPDATE_TRIGGERED = 961, + ATOM_WEAR_SETUP_WIZARD_PHONE_SWITCH_TRIGGERED = 962, + ATOM_RENDERER_INITIALIZED = 736, + ATOM_SCHEMA_VERSION_RECEIVED = 737, + ATOM_LAYOUT_INSPECTED = 741, + ATOM_LAYOUT_EXPRESSION_INSPECTED = 742, + ATOM_LAYOUT_ANIMATIONS_INSPECTED = 743, + ATOM_MATERIAL_COMPONENTS_INSPECTED = 744, + ATOM_TILE_REQUESTED = 745, + ATOM_STATE_RESPONSE_RECEIVED = 746, + ATOM_TILE_RESPONSE_RECEIVED = 747, + ATOM_INFLATION_FINISHED = 748, + ATOM_INFLATION_FAILED = 749, + ATOM_IGNORED_INFLATION_FAILURES_REPORTED = 750, + ATOM_DRAWABLE_RENDERED = 751, + ATOM_WEAR_MODE_STATE_CHANGED = 715, + ATOM_MEDIA_ACTION_REPORTED = 608, + ATOM_MEDIA_CONTROLS_LAUNCHED = 609, + ATOM_MEDIA_SESSION_STATE_CHANGED = 677, + ATOM_MEDIA_CONTROL_API_USAGE_REPORTED = 966, + ATOM_MEDIA_SUBSCRIPTION_CHANGED = 990, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY = 757, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE = 758, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT = 759, + ATOM_MEDIATOR_UPDATED = 721, + ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER = 10196, + ATOM_SYSPROXY_CONNECTION_UPDATED = 786, + ATOM_WEAR_COMPANION_CONNECTION_STATE = 921, + ATOM_SYSPROXY_SERVICE_STATE_UPDATED = 949, + ATOM_UWB_ACTIVITY_INFO = 10188, + ATOM_TEST_UPROBESTATS_ATOM_REPORTED = 915, + ATOM_TV_LOW_POWER_STANDBY_POLICY = 679, + ATOM_EXTERNAL_TV_INPUT_EVENT = 717, + ATOM_BOOT_INTEGRITY_INFO_REPORTED = 775, + ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED = 738, + ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED = 739, + ATOM_THREADNETWORK_DEVICE_INFO_REPORTED = 740, + ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED = 713, + ATOM_EMERGENCY_NUMBERS_INFO = 10180, + ATOM_DATA_NETWORK_VALIDATION = 10207, + ATOM_DATA_RAT_STATE_CHANGED = 854, + ATOM_CONNECTED_CHANNEL_CHANGED = 882, + ATOM_CELLULAR_IDENTIFIER_DISCLOSED = 800, + ATOM_SATELLITE_CONTROLLER = 10182, + ATOM_SATELLITE_SESSION = 10183, + ATOM_SATELLITE_INCOMING_DATAGRAM = 10184, + ATOM_SATELLITE_OUTGOING_DATAGRAM = 10185, + ATOM_SATELLITE_PROVISION = 10186, + ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER = 10187, + ATOM_CARRIER_ROAMING_SATELLITE_SESSION = 10211, + ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS = 10212, + ATOM_CONTROLLER_STATS_PER_PACKAGE = 10213, + ATOM_SATELLITE_ENTITLEMENT = 10214, + ATOM_SATELLITE_CONFIG_UPDATER = 10215, + ATOM_SATELLITE_ACCESS_CONTROLLER = 10219, + ATOM_QUALIFIED_RAT_LIST_CHANGED = 634, + ATOM_QNS_IMS_CALL_DROP_STATS = 635, + ATOM_QNS_FALLBACK_RESTRICTION_CHANGED = 636, + ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO = 10177, + ATOM_QNS_HANDOVER_TIME_MILLIS = 10178, + ATOM_QNS_HANDOVER_PINGPONG = 10179, + ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED = 923, + ATOM_EMERGENCY_NUMBER_DIALED = 637, + ATOM_CALL_STATS = 10221, + ATOM_CALL_AUDIO_ROUTE_STATS = 10222, + ATOM_TELECOM_API_STATS = 10223, + ATOM_TELECOM_ERROR_STATS = 10224, + ATOM_LOCKSCREEN_SHORTCUT_SELECTED = 611, + ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED = 612, + ATOM_LAUNCHER_IMPRESSION_EVENT_V2 = 716, + ATOM_DISPLAY_SWITCH_LATENCY_TRACKED = 753, + ATOM_NOTIFICATION_LISTENER_SERVICE = 829, + ATOM_NAV_HANDLE_TOUCH_POINTS = 869, + ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED = 908, + ATOM_PERIPHERAL_TUTORIAL_LAUNCHED = 942, + ATOM_CONTEXTUAL_EDUCATION_TRIGGERED = 971, + ATOM_COMMUNAL_HUB_SNAPSHOT = 10226, + ATOM_TEST_EXTENSION_ATOM_REPORTED = 660, + ATOM_TEST_RESTRICTED_ATOM_REPORTED = 672, + ATOM_STATS_SOCKET_LOSS_REPORTED = 752, + ATOM_SETTINGS_SPA_REPORTED = 622, + ATOM_SELINUX_AUDIT_LOG = 799, + ATOM_SANDBOX_API_CALLED = 488, + ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED = 735, + ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION = 796, + ATOM_SANDBOX_SDK_STORAGE = 10159, + ATOM_RKPD_POOL_STATS = 664, + ATOM_RKPD_CLIENT_OPERATION = 665, + ATOM_RANGING_SESSION_CONFIGURED = 993, + ATOM_RANGING_SESSION_STARTED = 994, + ATOM_RANGING_SESSION_CLOSED = 995, + ATOM_RANGING_TECHNOLOGY_STARTED = 996, + ATOM_RANGING_TECHNOLOGY_STOPPED = 997, + ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED = 784, + ATOM_BACKUP_SETUP_STATUS_REPORTED = 785, + ATOM_SCREEN_OFF_REPORTED = 776, + ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED = 836, + ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED = 837, + ATOM_SCREEN_DIM_REPORTED = 867, + ATOM_ATOM_9999 = 9999, + ATOM_ATOM_99999 = 99999, + ATOM_PHOTOPICKER_SESSION_INFO_REPORTED = 886, + ATOM_PHOTOPICKER_API_INFO_REPORTED = 887, + ATOM_PHOTOPICKER_UI_EVENT_LOGGED = 888, + ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED = 889, + ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED = 890, + ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED = 891, + ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED = 892, + ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED = 893, + ATOM_PHOTOPICKER_PAGE_INFO_LOGGED = 894, + ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED = 895, + ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED = 896, + ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED = 897, + ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED = 898, + ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED = 899, + ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED = 645, + ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED = 646, + ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION = 647, + ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED = 648, + ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED = 649, + ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED = 827, + ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED = 828, + ATOM_PRESSURE_STALL_INFORMATION = 10229, + ATOM_PDF_LOAD_REPORTED = 859, + ATOM_PDF_API_USAGE_REPORTED = 860, + ATOM_PDF_SEARCH_REPORTED = 861, + ATOM_COMPONENT_STATE_CHANGED_REPORTED = 863, + ATOM_ONDEVICEPERSONALIZATION_API_CALLED = 711, + ATOM_ONDEVICEPERSONALIZATION_TRACE_EVENT = 952, + ATOM_NFC_OBSERVE_MODE_STATE_CHANGED = 855, + ATOM_NFC_FIELD_CHANGED = 856, + ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED = 857, + ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED = 858, + ATOM_NFC_EXIT_FRAME_TABLE_CHANGED = 1036, + ATOM_NFC_AUTO_TRANSACT_REPORTED = 1038, + ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED = 901, + ATOM_MTE_STATE = 10181, + ATOM_ZRAM_MAINTENANCE_EXECUTED = 1015, + ATOM_ZRAM_SETUP_EXECUTED = 1029, + ATOM_ZRAM_MM_STAT_MMD = 10232, + ATOM_ZRAM_BD_STAT_MMD = 10233, + ATOM_MEDIA_EDITING_ENDED_REPORTED = 798, + ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED = 600, + ATOM_MEDIA_CODEC_STARTED = 641, + ATOM_MEDIA_CODEC_STOPPED = 642, + ATOM_MEDIA_CODEC_RENDERED = 684, + ATOM_EMERGENCY_STATE_CHANGED = 633, + ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED = 868, + ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED = 1002, + ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED = 1003, + ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED = 1004, + ATOM_KERNEL_OOM_KILL_OCCURRED = 754, + ATOM_KEYBOARD_CONFIGURED = 682, + ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED = 683, + ATOM_INPUTDEVICE_USAGE_REPORTED = 686, + ATOM_INPUT_EVENT_LATENCY_REPORTED = 932, + ATOM_TOUCHPAD_USAGE = 10191, + ATOM_IKE_SESSION_TERMINATED = 678, + ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED = 760, + ATOM_NEGOTIATED_SECURITY_ASSOCIATION = 821, + ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED = 761, + ATOM_HEALTH_CONNECT_UI_IMPRESSION = 623, + ATOM_HEALTH_CONNECT_UI_INTERACTION = 624, + ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED = 625, + ATOM_HEALTH_CONNECT_API_CALLED = 616, + ATOM_HEALTH_CONNECT_USAGE_STATS = 617, + ATOM_HEALTH_CONNECT_STORAGE_STATS = 618, + ATOM_HEALTH_CONNECT_API_INVOKED = 643, + ATOM_EXERCISE_ROUTE_API_CALLED = 654, + ATOM_HEALTH_CONNECT_EXPORT_INVOKED = 907, + ATOM_HEALTH_CONNECT_IMPORT_INVOKED = 918, + ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED = 919, + ATOM_HEALTH_CONNECT_PERMISSION_STATS = 963, + ATOM_HEALTH_CONNECT_PHR_API_INVOKED = 980, + ATOM_HEALTH_CONNECT_PHR_USAGE_STATS = 981, + ATOM_HEALTH_CONNECT_PHR_STORAGE_STATS = 984, + ATOM_HEALTH_CONNECT_RESTRICTED_ECOSYSTEM_STATS = 985, + ATOM_HEALTH_CONNECT_ECOSYSTEM_STATS = 986, + ATOM_HDMI_EARC_STATUS_REPORTED = 701, + ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED = 724, + ATOM_HDMI_POWER_STATE_CHANGE_ON_ACTIVE_SOURCE_LOST_TOGGLED = 991, + ATOM_BATTERY_HEALTH = 10220, + ATOM_BIOMETRIC_UNENROLLED = 944, + ATOM_BIOMETRIC_ENUMERATED = 945, + ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED = 584, + ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED = 816, + ATOM_FULL_SCREEN_INTENT_LAUNCHED = 631, + ATOM_BAL_ALLOWED = 632, + ATOM_IN_TASK_ACTIVITY_STARTED = 685, + ATOM_DEVICE_ORIENTATION_CHANGED = 906, + ATOM_CACHED_APPS_HIGH_WATERMARK = 10189, + ATOM_STYLUS_PREDICTION_METRICS_REPORTED = 718, + ATOM_USER_RISK_EVENT_REPORTED = 725, + ATOM_MEDIA_PROJECTION_STATE_CHANGED = 729, + ATOM_MEDIA_PROJECTION_TARGET_CHANGED = 730, + ATOM_EXCESSIVE_BINDER_PROXY_COUNT_REPORTED = 853, + ATOM_PROXY_BYTES_TRANSFER_BY_FG_BG = 10200, + ATOM_MOBILE_BYTES_TRANSFER_BY_PROC_STATE = 10204, + ATOM_BIOMETRIC_FRR_NOTIFICATION = 817, + ATOM_SENSITIVE_CONTENT_MEDIA_PROJECTION_SESSION = 830, + ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_SESSION = 831, + ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_APPLIED = 832, + ATOM_SENSITIVE_NOTIFICATION_REDACTION = 833, + ATOM_SENSITIVE_CONTENT_APP_PROTECTION = 835, + ATOM_APP_RESTRICTION_STATE_CHANGED = 866, + ATOM_BATTERY_USAGE_STATS_PER_UID = 10209, + ATOM_POSTGC_MEMORY_SNAPSHOT = 924, + ATOM_POWER_SAVE_TEMP_ALLOWLIST_CHANGED = 926, + ATOM_APP_OP_ACCESS_TRACKED = 931, + ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED = 933, + ATOM_DEVICE_IDLE_TEMP_ALLOWLIST_UPDATED = 940, + ATOM_APP_OP_NOTE_OP_OR_CHECK_OP_BINDER_API_CALLED = 943, + ATOM_FRAMEWORK_WAKELOCK_INFO = 10230, + ATOM_JANK_FRAME_COUNT_BY_WIDGET_REPORTED = 950, + ATOM_INTENT_CREATOR_TOKEN_ADDED = 978, + ATOM_NOTIFICATION_CHANNEL_CLASSIFICATION = 983, + ATOM_CAMERA_STATUS_FOR_COMPATIBILITY_CHANGED = 999, + ATOM_FEDERATED_COMPUTE_API_CALLED = 712, + ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED = 771, + ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED = 838, + ATOM_FEDERATED_COMPUTE_TRACE_EVENT_REPORTED = 992, + ATOM_EXPRESS_EVENT_REPORTED = 528, + ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED = 593, + ATOM_EXPRESS_UID_EVENT_REPORTED = 644, + ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED = 658, + ATOM_DREAM_SETTING_CHANGED = 705, + ATOM_DREAM_SETTING_SNAPSHOT = 10192, + ATOM_DND_STATE_CHANGED = 657, + ATOM_EXTERNAL_DISPLAY_STATE_CHANGED = 806, + ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED = 792, + ATOM_DEVICE_POLICY_MANAGEMENT_MODE = 10216, + ATOM_DEVICE_POLICY_STATE = 10217, + ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED = 726, + ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED = 727, + ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED = 728, + ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED = 789, + ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED = 790, + ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED = 791, + ATOM_DESKTOP_MODE_UI_CHANGED = 818, + ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE = 819, + ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED = 935, + ATOM_CRONET_ENGINE_CREATED = 703, + ATOM_CRONET_TRAFFIC_REPORTED = 704, + ATOM_CRONET_ENGINE_BUILDER_INITIALIZED = 762, + ATOM_CRONET_HTTP_FLAGS_INITIALIZED = 763, + ATOM_CRONET_INITIALIZED = 764, + ATOM_CREDENTIAL_MANAGER_API_CALLED = 585, + ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED = 651, + ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED = 652, + ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED = 653, + ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED = 667, + ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED = 668, + ATOM_CREDENTIAL_MANAGER_GET_REPORTED = 669, + ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED = 670, + ATOM_CREDENTIAL_MANAGER_APIV2_CALLED = 671, + ATOM_CPU_POLICY = 10199, + ATOM_VPN_CONNECTION_STATE_CHANGED = 850, + ATOM_VPN_CONNECTION_REPORTED = 851, + ATOM_IP_CLIENT_RA_INFO_REPORTED = 778, + ATOM_APF_SESSION_INFO_REPORTED = 777, + ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED = 979, + ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED = 783, + ATOM_DAILY_KEEPALIVE_INFO_REPORTED = 650, + ATOM_NETWORK_REQUEST_STATE_CHANGED = 779, + ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED = 925, + ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_STATE_CHANGED = 972, + ATOM_HARDWARE_RENDERER_EVENT = 946, + ATOM_TEXTURE_VIEW_EVENT = 947, + ATOM_SURFACE_CONTROL_EVENT = 948, + ATOM_IMAGE_DECODED = 977, + ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED = 934, + ATOM_CONSCRYPT_SERVICE_USED = 965, + ATOM_CERTIFICATE_TRANSPARENCY_VERIFICATION_REPORTED = 989, + ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT = 900, + ATOM_BROADCAST_SENT = 922, + ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED = 613, + ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION = 614, + ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION = 615, + ATOM_BLUETOOTH_LE_SESSION_CONNECTED = 656, + ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED = 666, + ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED = 696, + ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED = 781, + ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED = 782, + ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID = 862, + ATOM_LE_APP_SCAN_STATE_CHANGED = 870, + ATOM_LE_RADIO_SCAN_STOPPED = 871, + ATOM_LE_SCAN_RESULT_RECEIVED = 872, + ATOM_LE_SCAN_ABUSED = 873, + ATOM_LE_ADV_STATE_CHANGED = 874, + ATOM_LE_ADV_ERROR_REPORTED = 875, + ATOM_A2DP_SESSION_REPORTED = 904, + ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED = 916, + ATOM_BROADCAST_AUDIO_SESSION_REPORTED = 927, + ATOM_BROADCAST_AUDIO_SYNC_REPORTED = 928, + ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE = 982, + ATOM_BLUETOOTH_LE_CONNECTION = 988, + ATOM_HEARING_DEVICE_ACTIVE_EVENT_REPORTED = 1021, + ATOM_BACKPORTED_FIX_STATUS_REPORTED = 987, + ATOM_PLUGIN_INITIALIZED = 655, + ATOM_CAR_SYSTEM_UI_DATA_SUBSCRIPTION_EVENT_REPORTED = 974, + ATOM_CAR_SETTINGS_DATA_SUBSCRIPTION_EVENT_REPORTED = 975, + ATOM_CAR_QC_LIB_EVENT_REPORTED = 976, + ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED = 852, + ATOM_CAR_RECENTS_EVENT_REPORTED = 770, + ATOM_CAR_CALM_MODE_EVENT_REPORTED = 797, + ATOM_AUTOFILL_UI_EVENT_REPORTED = 603, + ATOM_AUTOFILL_FILL_REQUEST_REPORTED = 604, + ATOM_AUTOFILL_FILL_RESPONSE_REPORTED = 605, + ATOM_AUTOFILL_SAVE_EVENT_REPORTED = 606, + ATOM_AUTOFILL_SESSION_COMMITTED = 607, + ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED = 659, + ATOM_ODREFRESH_REPORTED = 366, + ATOM_ODSIGN_REPORTED = 548, + ATOM_BACKGROUND_DEXOPT_JOB_ENDED = 467, + ATOM_PREREBOOT_DEXOPT_JOB_ENDED = 883, + ATOM_ART_DATUM_REPORTED = 332, + ATOM_ART_DEVICE_DATUM_REPORTED = 550, + ATOM_ART_DATUM_DELTA_REPORTED = 565, + ATOM_ART_DEX2OAT_REPORTED = 929, + ATOM_ART_DEVICE_STATUS = 10205, + ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED = 385, + ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED = 579, + ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED = 825, + ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED = 826, + ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED = 909, + ATOM_APP_FUNCTIONS_REQUEST_REPORTED = 998, + ATOM_APEX_INSTALLATION_REQUESTED = 732, + ATOM_APEX_INSTALLATION_STAGED = 733, + ATOM_APEX_INSTALLATION_ENDED = 734, + ATOM_AI_WALLPAPERS_BUTTON_PRESSED = 706, + ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED = 707, + ATOM_AI_WALLPAPERS_TERM_SELECTED = 708, + ATOM_AI_WALLPAPERS_WALLPAPER_SET = 709, + ATOM_AI_WALLPAPERS_SESSION_SUMMARY = 710, ATOM_JSSCRIPTENGINE_LATENCY_REPORTED = 483, ATOM_AD_SERVICES_API_CALLED = 435, ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED = 436, @@ -56929,351 +57253,19 @@ enum AtomId : int32_t { ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED = 903, ATOM_UPDATE_SIGNALS_PROCESS_REPORTED = 905, ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED = 930, - ATOM_AI_WALLPAPERS_BUTTON_PRESSED = 706, - ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED = 707, - ATOM_AI_WALLPAPERS_TERM_SELECTED = 708, - ATOM_AI_WALLPAPERS_WALLPAPER_SET = 709, - ATOM_AI_WALLPAPERS_SESSION_SUMMARY = 710, - ATOM_APEX_INSTALLATION_REQUESTED = 732, - ATOM_APEX_INSTALLATION_STAGED = 733, - ATOM_APEX_INSTALLATION_ENDED = 734, - ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED = 385, - ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED = 579, - ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED = 825, - ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED = 826, - ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED = 909, - ATOM_ART_DATUM_REPORTED = 332, - ATOM_ART_DEVICE_DATUM_REPORTED = 550, - ATOM_ART_DATUM_DELTA_REPORTED = 565, - ATOM_ART_DEX2OAT_REPORTED = 929, - ATOM_ART_DEVICE_STATUS = 10205, - ATOM_BACKGROUND_DEXOPT_JOB_ENDED = 467, - ATOM_PREREBOOT_DEXOPT_JOB_ENDED = 883, - ATOM_ODREFRESH_REPORTED = 366, - ATOM_ODSIGN_REPORTED = 548, - ATOM_AUTOFILL_UI_EVENT_REPORTED = 603, - ATOM_AUTOFILL_FILL_REQUEST_REPORTED = 604, - ATOM_AUTOFILL_FILL_RESPONSE_REPORTED = 605, - ATOM_AUTOFILL_SAVE_EVENT_REPORTED = 606, - ATOM_AUTOFILL_SESSION_COMMITTED = 607, - ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED = 659, - ATOM_CAR_RECENTS_EVENT_REPORTED = 770, - ATOM_CAR_CALM_MODE_EVENT_REPORTED = 797, - ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED = 852, - ATOM_PLUGIN_INITIALIZED = 655, - ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED = 613, - ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION = 614, - ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION = 615, - ATOM_BLUETOOTH_LE_SESSION_CONNECTED = 656, - ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED = 666, - ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED = 696, - ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED = 781, - ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED = 782, - ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID = 862, - ATOM_LE_APP_SCAN_STATE_CHANGED = 870, - ATOM_LE_RADIO_SCAN_STOPPED = 871, - ATOM_LE_SCAN_RESULT_RECEIVED = 872, - ATOM_LE_SCAN_ABUSED = 873, - ATOM_LE_ADV_STATE_CHANGED = 874, - ATOM_LE_ADV_ERROR_REPORTED = 875, - ATOM_A2DP_SESSION_REPORTED = 904, - ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED = 916, - ATOM_BROADCAST_AUDIO_SESSION_REPORTED = 927, - ATOM_BROADCAST_AUDIO_SYNC_REPORTED = 928, - ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE = 982, - ATOM_BLUETOOTH_LE_CONNECTION = 988, - ATOM_BROADCAST_SENT = 922, - ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT = 900, - ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED = 934, - ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_FAILED = 972, - ATOM_DAILY_KEEPALIVE_INFO_REPORTED = 650, - ATOM_NETWORK_REQUEST_STATE_CHANGED = 779, - ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED = 925, - ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED = 783, - ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED = 979, - ATOM_APF_SESSION_INFO_REPORTED = 777, - ATOM_IP_CLIENT_RA_INFO_REPORTED = 778, - ATOM_VPN_CONNECTION_STATE_CHANGED = 850, - ATOM_VPN_CONNECTION_REPORTED = 851, - ATOM_CPU_POLICY = 10199, - ATOM_CREDENTIAL_MANAGER_API_CALLED = 585, - ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED = 651, - ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED = 652, - ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED = 653, - ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED = 667, - ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED = 668, - ATOM_CREDENTIAL_MANAGER_GET_REPORTED = 669, - ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED = 670, - ATOM_CREDENTIAL_MANAGER_APIV2_CALLED = 671, - ATOM_CRONET_ENGINE_CREATED = 703, - ATOM_CRONET_TRAFFIC_REPORTED = 704, - ATOM_CRONET_ENGINE_BUILDER_INITIALIZED = 762, - ATOM_CRONET_HTTP_FLAGS_INITIALIZED = 763, - ATOM_CRONET_INITIALIZED = 764, - ATOM_DESKTOP_MODE_UI_CHANGED = 818, - ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE = 819, - ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED = 935, - ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED = 726, - ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED = 727, - ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED = 728, - ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED = 789, - ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED = 790, - ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED = 791, - ATOM_DEVICE_POLICY_MANAGEMENT_MODE = 10216, - ATOM_DEVICE_POLICY_STATE = 10217, - ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED = 792, - ATOM_EXTERNAL_DISPLAY_STATE_CHANGED = 806, - ATOM_DND_STATE_CHANGED = 657, - ATOM_DREAM_SETTING_CHANGED = 705, - ATOM_DREAM_SETTING_SNAPSHOT = 10192, - ATOM_EXPRESS_EVENT_REPORTED = 528, - ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED = 593, - ATOM_EXPRESS_UID_EVENT_REPORTED = 644, - ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED = 658, - ATOM_FEDERATED_COMPUTE_API_CALLED = 712, - ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED = 771, - ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED = 838, - ATOM_FULL_SCREEN_INTENT_LAUNCHED = 631, - ATOM_BAL_ALLOWED = 632, - ATOM_IN_TASK_ACTIVITY_STARTED = 685, - ATOM_DEVICE_ORIENTATION_CHANGED = 906, - ATOM_CACHED_APPS_HIGH_WATERMARK = 10189, - ATOM_STYLUS_PREDICTION_METRICS_REPORTED = 718, - ATOM_USER_RISK_EVENT_REPORTED = 725, - ATOM_MEDIA_PROJECTION_STATE_CHANGED = 729, - ATOM_MEDIA_PROJECTION_TARGET_CHANGED = 730, - ATOM_EXCESSIVE_BINDER_PROXY_COUNT_REPORTED = 853, - ATOM_PROXY_BYTES_TRANSFER_BY_FG_BG = 10200, - ATOM_MOBILE_BYTES_TRANSFER_BY_PROC_STATE = 10204, - ATOM_BIOMETRIC_FRR_NOTIFICATION = 817, - ATOM_SENSITIVE_CONTENT_MEDIA_PROJECTION_SESSION = 830, - ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_SESSION = 831, - ATOM_SENSITIVE_NOTIFICATION_APP_PROTECTION_APPLIED = 832, - ATOM_SENSITIVE_NOTIFICATION_REDACTION = 833, - ATOM_SENSITIVE_CONTENT_APP_PROTECTION = 835, - ATOM_APP_RESTRICTION_STATE_CHANGED = 866, - ATOM_BATTERY_USAGE_STATS_PER_UID = 10209, - ATOM_POSTGC_MEMORY_SNAPSHOT = 924, - ATOM_POWER_SAVE_TEMP_ALLOWLIST_CHANGED = 926, - ATOM_APP_OP_ACCESS_TRACKED = 931, - ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED = 933, - ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED = 584, - ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED = 816, - ATOM_BATTERY_HEALTH = 10220, - ATOM_HDMI_EARC_STATUS_REPORTED = 701, - ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED = 724, - ATOM_HEALTH_CONNECT_API_CALLED = 616, - ATOM_HEALTH_CONNECT_USAGE_STATS = 617, - ATOM_HEALTH_CONNECT_STORAGE_STATS = 618, - ATOM_HEALTH_CONNECT_API_INVOKED = 643, - ATOM_EXERCISE_ROUTE_API_CALLED = 654, - ATOM_HEALTH_CONNECT_EXPORT_INVOKED = 907, - ATOM_HEALTH_CONNECT_IMPORT_INVOKED = 918, - ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED = 919, - ATOM_HEALTH_CONNECT_UI_IMPRESSION = 623, - ATOM_HEALTH_CONNECT_UI_INTERACTION = 624, - ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED = 625, - ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED = 761, - ATOM_IKE_SESSION_TERMINATED = 678, - ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED = 760, - ATOM_NEGOTIATED_SECURITY_ASSOCIATION = 821, - ATOM_KEYBOARD_CONFIGURED = 682, - ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED = 683, - ATOM_INPUTDEVICE_USAGE_REPORTED = 686, - ATOM_INPUT_EVENT_LATENCY_REPORTED = 932, - ATOM_TOUCHPAD_USAGE = 10191, - ATOM_KERNEL_OOM_KILL_OCCURRED = 754, - ATOM_EMERGENCY_STATE_CHANGED = 633, - ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED = 868, - ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED = 1002, - ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED = 1003, - ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED = 1004, - ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED = 600, - ATOM_MEDIA_CODEC_STARTED = 641, - ATOM_MEDIA_CODEC_STOPPED = 642, - ATOM_MEDIA_CODEC_RENDERED = 684, - ATOM_MEDIA_EDITING_ENDED_REPORTED = 798, - ATOM_MTE_STATE = 10181, - ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED = 901, - ATOM_NFC_OBSERVE_MODE_STATE_CHANGED = 855, - ATOM_NFC_FIELD_CHANGED = 856, - ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED = 857, - ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED = 858, - ATOM_ONDEVICEPERSONALIZATION_API_CALLED = 711, - ATOM_COMPONENT_STATE_CHANGED_REPORTED = 863, - ATOM_PDF_LOAD_REPORTED = 859, - ATOM_PDF_API_USAGE_REPORTED = 860, - ATOM_PDF_SEARCH_REPORTED = 861, - ATOM_PRESSURE_STALL_INFORMATION = 10229, - ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED = 645, - ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED = 646, - ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION = 647, - ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED = 648, - ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED = 649, - ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED = 827, - ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED = 828, - ATOM_PHOTOPICKER_SESSION_INFO_REPORTED = 886, - ATOM_PHOTOPICKER_API_INFO_REPORTED = 887, - ATOM_PHOTOPICKER_UI_EVENT_LOGGED = 888, - ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED = 889, - ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED = 890, - ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED = 891, - ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED = 892, - ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED = 893, - ATOM_PHOTOPICKER_PAGE_INFO_LOGGED = 894, - ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED = 895, - ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED = 896, - ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED = 897, - ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED = 898, - ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED = 899, - ATOM_ATOM_9999 = 9999, - ATOM_ATOM_99999 = 99999, - ATOM_SCREEN_OFF_REPORTED = 776, - ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED = 836, - ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED = 837, - ATOM_SCREEN_DIM_REPORTED = 867, - ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED = 784, - ATOM_BACKUP_SETUP_STATUS_REPORTED = 785, - ATOM_RANGING_SESSION_CONFIGURED = 993, - ATOM_RANGING_SESSION_STARTED = 994, - ATOM_RANGING_SESSION_CLOSED = 995, - ATOM_RANGING_TECHNOLOGY_STARTED = 996, - ATOM_RANGING_TECHNOLOGY_STOPPED = 997, - ATOM_RKPD_POOL_STATS = 664, - ATOM_RKPD_CLIENT_OPERATION = 665, - ATOM_SANDBOX_API_CALLED = 488, - ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED = 735, - ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION = 796, - ATOM_SANDBOX_SDK_STORAGE = 10159, - ATOM_SELINUX_AUDIT_LOG = 799, - ATOM_SETTINGS_SPA_REPORTED = 622, - ATOM_TEST_EXTENSION_ATOM_REPORTED = 660, - ATOM_TEST_RESTRICTED_ATOM_REPORTED = 672, - ATOM_STATS_SOCKET_LOSS_REPORTED = 752, - ATOM_LOCKSCREEN_SHORTCUT_SELECTED = 611, - ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED = 612, - ATOM_LAUNCHER_IMPRESSION_EVENT_V2 = 716, - ATOM_DISPLAY_SWITCH_LATENCY_TRACKED = 753, - ATOM_NOTIFICATION_LISTENER_SERVICE = 829, - ATOM_NAV_HANDLE_TOUCH_POINTS = 869, - ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED = 908, - ATOM_COMMUNAL_HUB_SNAPSHOT = 10226, - ATOM_EMERGENCY_NUMBER_DIALED = 637, - ATOM_CALL_STATS = 10221, - ATOM_CALL_AUDIO_ROUTE_STATS = 10222, - ATOM_TELECOM_API_STATS = 10223, - ATOM_TELECOM_ERROR_STATS = 10224, - ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED = 713, - ATOM_EMERGENCY_NUMBERS_INFO = 10180, - ATOM_DATA_NETWORK_VALIDATION = 10207, - ATOM_DATA_RAT_STATE_CHANGED = 854, - ATOM_CONNECTED_CHANNEL_CHANGED = 882, - ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED = 923, - ATOM_QUALIFIED_RAT_LIST_CHANGED = 634, - ATOM_QNS_IMS_CALL_DROP_STATS = 635, - ATOM_QNS_FALLBACK_RESTRICTION_CHANGED = 636, - ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO = 10177, - ATOM_QNS_HANDOVER_TIME_MILLIS = 10178, - ATOM_QNS_HANDOVER_PINGPONG = 10179, - ATOM_SATELLITE_CONTROLLER = 10182, - ATOM_SATELLITE_SESSION = 10183, - ATOM_SATELLITE_INCOMING_DATAGRAM = 10184, - ATOM_SATELLITE_OUTGOING_DATAGRAM = 10185, - ATOM_SATELLITE_PROVISION = 10186, - ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER = 10187, - ATOM_CARRIER_ROAMING_SATELLITE_SESSION = 10211, - ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS = 10212, - ATOM_CONTROLLER_STATS_PER_PACKAGE = 10213, - ATOM_SATELLITE_ENTITLEMENT = 10214, - ATOM_SATELLITE_CONFIG_UPDATER = 10215, - ATOM_SATELLITE_ACCESS_CONTROLLER = 10219, - ATOM_CELLULAR_IDENTIFIER_DISCLOSED = 800, - ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED = 738, - ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED = 739, - ATOM_THREADNETWORK_DEVICE_INFO_REPORTED = 740, - ATOM_BOOT_INTEGRITY_INFO_REPORTED = 775, - ATOM_TV_LOW_POWER_STANDBY_POLICY = 679, - ATOM_EXTERNAL_TV_INPUT_EVENT = 717, - ATOM_TEST_UPROBESTATS_ATOM_REPORTED = 915, - ATOM_UWB_ACTIVITY_INFO = 10188, - ATOM_MEDIATOR_UPDATED = 721, - ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER = 10196, - ATOM_SYSPROXY_CONNECTION_UPDATED = 786, - ATOM_WEAR_COMPANION_CONNECTION_STATE = 921, - ATOM_MEDIA_ACTION_REPORTED = 608, - ATOM_MEDIA_CONTROLS_LAUNCHED = 609, - ATOM_MEDIA_SESSION_STATE_CHANGED = 677, - ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY = 757, - ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE = 758, - ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT = 759, - ATOM_WEAR_MODE_STATE_CHANGED = 715, - ATOM_RENDERER_INITIALIZED = 736, - ATOM_SCHEMA_VERSION_RECEIVED = 737, - ATOM_LAYOUT_INSPECTED = 741, - ATOM_LAYOUT_EXPRESSION_INSPECTED = 742, - ATOM_LAYOUT_ANIMATIONS_INSPECTED = 743, - ATOM_MATERIAL_COMPONENTS_INSPECTED = 744, - ATOM_TILE_REQUESTED = 745, - ATOM_STATE_RESPONSE_RECEIVED = 746, - ATOM_TILE_RESPONSE_RECEIVED = 747, - ATOM_INFLATION_FINISHED = 748, - ATOM_INFLATION_FAILED = 749, - ATOM_IGNORED_INFLATION_FAILURES_REPORTED = 750, - ATOM_DRAWABLE_RENDERED = 751, - ATOM_WEAR_TIME_SYNC_REQUESTED = 911, - ATOM_WEAR_TIME_UPDATE_STARTED = 912, - ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED = 913, - ATOM_WEAR_TIME_CHANGED = 914, - ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED = 619, - ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED = 620, - ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED = 621, - ATOM_WS_WEAR_TIME_SESSION = 610, - ATOM_WS_INCOMING_CALL_ACTION_REPORTED = 626, - ATOM_WS_CALL_DISCONNECTION_REPORTED = 627, - ATOM_WS_CALL_DURATION_REPORTED = 628, - ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED = 629, - ATOM_WS_CALL_INTERACTION_REPORTED = 630, - ATOM_WS_ON_BODY_STATE_CHANGED = 787, - ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED = 802, - ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED = 803, - ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED = 804, - ATOM_WS_REMOTE_EVENT_USAGE_REPORTED = 920, - ATOM_WS_BUGREPORT_REQUESTED = 936, - ATOM_WS_BUGREPORT_TRIGGERED = 937, - ATOM_WS_BUGREPORT_FINISHED = 938, - ATOM_WS_BUGREPORT_RESULT_RECEIVED = 939, - ATOM_WS_STANDALONE_MODE_SNAPSHOT = 10197, - ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT = 10206, - ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT = 10225, - ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT = 10227, - ATOM_WEAR_POWER_MENU_OPENED = 731, - ATOM_WEAR_ASSISTANT_OPENED = 755, - ATOM_FIRST_OVERLAY_STATE_CHANGED = 917, - ATOM_WIFI_AWARE_NDP_REPORTED = 638, - ATOM_WIFI_AWARE_ATTACH_REPORTED = 639, - ATOM_WIFI_SELF_RECOVERY_TRIGGERED = 661, - ATOM_SOFT_AP_STARTED = 680, - ATOM_SOFT_AP_STOPPED = 681, - ATOM_WIFI_LOCK_RELEASED = 687, - ATOM_WIFI_LOCK_DEACTIVATED = 688, - ATOM_WIFI_CONFIG_SAVED = 689, - ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED = 690, - ATOM_WIFI_AWARE_HAL_API_CALLED = 691, - ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED = 692, - ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED = 693, - ATOM_WIFI_THREAD_TASK_EXECUTED = 694, - ATOM_WIFI_STATE_CHANGED = 700, - ATOM_PNO_SCAN_STARTED = 719, - ATOM_PNO_SCAN_STOPPED = 720, - ATOM_WIFI_IS_UNUSABLE_REPORTED = 722, - ATOM_WIFI_AP_CAPABILITIES_REPORTED = 723, - ATOM_SOFT_AP_STATE_CHANGED = 805, - ATOM_SCORER_PREDICTION_RESULT_REPORTED = 884, - ATOM_WIFI_AWARE_CAPABILITIES = 10190, - ATOM_WIFI_MODULE_INFO = 10193, - ATOM_WIFI_SETTING_INFO = 10194, - ATOM_WIFI_COMPLEX_SETTING_INFO = 10195, - ATOM_WIFI_CONFIGURED_NETWORK_INFO = 10198, + ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_SCHEDULE_ATTEMPTED = 967, + ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_PERFORMED = 968, + ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_PERFORMED_ATTEMPTED_FAILURE_REPORTED = 969, + ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_BACKGROUND_JOB_RAN = 970, + ATOM_THERMAL_STATUS_CALLED = 772, + ATOM_THERMAL_HEADROOM_CALLED = 773, + ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED = 774, + ATOM_ADPF_HINT_SESSION_TID_CLEANUP = 839, + ATOM_THERMAL_HEADROOM_THRESHOLDS = 10201, + ATOM_ADPF_SESSION_SNAPSHOT = 10218, + ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED = 820, + ATOM_ACCOUNT_MANAGER_EVENT = 951, + ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED = 910, }; constexpr AtomId AtomId_MIN = AtomId::ATOM_UNSPECIFIED; @@ -59470,554 +59462,743 @@ const char* AtomId_Name(::perfetto::protos::pbzero::AtomId value) { case ::perfetto::protos::pbzero::AtomId::ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT: return "ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED: - return "ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_NDP_REPORTED: + return "ATOM_WIFI_AWARE_NDP_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED: - return "ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_ATTACH_REPORTED: + return "ATOM_WIFI_AWARE_ATTACH_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_STATUS_CALLED: - return "ATOM_THERMAL_STATUS_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SELF_RECOVERY_TRIGGERED: + return "ATOM_WIFI_SELF_RECOVERY_TRIGGERED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_CALLED: - return "ATOM_THERMAL_HEADROOM_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STARTED: + return "ATOM_SOFT_AP_STARTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED: - return "ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STOPPED: + return "ATOM_SOFT_AP_STOPPED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ADPF_HINT_SESSION_TID_CLEANUP: - return "ATOM_ADPF_HINT_SESSION_TID_CLEANUP"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_RELEASED: + return "ATOM_WIFI_LOCK_RELEASED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_THRESHOLDS: - return "ATOM_THERMAL_HEADROOM_THRESHOLDS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_DEACTIVATED: + return "ATOM_WIFI_LOCK_DEACTIVATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ADPF_SESSION_SNAPSHOT: - return "ATOM_ADPF_SESSION_SNAPSHOT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONFIG_SAVED: + return "ATOM_WIFI_CONFIG_SAVED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_JSSCRIPTENGINE_LATENCY_REPORTED: - return "ATOM_JSSCRIPTENGINE_LATENCY_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED: + return "ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_API_CALLED: - return "ATOM_AD_SERVICES_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_HAL_API_CALLED: + return "ATOM_WIFI_AWARE_HAL_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED: - return "ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED: + return "ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED: - return "ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED: + return "ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED: - return "ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_THREAD_TASK_EXECUTED: + return "ATOM_WIFI_THREAD_TASK_EXECUTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED: - return "ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_STATE_CHANGED: + return "ATOM_WIFI_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_FETCH_PROCESS_REPORTED: - return "ATOM_BACKGROUND_FETCH_PROCESS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PNO_SCAN_STARTED: + return "ATOM_PNO_SCAN_STARTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED: - return "ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PNO_SCAN_STOPPED: + return "ATOM_PNO_SCAN_STOPPED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_BIDDING_PROCESS_REPORTED: - return "ATOM_RUN_AD_BIDDING_PROCESS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_IS_UNUSABLE_REPORTED: + return "ATOM_WIFI_IS_UNUSABLE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_SCORING_PROCESS_REPORTED: - return "ATOM_RUN_AD_SCORING_PROCESS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AP_CAPABILITIES_REPORTED: + return "ATOM_WIFI_AP_CAPABILITIES_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_SELECTION_PROCESS_REPORTED: - return "ATOM_RUN_AD_SELECTION_PROCESS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STATE_CHANGED: + return "ATOM_SOFT_AP_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED: - return "ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCORER_PREDICTION_RESULT_REPORTED: + return "ATOM_SCORER_PREDICTION_RESULT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED: - return "ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_CAPABILITIES: + return "ATOM_WIFI_AWARE_CAPABILITIES"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS: - return "ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_MODULE_INFO: + return "ATOM_WIFI_MODULE_INFO"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_GET_TOPICS_REPORTED: - return "ATOM_AD_SERVICES_GET_TOPICS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SETTING_INFO: + return "ATOM_WIFI_SETTING_INFO"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED: - return "ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_COMPLEX_SETTING_INFO: + return "ATOM_WIFI_COMPLEX_SETTING_INFO"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED: - return "ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONFIGURED_NETWORK_INFO: + return "ATOM_WIFI_CONFIGURED_NETWORK_INFO"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED: - return "ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_MENU_OPENED: + return "ATOM_WEAR_POWER_MENU_OPENED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED: - return "ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_ASSISTANT_OPENED: + return "ATOM_WEAR_ASSISTANT_OPENED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS: - return "ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_FIRST_OVERLAY_STATE_CHANGED: + return "ATOM_FIRST_OVERLAY_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ERROR_REPORTED: - return "ATOM_AD_SERVICES_ERROR_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WEAR_TIME_SESSION: + return "ATOM_WS_WEAR_TIME_SESSION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED: - return "ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_INCOMING_CALL_ACTION_REPORTED: + return "ATOM_WS_INCOMING_CALL_ACTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION: - return "ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_DISCONNECTION_REPORTED: + return "ATOM_WS_CALL_DISCONNECTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION: - return "ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_DURATION_REPORTED: + return "ATOM_WS_CALL_DURATION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_JOBS: - return "ATOM_AD_SERVICES_MEASUREMENT_JOBS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED: + return "ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT: - return "ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_INTERACTION_REPORTED: + return "ATOM_WS_CALL_INTERACTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_AD_ID_MATCH_FOR_DEBUG_KEYS: - return "ATOM_AD_SERVICES_MEASUREMENT_AD_ID_MATCH_FOR_DEBUG_KEYS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_ON_BODY_STATE_CHANGED: + return "ATOM_WS_ON_BODY_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_DATA_STORED: - return "ATOM_AD_SERVICES_ENROLLMENT_DATA_STORED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED: + return "ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_FILE_DOWNLOADED: - return "ATOM_AD_SERVICES_ENROLLMENT_FILE_DOWNLOADED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED: + return "ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_MATCHED: - return "ATOM_AD_SERVICES_ENROLLMENT_MATCHED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED: + return "ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_CONSENT_MIGRATED: - return "ATOM_AD_SERVICES_CONSENT_MIGRATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_REMOTE_EVENT_USAGE_REPORTED: + return "ATOM_WS_REMOTE_EVENT_USAGE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_FAILED: - return "ATOM_AD_SERVICES_ENROLLMENT_FAILED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_NOTIFICATION_MANAGED_DISMISSAL_SYNC: + return "ATOM_WS_NOTIFICATION_MANAGED_DISMISSAL_SYNC"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_CLICK_VERIFICATION: - return "ATOM_AD_SERVICES_MEASUREMENT_CLICK_VERIFICATION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_EVENT_REPORTED: + return "ATOM_WS_BUGREPORT_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENCRYPTION_KEY_FETCHED: - return "ATOM_AD_SERVICES_ENCRYPTION_KEY_FETCHED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_STANDALONE_MODE_SNAPSHOT: + return "ATOM_WS_STANDALONE_MODE_SNAPSHOT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENCRYPTION_KEY_DB_TRANSACTION_ENDED: - return "ATOM_AD_SERVICES_ENCRYPTION_KEY_DB_TRANSACTION_ENDED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT: + return "ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DESTINATION_REGISTERED_BEACONS: - return "ATOM_DESTINATION_REGISTERED_BEACONS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT: + return "ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_REPORT_INTERACTION_API_CALLED: - return "ATOM_REPORT_INTERACTION_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT: + return "ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_INTERACTION_REPORTING_TABLE_CLEARED: - return "ATOM_INTERACTION_REPORTING_TABLE_CLEARED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED: + return "ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_MANIFEST_CONFIG_HELPER_CALLED: - return "ATOM_APP_MANIFEST_CONFIG_HELPER_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED: + return "ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_FILTERING_PROCESS_JOIN_CA_REPORTED: - return "ATOM_AD_FILTERING_PROCESS_JOIN_CA_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED: + return "ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_FILTERING_PROCESS_AD_SELECTION_REPORTED: - return "ATOM_AD_FILTERING_PROCESS_AD_SELECTION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_SYNC_REQUESTED: + return "ATOM_WEAR_TIME_SYNC_REQUESTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_COUNTER_HISTOGRAM_UPDATER_REPORTED: - return "ATOM_AD_COUNTER_HISTOGRAM_UPDATER_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_UPDATE_STARTED: + return "ATOM_WEAR_TIME_UPDATE_STARTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SIGNATURE_VERIFICATION: - return "ATOM_SIGNATURE_VERIFICATION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED: + return "ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_IMMEDIATE_SIGN_JOIN_STATUS_REPORTED: - return "ATOM_K_ANON_IMMEDIATE_SIGN_JOIN_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_CHANGED: + return "ATOM_WEAR_TIME_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_BACKGROUND_JOB_STATUS_REPORTED: - return "ATOM_K_ANON_BACKGROUND_JOB_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_DEVICE_STATUS_REPORTED: + return "ATOM_WEAR_SETUP_WIZARD_DEVICE_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_INITIALIZE_STATUS_REPORTED: - return "ATOM_K_ANON_INITIALIZE_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_PAIRING_COMPLETED: + return "ATOM_WEAR_SETUP_WIZARD_PAIRING_COMPLETED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_SIGN_STATUS_REPORTED: - return "ATOM_K_ANON_SIGN_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_CONNECTION_ESTABLISHED: + return "ATOM_WEAR_SETUP_WIZARD_CONNECTION_ESTABLISHED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_JOIN_STATUS_REPORTED: - return "ATOM_K_ANON_JOIN_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_CHECKIN_COMPLETED: + return "ATOM_WEAR_SETUP_WIZARD_CHECKIN_COMPLETED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_KEY_ATTESTATION_STATUS_REPORTED: - return "ATOM_K_ANON_KEY_ATTESTATION_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_COMPANION_TIME_REPORTED: + return "ATOM_WEAR_SETUP_WIZARD_COMPANION_TIME_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_GET_AD_SELECTION_DATA_API_CALLED: - return "ATOM_GET_AD_SELECTION_DATA_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_STATUS_REPORTED: + return "ATOM_WEAR_SETUP_WIZARD_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_GET_AD_SELECTION_DATA_BUYER_INPUT_GENERATED: - return "ATOM_GET_AD_SELECTION_DATA_BUYER_INPUT_GENERATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_HEARTBEAT_REPORTED: + return "ATOM_WEAR_SETUP_WIZARD_HEARTBEAT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_JOB_SCHEDULING_REPORTED: - return "ATOM_BACKGROUND_JOB_SCHEDULING_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_FRP_TRIGGERED: + return "ATOM_WEAR_SETUP_WIZARD_FRP_TRIGGERED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_ENCRYPTION_EPOCH_COMPUTATION_REPORTED: - return "ATOM_TOPICS_ENCRYPTION_EPOCH_COMPUTATION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_SYSTEM_UPDATE_TRIGGERED: + return "ATOM_WEAR_SETUP_WIZARD_SYSTEM_UPDATE_TRIGGERED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_ENCRYPTION_GET_TOPICS_REPORTED: - return "ATOM_TOPICS_ENCRYPTION_GET_TOPICS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETUP_WIZARD_PHONE_SWITCH_TRIGGERED: + return "ATOM_WEAR_SETUP_WIZARD_PHONE_SWITCH_TRIGGERED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ADSERVICES_SHELL_COMMAND_CALLED: - return "ATOM_ADSERVICES_SHELL_COMMAND_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RENDERER_INITIALIZED: + return "ATOM_RENDERER_INITIALIZED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_SIGNALS_API_CALLED: - return "ATOM_UPDATE_SIGNALS_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEMA_VERSION_RECEIVED: + return "ATOM_SCHEMA_VERSION_RECEIVED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JOB_RUN: - return "ATOM_ENCODING_JOB_RUN"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_INSPECTED: + return "ATOM_LAYOUT_INSPECTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JS_FETCH: - return "ATOM_ENCODING_JS_FETCH"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_EXPRESSION_INSPECTED: + return "ATOM_LAYOUT_EXPRESSION_INSPECTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JS_EXECUTION: - return "ATOM_ENCODING_JS_EXECUTION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_ANIMATIONS_INSPECTED: + return "ATOM_LAYOUT_ANIMATIONS_INSPECTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PERSIST_AD_SELECTION_RESULT_CALLED: - return "ATOM_PERSIST_AD_SELECTION_RESULT_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MATERIAL_COMPONENTS_INSPECTED: + return "ATOM_MATERIAL_COMPONENTS_INSPECTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SERVER_AUCTION_KEY_FETCH_CALLED: - return "ATOM_SERVER_AUCTION_KEY_FETCH_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TILE_REQUESTED: + return "ATOM_TILE_REQUESTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SERVER_AUCTION_BACKGROUND_KEY_FETCH_ENABLED: - return "ATOM_SERVER_AUCTION_BACKGROUND_KEY_FETCH_ENABLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_STATE_RESPONSE_RECEIVED: + return "ATOM_STATE_RESPONSE_RECEIVED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_PROCESS_ODP_REGISTRATION: - return "ATOM_AD_SERVICES_MEASUREMENT_PROCESS_ODP_REGISTRATION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TILE_RESPONSE_RECEIVED: + return "ATOM_TILE_RESPONSE_RECEIVED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_NOTIFY_REGISTRATION_TO_ODP: - return "ATOM_AD_SERVICES_MEASUREMENT_NOTIFY_REGISTRATION_TO_ODP"; + case ::perfetto::protos::pbzero::AtomId::ATOM_INFLATION_FINISHED: + return "ATOM_INFLATION_FINISHED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SELECT_ADS_FROM_OUTCOMES_API_CALLED: - return "ATOM_SELECT_ADS_FROM_OUTCOMES_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_INFLATION_FAILED: + return "ATOM_INFLATION_FAILED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_REPORT_IMPRESSION_API_CALLED: - return "ATOM_REPORT_IMPRESSION_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_IGNORED_INFLATION_FAILURES_REPORTED: + return "ATOM_IGNORED_INFLATION_FAILURES_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_TRANSACTION_STATS: - return "ATOM_AD_SERVICES_ENROLLMENT_TRANSACTION_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DRAWABLE_RENDERED: + return "ATOM_DRAWABLE_RENDERED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_COBALT_LOGGER_EVENT_REPORTED: - return "ATOM_AD_SERVICES_COBALT_LOGGER_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MODE_STATE_CHANGED: + return "ATOM_WEAR_MODE_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED: - return "ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_ACTION_REPORTED: + return "ATOM_MEDIA_ACTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_SIGNALS_PROCESS_REPORTED: - return "ATOM_UPDATE_SIGNALS_PROCESS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CONTROLS_LAUNCHED: + return "ATOM_MEDIA_CONTROLS_LAUNCHED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED: - return "ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_SESSION_STATE_CHANGED: + return "ATOM_MEDIA_SESSION_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_BUTTON_PRESSED: - return "ATOM_AI_WALLPAPERS_BUTTON_PRESSED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CONTROL_API_USAGE_REPORTED: + return "ATOM_MEDIA_CONTROL_API_USAGE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED: - return "ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_SUBSCRIPTION_CHANGED: + return "ATOM_MEDIA_SUBSCRIPTION_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_TERM_SELECTED: - return "ATOM_AI_WALLPAPERS_TERM_SELECTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_WALLPAPER_SET: - return "ATOM_AI_WALLPAPERS_WALLPAPER_SET"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_SESSION_SUMMARY: - return "ATOM_AI_WALLPAPERS_SESSION_SUMMARY"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_REQUESTED: - return "ATOM_APEX_INSTALLATION_REQUESTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIATOR_UPDATED: + return "ATOM_MEDIATOR_UPDATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_STAGED: - return "ATOM_APEX_INSTALLATION_STAGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER: + return "ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_ENDED: - return "ATOM_APEX_INSTALLATION_ENDED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSPROXY_CONNECTION_UPDATED: + return "ATOM_SYSPROXY_CONNECTION_UPDATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED: - return "ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_COMPANION_CONNECTION_STATE: + return "ATOM_WEAR_COMPANION_CONNECTION_STATE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED: - return "ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSPROXY_SERVICE_STATE_UPDATED: + return "ATOM_SYSPROXY_SERVICE_STATE_UPDATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED: - return "ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_ACTIVITY_INFO: + return "ATOM_UWB_ACTIVITY_INFO"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED: - return "ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_UPROBESTATS_ATOM_REPORTED: + return "ATOM_TEST_UPROBESTATS_ATOM_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED: - return "ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TV_LOW_POWER_STANDBY_POLICY: + return "ATOM_TV_LOW_POWER_STANDBY_POLICY"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DATUM_REPORTED: - return "ATOM_ART_DATUM_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EXTERNAL_TV_INPUT_EVENT: + return "ATOM_EXTERNAL_TV_INPUT_EVENT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEVICE_DATUM_REPORTED: - return "ATOM_ART_DEVICE_DATUM_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_INTEGRITY_INFO_REPORTED: + return "ATOM_BOOT_INTEGRITY_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DATUM_DELTA_REPORTED: - return "ATOM_ART_DATUM_DELTA_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED: + return "ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEX2OAT_REPORTED: - return "ATOM_ART_DEX2OAT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED: + return "ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEVICE_STATUS: - return "ATOM_ART_DEVICE_STATUS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_DEVICE_INFO_REPORTED: + return "ATOM_THREADNETWORK_DEVICE_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_DEXOPT_JOB_ENDED: - return "ATOM_BACKGROUND_DEXOPT_JOB_ENDED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED: + return "ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PREREBOOT_DEXOPT_JOB_ENDED: - return "ATOM_PREREBOOT_DEXOPT_JOB_ENDED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_NUMBERS_INFO: + return "ATOM_EMERGENCY_NUMBERS_INFO"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ODREFRESH_REPORTED: - return "ATOM_ODREFRESH_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_NETWORK_VALIDATION: + return "ATOM_DATA_NETWORK_VALIDATION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ODSIGN_REPORTED: - return "ATOM_ODSIGN_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_RAT_STATE_CHANGED: + return "ATOM_DATA_RAT_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_UI_EVENT_REPORTED: - return "ATOM_AUTOFILL_UI_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CONNECTED_CHANNEL_CHANGED: + return "ATOM_CONNECTED_CHANNEL_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FILL_REQUEST_REPORTED: - return "ATOM_AUTOFILL_FILL_REQUEST_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_IDENTIFIER_DISCLOSED: + return "ATOM_CELLULAR_IDENTIFIER_DISCLOSED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FILL_RESPONSE_REPORTED: - return "ATOM_AUTOFILL_FILL_RESPONSE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_CONTROLLER: + return "ATOM_SATELLITE_CONTROLLER"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_SAVE_EVENT_REPORTED: - return "ATOM_AUTOFILL_SAVE_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_SESSION: + return "ATOM_SATELLITE_SESSION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_SESSION_COMMITTED: - return "ATOM_AUTOFILL_SESSION_COMMITTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_INCOMING_DATAGRAM: + return "ATOM_SATELLITE_INCOMING_DATAGRAM"; - case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED: - return "ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_OUTGOING_DATAGRAM: + return "ATOM_SATELLITE_OUTGOING_DATAGRAM"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_RECENTS_EVENT_REPORTED: - return "ATOM_CAR_RECENTS_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_PROVISION: + return "ATOM_SATELLITE_PROVISION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_CALM_MODE_EVENT_REPORTED: - return "ATOM_CAR_CALM_MODE_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER: + return "ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED: - return "ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ROAMING_SATELLITE_SESSION: + return "ATOM_CARRIER_ROAMING_SATELLITE_SESSION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PLUGIN_INITIALIZED: - return "ATOM_PLUGIN_INITIALIZED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS: + return "ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED: - return "ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTROLLER_STATS_PER_PACKAGE: + return "ATOM_CONTROLLER_STATS_PER_PACKAGE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION: - return "ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_ENTITLEMENT: + return "ATOM_SATELLITE_ENTITLEMENT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION: - return "ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_CONFIG_UPDATER: + return "ATOM_SATELLITE_CONFIG_UPDATER"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_SESSION_CONNECTED: - return "ATOM_BLUETOOTH_LE_SESSION_CONNECTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_ACCESS_CONTROLLER: + return "ATOM_SATELLITE_ACCESS_CONTROLLER"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED: - return "ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_QUALIFIED_RAT_LIST_CHANGED: + return "ATOM_QUALIFIED_RAT_LIST_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED: - return "ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_IMS_CALL_DROP_STATS: + return "ATOM_QNS_IMS_CALL_DROP_STATS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED: - return "ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_FALLBACK_RESTRICTION_CHANGED: + return "ATOM_QNS_FALLBACK_RESTRICTION_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED: - return "ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO: + return "ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO"; - case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID: - return "ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID"; + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_HANDOVER_TIME_MILLIS: + return "ATOM_QNS_HANDOVER_TIME_MILLIS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LE_APP_SCAN_STATE_CHANGED: - return "ATOM_LE_APP_SCAN_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_HANDOVER_PINGPONG: + return "ATOM_QNS_HANDOVER_PINGPONG"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LE_RADIO_SCAN_STOPPED: - return "ATOM_LE_RADIO_SCAN_STOPPED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED: + return "ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LE_SCAN_RESULT_RECEIVED: - return "ATOM_LE_SCAN_RESULT_RECEIVED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_NUMBER_DIALED: + return "ATOM_EMERGENCY_NUMBER_DIALED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LE_SCAN_ABUSED: - return "ATOM_LE_SCAN_ABUSED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CALL_STATS: + return "ATOM_CALL_STATS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LE_ADV_STATE_CHANGED: - return "ATOM_LE_ADV_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CALL_AUDIO_ROUTE_STATS: + return "ATOM_CALL_AUDIO_ROUTE_STATS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LE_ADV_ERROR_REPORTED: - return "ATOM_LE_ADV_ERROR_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TELECOM_API_STATS: + return "ATOM_TELECOM_API_STATS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_A2DP_SESSION_REPORTED: - return "ATOM_A2DP_SESSION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TELECOM_ERROR_STATS: + return "ATOM_TELECOM_ERROR_STATS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED: - return "ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCKSCREEN_SHORTCUT_SELECTED: + return "ATOM_LOCKSCREEN_SHORTCUT_SELECTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_AUDIO_SESSION_REPORTED: - return "ATOM_BROADCAST_AUDIO_SESSION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED: + return "ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_AUDIO_SYNC_REPORTED: - return "ATOM_BROADCAST_AUDIO_SYNC_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_IMPRESSION_EVENT_V2: + return "ATOM_LAUNCHER_IMPRESSION_EVENT_V2"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE: - return "ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_SWITCH_LATENCY_TRACKED: + return "ATOM_DISPLAY_SWITCH_LATENCY_TRACKED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_CONNECTION: - return "ATOM_BLUETOOTH_LE_CONNECTION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_LISTENER_SERVICE: + return "ATOM_NOTIFICATION_LISTENER_SERVICE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_SENT: - return "ATOM_BROADCAST_SENT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_NAV_HANDLE_TOUCH_POINTS: + return "ATOM_NAV_HANDLE_TOUCH_POINTS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT: - return "ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED: + return "ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED: - return "ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PERIPHERAL_TUTORIAL_LAUNCHED: + return "ATOM_PERIPHERAL_TUTORIAL_LAUNCHED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_FAILED: - return "ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_FAILED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTEXTUAL_EDUCATION_TRIGGERED: + return "ATOM_CONTEXTUAL_EDUCATION_TRIGGERED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DAILY_KEEPALIVE_INFO_REPORTED: - return "ATOM_DAILY_KEEPALIVE_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_COMMUNAL_HUB_SNAPSHOT: + return "ATOM_COMMUNAL_HUB_SNAPSHOT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_REQUEST_STATE_CHANGED: - return "ATOM_NETWORK_REQUEST_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_EXTENSION_ATOM_REPORTED: + return "ATOM_TEST_EXTENSION_ATOM_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED: - return "ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_RESTRICTED_ATOM_REPORTED: + return "ATOM_TEST_RESTRICTED_ATOM_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED: - return "ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_STATS_SOCKET_LOSS_REPORTED: + return "ATOM_STATS_SOCKET_LOSS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED: - return "ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SETTINGS_SPA_REPORTED: + return "ATOM_SETTINGS_SPA_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APF_SESSION_INFO_REPORTED: - return "ATOM_APF_SESSION_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SELINUX_AUDIT_LOG: + return "ATOM_SELINUX_AUDIT_LOG"; - case ::perfetto::protos::pbzero::AtomId::ATOM_IP_CLIENT_RA_INFO_REPORTED: - return "ATOM_IP_CLIENT_RA_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_API_CALLED: + return "ATOM_SANDBOX_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_VPN_CONNECTION_STATE_CHANGED: - return "ATOM_VPN_CONNECTION_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED: + return "ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_VPN_CONNECTION_REPORTED: - return "ATOM_VPN_CONNECTION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION: + return "ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_POLICY: - return "ATOM_CPU_POLICY"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_SDK_STORAGE: + return "ATOM_SANDBOX_SDK_STORAGE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_API_CALLED: - return "ATOM_CREDENTIAL_MANAGER_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RKPD_POOL_STATS: + return "ATOM_RKPD_POOL_STATS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED: - return "ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RKPD_CLIENT_OPERATION: + return "ATOM_RKPD_CLIENT_OPERATION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED: - return "ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_CONFIGURED: + return "ATOM_RANGING_SESSION_CONFIGURED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED: - return "ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_STARTED: + return "ATOM_RANGING_SESSION_STARTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED: - return "ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_CLOSED: + return "ATOM_RANGING_SESSION_CLOSED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED: - return "ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_TECHNOLOGY_STARTED: + return "ATOM_RANGING_TECHNOLOGY_STARTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_GET_REPORTED: - return "ATOM_CREDENTIAL_MANAGER_GET_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_TECHNOLOGY_STOPPED: + return "ATOM_RANGING_TECHNOLOGY_STOPPED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED: - return "ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED: + return "ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_APIV2_CALLED: - return "ATOM_CREDENTIAL_MANAGER_APIV2_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BACKUP_SETUP_STATUS_REPORTED: + return "ATOM_BACKUP_SETUP_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_ENGINE_CREATED: - return "ATOM_CRONET_ENGINE_CREATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_OFF_REPORTED: + return "ATOM_SCREEN_OFF_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_TRAFFIC_REPORTED: - return "ATOM_CRONET_TRAFFIC_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED: + return "ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_ENGINE_BUILDER_INITIALIZED: - return "ATOM_CRONET_ENGINE_BUILDER_INITIALIZED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED: + return "ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_HTTP_FLAGS_INITIALIZED: - return "ATOM_CRONET_HTTP_FLAGS_INITIALIZED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_DIM_REPORTED: + return "ATOM_SCREEN_DIM_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_INITIALIZED: - return "ATOM_CRONET_INITIALIZED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ATOM_9999: + return "ATOM_ATOM_9999"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_UI_CHANGED: - return "ATOM_DESKTOP_MODE_UI_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ATOM_99999: + return "ATOM_ATOM_99999"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE: - return "ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_SESSION_INFO_REPORTED: + return "ATOM_PHOTOPICKER_SESSION_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED: - return "ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_API_INFO_REPORTED: + return "ATOM_PHOTOPICKER_API_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED: - return "ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_UI_EVENT_LOGGED: + return "ATOM_PHOTOPICKER_UI_EVENT_LOGGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED: - return "ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED: + return "ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED: - return "ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED: + return "ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED: - return "ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED: + return "ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED: - return "ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED: + return "ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED: - return "ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED: + return "ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_POLICY_MANAGEMENT_MODE: - return "ATOM_DEVICE_POLICY_MANAGEMENT_MODE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_PAGE_INFO_LOGGED: + return "ATOM_PHOTOPICKER_PAGE_INFO_LOGGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_POLICY_STATE: - return "ATOM_DEVICE_POLICY_STATE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED: + return "ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED: - return "ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED: + return "ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EXTERNAL_DISPLAY_STATE_CHANGED: - return "ATOM_EXTERNAL_DISPLAY_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED: + return "ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DND_STATE_CHANGED: - return "ATOM_DND_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED: + return "ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DREAM_SETTING_CHANGED: - return "ATOM_DREAM_SETTING_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED: + return "ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DREAM_SETTING_SNAPSHOT: - return "ATOM_DREAM_SETTING_SNAPSHOT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED: + return "ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_EVENT_REPORTED: - return "ATOM_EXPRESS_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED: + return "ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED: - return "ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION: + return "ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_UID_EVENT_REPORTED: - return "ATOM_EXPRESS_UID_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED: + return "ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED: - return "ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED: + return "ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_FEDERATED_COMPUTE_API_CALLED: - return "ATOM_FEDERATED_COMPUTE_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED: + return "ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED: - return "ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED: + return "ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED: - return "ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PRESSURE_STALL_INFORMATION: + return "ATOM_PRESSURE_STALL_INFORMATION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_LOAD_REPORTED: + return "ATOM_PDF_LOAD_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_API_USAGE_REPORTED: + return "ATOM_PDF_API_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_SEARCH_REPORTED: + return "ATOM_PDF_SEARCH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_COMPONENT_STATE_CHANGED_REPORTED: + return "ATOM_COMPONENT_STATE_CHANGED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ONDEVICEPERSONALIZATION_API_CALLED: + return "ATOM_ONDEVICEPERSONALIZATION_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ONDEVICEPERSONALIZATION_TRACE_EVENT: + return "ATOM_ONDEVICEPERSONALIZATION_TRACE_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_OBSERVE_MODE_STATE_CHANGED: + return "ATOM_NFC_OBSERVE_MODE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_FIELD_CHANGED: + return "ATOM_NFC_FIELD_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED: + return "ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED: + return "ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_EXIT_FRAME_TABLE_CHANGED: + return "ATOM_NFC_EXIT_FRAME_TABLE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_AUTO_TRANSACT_REPORTED: + return "ATOM_NFC_AUTO_TRANSACT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED: + return "ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MTE_STATE: + return "ATOM_MTE_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ZRAM_MAINTENANCE_EXECUTED: + return "ATOM_ZRAM_MAINTENANCE_EXECUTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ZRAM_SETUP_EXECUTED: + return "ATOM_ZRAM_SETUP_EXECUTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ZRAM_MM_STAT_MMD: + return "ATOM_ZRAM_MM_STAT_MMD"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ZRAM_BD_STAT_MMD: + return "ATOM_ZRAM_BD_STAT_MMD"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_EDITING_ENDED_REPORTED: + return "ATOM_MEDIA_EDITING_ENDED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED: + return "ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STARTED: + return "ATOM_MEDIA_CODEC_STARTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STOPPED: + return "ATOM_MEDIA_CODEC_STOPPED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_RENDERED: + return "ATOM_MEDIA_CODEC_RENDERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_STATE_CHANGED: + return "ATOM_EMERGENCY_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED: + return "ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED: + return "ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED: + return "ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED: + return "ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_OOM_KILL_OCCURRED: + return "ATOM_KERNEL_OOM_KILL_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYBOARD_CONFIGURED: + return "ATOM_KEYBOARD_CONFIGURED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED: + return "ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INPUTDEVICE_USAGE_REPORTED: + return "ATOM_INPUTDEVICE_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INPUT_EVENT_LATENCY_REPORTED: + return "ATOM_INPUT_EVENT_LATENCY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TOUCHPAD_USAGE: + return "ATOM_TOUCHPAD_USAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IKE_SESSION_TERMINATED: + return "ATOM_IKE_SESSION_TERMINATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED: + return "ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NEGOTIATED_SECURITY_ASSOCIATION: + return "ATOM_NEGOTIATED_SECURITY_ASSOCIATION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED: + return "ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_UI_IMPRESSION: + return "ATOM_HEALTH_CONNECT_UI_IMPRESSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_UI_INTERACTION: + return "ATOM_HEALTH_CONNECT_UI_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED: + return "ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_API_CALLED: + return "ATOM_HEALTH_CONNECT_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_USAGE_STATS: + return "ATOM_HEALTH_CONNECT_USAGE_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_STORAGE_STATS: + return "ATOM_HEALTH_CONNECT_STORAGE_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_API_INVOKED: + return "ATOM_HEALTH_CONNECT_API_INVOKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXERCISE_ROUTE_API_CALLED: + return "ATOM_EXERCISE_ROUTE_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_EXPORT_INVOKED: + return "ATOM_HEALTH_CONNECT_EXPORT_INVOKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_IMPORT_INVOKED: + return "ATOM_HEALTH_CONNECT_IMPORT_INVOKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED: + return "ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_PERMISSION_STATS: + return "ATOM_HEALTH_CONNECT_PERMISSION_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_PHR_API_INVOKED: + return "ATOM_HEALTH_CONNECT_PHR_API_INVOKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_PHR_USAGE_STATS: + return "ATOM_HEALTH_CONNECT_PHR_USAGE_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_PHR_STORAGE_STATS: + return "ATOM_HEALTH_CONNECT_PHR_STORAGE_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_RESTRICTED_ECOSYSTEM_STATS: + return "ATOM_HEALTH_CONNECT_RESTRICTED_ECOSYSTEM_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_ECOSYSTEM_STATS: + return "ATOM_HEALTH_CONNECT_ECOSYSTEM_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_EARC_STATUS_REPORTED: + return "ATOM_HDMI_EARC_STATUS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED: + return "ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_POWER_STATE_CHANGE_ON_ACTIVE_SOURCE_LOST_TOGGLED: + return "ATOM_HDMI_POWER_STATE_CHANGE_ON_ACTIVE_SOURCE_LOST_TOGGLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_HEALTH: + return "ATOM_BATTERY_HEALTH"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_UNENROLLED: + return "ATOM_BIOMETRIC_UNENROLLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_ENUMERATED: + return "ATOM_BIOMETRIC_ENUMERATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED: + return "ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED: + return "ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED"; case ::perfetto::protos::pbzero::AtomId::ATOM_FULL_SCREEN_INTENT_LAUNCHED: return "ATOM_FULL_SCREEN_INTENT_LAUNCHED"; @@ -60091,656 +60272,629 @@ const char* AtomId_Name(::perfetto::protos::pbzero::AtomId value) { case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED: return "ATOM_CONTENT_OR_FILE_URI_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED: - return "ATOM_APPLICATION_GRAMMATICAL_INFLECTION_CHANGED"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED: - return "ATOM_SYSTEM_GRAMMATICAL_INFLECTION_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_IDLE_TEMP_ALLOWLIST_UPDATED: + return "ATOM_DEVICE_IDLE_TEMP_ALLOWLIST_UPDATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_HEALTH: - return "ATOM_BATTERY_HEALTH"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_OP_NOTE_OP_OR_CHECK_OP_BINDER_API_CALLED: + return "ATOM_APP_OP_NOTE_OP_OR_CHECK_OP_BINDER_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_EARC_STATUS_REPORTED: - return "ATOM_HDMI_EARC_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_FRAMEWORK_WAKELOCK_INFO: + return "ATOM_FRAMEWORK_WAKELOCK_INFO"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED: - return "ATOM_HDMI_SOUNDBAR_MODE_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_JANK_FRAME_COUNT_BY_WIDGET_REPORTED: + return "ATOM_JANK_FRAME_COUNT_BY_WIDGET_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_API_CALLED: - return "ATOM_HEALTH_CONNECT_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_INTENT_CREATOR_TOKEN_ADDED: + return "ATOM_INTENT_CREATOR_TOKEN_ADDED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_USAGE_STATS: - return "ATOM_HEALTH_CONNECT_USAGE_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_CHANNEL_CLASSIFICATION: + return "ATOM_NOTIFICATION_CHANNEL_CLASSIFICATION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_STORAGE_STATS: - return "ATOM_HEALTH_CONNECT_STORAGE_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_STATUS_FOR_COMPATIBILITY_CHANGED: + return "ATOM_CAMERA_STATUS_FOR_COMPATIBILITY_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_API_INVOKED: - return "ATOM_HEALTH_CONNECT_API_INVOKED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_FEDERATED_COMPUTE_API_CALLED: + return "ATOM_FEDERATED_COMPUTE_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EXERCISE_ROUTE_API_CALLED: - return "ATOM_EXERCISE_ROUTE_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED: + return "ATOM_FEDERATED_COMPUTE_TRAINING_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_EXPORT_INVOKED: - return "ATOM_HEALTH_CONNECT_EXPORT_INVOKED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED: + return "ATOM_EXAMPLE_ITERATOR_NEXT_LATENCY_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_IMPORT_INVOKED: - return "ATOM_HEALTH_CONNECT_IMPORT_INVOKED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_FEDERATED_COMPUTE_TRACE_EVENT_REPORTED: + return "ATOM_FEDERATED_COMPUTE_TRACE_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED: - return "ATOM_HEALTH_CONNECT_EXPORT_IMPORT_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_EVENT_REPORTED: + return "ATOM_EXPRESS_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_UI_IMPRESSION: - return "ATOM_HEALTH_CONNECT_UI_IMPRESSION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED: + return "ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_UI_INTERACTION: - return "ATOM_HEALTH_CONNECT_UI_INTERACTION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_UID_EVENT_REPORTED: + return "ATOM_EXPRESS_UID_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED: - return "ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED: + return "ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED: - return "ATOM_HOTWORD_EGRESS_SIZE_ATOM_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DREAM_SETTING_CHANGED: + return "ATOM_DREAM_SETTING_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_IKE_SESSION_TERMINATED: - return "ATOM_IKE_SESSION_TERMINATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DREAM_SETTING_SNAPSHOT: + return "ATOM_DREAM_SETTING_SNAPSHOT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED: - return "ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DND_STATE_CHANGED: + return "ATOM_DND_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NEGOTIATED_SECURITY_ASSOCIATION: - return "ATOM_NEGOTIATED_SECURITY_ASSOCIATION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_EXTERNAL_DISPLAY_STATE_CHANGED: + return "ATOM_EXTERNAL_DISPLAY_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_KEYBOARD_CONFIGURED: - return "ATOM_KEYBOARD_CONFIGURED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED: + return "ATOM_DISPLAY_MODE_DIRECTOR_VOTE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED: - return "ATOM_KEYBOARD_SYSTEMS_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_POLICY_MANAGEMENT_MODE: + return "ATOM_DEVICE_POLICY_MANAGEMENT_MODE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_INPUTDEVICE_USAGE_REPORTED: - return "ATOM_INPUTDEVICE_USAGE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_POLICY_STATE: + return "ATOM_DEVICE_POLICY_STATE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_INPUT_EVENT_LATENCY_REPORTED: - return "ATOM_INPUT_EVENT_LATENCY_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED: + return "ATOM_DEVICE_LOCK_CHECK_IN_REQUEST_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TOUCHPAD_USAGE: - return "ATOM_TOUCHPAD_USAGE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED: + return "ATOM_DEVICE_LOCK_PROVISIONING_COMPLETE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_OOM_KILL_OCCURRED: - return "ATOM_KERNEL_OOM_KILL_OCCURRED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED: + return "ATOM_DEVICE_LOCK_KIOSK_APP_REQUEST_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_STATE_CHANGED: - return "ATOM_EMERGENCY_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED: + return "ATOM_DEVICE_LOCK_CHECK_IN_RETRY_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED: - return "ATOM_CHRE_SIGNIFICANT_MOTION_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED: + return "ATOM_DEVICE_LOCK_PROVISION_FAILURE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED: - return "ATOM_POPULATION_DENSITY_PROVIDER_LOADING_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED: + return "ATOM_DEVICE_LOCK_LOCK_UNLOCK_DEVICE_FAILURE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED: - return "ATOM_DENSITY_BASED_COARSE_LOCATIONS_USAGE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_UI_CHANGED: + return "ATOM_DESKTOP_MODE_UI_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED: - return "ATOM_DENSITY_BASED_COARSE_LOCATIONS_PROVIDER_QUERY_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE: + return "ATOM_DESKTOP_MODE_SESSION_TASK_UPDATE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED: - return "ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED: + return "ATOM_DESKTOP_MODE_TASK_SIZE_UPDATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STARTED: - return "ATOM_MEDIA_CODEC_STARTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_ENGINE_CREATED: + return "ATOM_CRONET_ENGINE_CREATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STOPPED: - return "ATOM_MEDIA_CODEC_STOPPED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_TRAFFIC_REPORTED: + return "ATOM_CRONET_TRAFFIC_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_RENDERED: - return "ATOM_MEDIA_CODEC_RENDERED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_ENGINE_BUILDER_INITIALIZED: + return "ATOM_CRONET_ENGINE_BUILDER_INITIALIZED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_EDITING_ENDED_REPORTED: - return "ATOM_MEDIA_EDITING_ENDED_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_HTTP_FLAGS_INITIALIZED: + return "ATOM_CRONET_HTTP_FLAGS_INITIALIZED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MTE_STATE: - return "ATOM_MTE_STATE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_INITIALIZED: + return "ATOM_CRONET_INITIALIZED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED: - return "ATOM_MICROXR_DEVICE_BOOT_COMPLETE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_API_CALLED: + return "ATOM_CREDENTIAL_MANAGER_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_OBSERVE_MODE_STATE_CHANGED: - return "ATOM_NFC_OBSERVE_MODE_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_FIELD_CHANGED: - return "ATOM_NFC_FIELD_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED: - return "ATOM_NFC_POLLING_LOOP_NOTIFICATION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED: - return "ATOM_NFC_PROPRIETARY_CAPABILITIES_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ONDEVICEPERSONALIZATION_API_CALLED: - return "ATOM_ONDEVICEPERSONALIZATION_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_COMPONENT_STATE_CHANGED_REPORTED: - return "ATOM_COMPONENT_STATE_CHANGED_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_GET_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_GET_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_LOAD_REPORTED: - return "ATOM_PDF_LOAD_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_API_USAGE_REPORTED: - return "ATOM_PDF_API_USAGE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_APIV2_CALLED: + return "ATOM_CREDENTIAL_MANAGER_APIV2_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PDF_SEARCH_REPORTED: - return "ATOM_PDF_SEARCH_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_POLICY: + return "ATOM_CPU_POLICY"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PRESSURE_STALL_INFORMATION: - return "ATOM_PRESSURE_STALL_INFORMATION"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED: - return "ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED: - return "ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION: - return "ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED: - return "ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED: - return "ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED: - return "ATOM_ENHANCED_CONFIRMATION_DIALOG_RESULT_REPORTED"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED: - return "ATOM_ENHANCED_CONFIRMATION_RESTRICTION_CLEARED"; - - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_SESSION_INFO_REPORTED: - return "ATOM_PHOTOPICKER_SESSION_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_VPN_CONNECTION_STATE_CHANGED: + return "ATOM_VPN_CONNECTION_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_API_INFO_REPORTED: - return "ATOM_PHOTOPICKER_API_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_VPN_CONNECTION_REPORTED: + return "ATOM_VPN_CONNECTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_UI_EVENT_LOGGED: - return "ATOM_PHOTOPICKER_UI_EVENT_LOGGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_IP_CLIENT_RA_INFO_REPORTED: + return "ATOM_IP_CLIENT_RA_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED: - return "ATOM_PHOTOPICKER_MEDIA_ITEM_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APF_SESSION_INFO_REPORTED: + return "ATOM_APF_SESSION_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED: - return "ATOM_PHOTOPICKER_PREVIEW_INFO_LOGGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED: + return "ATOM_CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED: - return "ATOM_PHOTOPICKER_MENU_INTERACTION_LOGGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED: + return "ATOM_NETWORK_STATS_RECORDER_FILE_OPERATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED: - return "ATOM_PHOTOPICKER_BANNER_INTERACTION_LOGGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DAILY_KEEPALIVE_INFO_REPORTED: + return "ATOM_DAILY_KEEPALIVE_INFO_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED: - return "ATOM_PHOTOPICKER_MEDIA_LIBRARY_INFO_LOGGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_REQUEST_STATE_CHANGED: + return "ATOM_NETWORK_REQUEST_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_PAGE_INFO_LOGGED: - return "ATOM_PHOTOPICKER_PAGE_INFO_LOGGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED: + return "ATOM_TETHERING_ACTIVE_SESSIONS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED: - return "ATOM_PHOTOPICKER_MEDIA_GRID_SYNC_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_STATE_CHANGED: + return "ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_UPDATE_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED: - return "ATOM_PHOTOPICKER_ALBUM_SYNC_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_HARDWARE_RENDERER_EVENT: + return "ATOM_HARDWARE_RENDERER_EVENT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED: - return "ATOM_PHOTOPICKER_SEARCH_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TEXTURE_VIEW_EVENT: + return "ATOM_TEXTURE_VIEW_EVENT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED: - return "ATOM_SEARCH_DATA_EXTRACTION_DETAILS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SURFACE_CONTROL_EVENT: + return "ATOM_SURFACE_CONTROL_EVENT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED: - return "ATOM_EMBEDDED_PHOTOPICKER_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_IMAGE_DECODED: + return "ATOM_IMAGE_DECODED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ATOM_9999: - return "ATOM_ATOM_9999"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED: + return "ATOM_CERTIFICATE_TRANSPARENCY_LOG_LIST_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_ATOM_99999: - return "ATOM_ATOM_99999"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CONSCRYPT_SERVICE_USED: + return "ATOM_CONSCRYPT_SERVICE_USED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_OFF_REPORTED: - return "ATOM_SCREEN_OFF_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CERTIFICATE_TRANSPARENCY_VERIFICATION_REPORTED: + return "ATOM_CERTIFICATE_TRANSPARENCY_VERIFICATION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED: - return "ATOM_SCREEN_TIMEOUT_OVERRIDE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT: + return "ATOM_CAMERA_FEATURE_COMBINATION_QUERY_EVENT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED: - return "ATOM_SCREEN_INTERACTIVE_SESSION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_SENT: + return "ATOM_BROADCAST_SENT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_DIM_REPORTED: - return "ATOM_SCREEN_DIM_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED: + return "ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED: - return "ATOM_MEDIA_PROVIDER_DATABASE_ROLLBACK_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION: + return "ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BACKUP_SETUP_STATUS_REPORTED: - return "ATOM_BACKUP_SETUP_STATUS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION: + return "ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_CONFIGURED: - return "ATOM_RANGING_SESSION_CONFIGURED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_SESSION_CONNECTED: + return "ATOM_BLUETOOTH_LE_SESSION_CONNECTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_STARTED: - return "ATOM_RANGING_SESSION_STARTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED: + return "ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_SESSION_CLOSED: - return "ATOM_RANGING_SESSION_CLOSED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED: + return "ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_TECHNOLOGY_STARTED: - return "ATOM_RANGING_TECHNOLOGY_STARTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED: + return "ATOM_BLUETOOTH_CONTENT_PROFILE_ERROR_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RANGING_TECHNOLOGY_STOPPED: - return "ATOM_RANGING_TECHNOLOGY_STOPPED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED: + return "ATOM_BLUETOOTH_RFCOMM_CONNECTION_ATTEMPTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RKPD_POOL_STATS: - return "ATOM_RKPD_POOL_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID: + return "ATOM_REMOTE_DEVICE_INFORMATION_WITH_METRIC_ID"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RKPD_CLIENT_OPERATION: - return "ATOM_RKPD_CLIENT_OPERATION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LE_APP_SCAN_STATE_CHANGED: + return "ATOM_LE_APP_SCAN_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_API_CALLED: - return "ATOM_SANDBOX_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LE_RADIO_SCAN_STOPPED: + return "ATOM_LE_RADIO_SCAN_STOPPED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED: - return "ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LE_SCAN_RESULT_RECEIVED: + return "ATOM_LE_SCAN_RESULT_RECEIVED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION: - return "ATOM_SDK_SANDBOX_RESTRICTED_ACCESS_IN_SESSION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LE_SCAN_ABUSED: + return "ATOM_LE_SCAN_ABUSED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_SDK_STORAGE: - return "ATOM_SANDBOX_SDK_STORAGE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LE_ADV_STATE_CHANGED: + return "ATOM_LE_ADV_STATE_CHANGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SELINUX_AUDIT_LOG: - return "ATOM_SELINUX_AUDIT_LOG"; + case ::perfetto::protos::pbzero::AtomId::ATOM_LE_ADV_ERROR_REPORTED: + return "ATOM_LE_ADV_ERROR_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SETTINGS_SPA_REPORTED: - return "ATOM_SETTINGS_SPA_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_A2DP_SESSION_REPORTED: + return "ATOM_A2DP_SESSION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_EXTENSION_ATOM_REPORTED: - return "ATOM_TEST_EXTENSION_ATOM_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED: + return "ATOM_BLUETOOTH_CROSS_LAYER_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_RESTRICTED_ATOM_REPORTED: - return "ATOM_TEST_RESTRICTED_ATOM_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_AUDIO_SESSION_REPORTED: + return "ATOM_BROADCAST_AUDIO_SESSION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_STATS_SOCKET_LOSS_REPORTED: - return "ATOM_STATS_SOCKET_LOSS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_AUDIO_SYNC_REPORTED: + return "ATOM_BROADCAST_AUDIO_SYNC_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LOCKSCREEN_SHORTCUT_SELECTED: - return "ATOM_LOCKSCREEN_SHORTCUT_SELECTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE: + return "ATOM_BLUETOOTH_RFCOMM_CONNECTION_REPORTED_AT_CLOSE"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED: - return "ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_CONNECTION: + return "ATOM_BLUETOOTH_LE_CONNECTION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_IMPRESSION_EVENT_V2: - return "ATOM_LAUNCHER_IMPRESSION_EVENT_V2"; + case ::perfetto::protos::pbzero::AtomId::ATOM_HEARING_DEVICE_ACTIVE_EVENT_REPORTED: + return "ATOM_HEARING_DEVICE_ACTIVE_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_SWITCH_LATENCY_TRACKED: - return "ATOM_DISPLAY_SWITCH_LATENCY_TRACKED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BACKPORTED_FIX_STATUS_REPORTED: + return "ATOM_BACKPORTED_FIX_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_LISTENER_SERVICE: - return "ATOM_NOTIFICATION_LISTENER_SERVICE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PLUGIN_INITIALIZED: + return "ATOM_PLUGIN_INITIALIZED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_NAV_HANDLE_TOUCH_POINTS: - return "ATOM_NAV_HANDLE_TOUCH_POINTS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_SYSTEM_UI_DATA_SUBSCRIPTION_EVENT_REPORTED: + return "ATOM_CAR_SYSTEM_UI_DATA_SUBSCRIPTION_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED: - return "ATOM_COMMUNAL_HUB_WIDGET_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_SETTINGS_DATA_SUBSCRIPTION_EVENT_REPORTED: + return "ATOM_CAR_SETTINGS_DATA_SUBSCRIPTION_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_COMMUNAL_HUB_SNAPSHOT: - return "ATOM_COMMUNAL_HUB_SNAPSHOT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_QC_LIB_EVENT_REPORTED: + return "ATOM_CAR_QC_LIB_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_NUMBER_DIALED: - return "ATOM_EMERGENCY_NUMBER_DIALED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED: + return "ATOM_CAR_WAKEUP_FROM_SUSPEND_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CALL_STATS: - return "ATOM_CALL_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_RECENTS_EVENT_REPORTED: + return "ATOM_CAR_RECENTS_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CALL_AUDIO_ROUTE_STATS: - return "ATOM_CALL_AUDIO_ROUTE_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_CALM_MODE_EVENT_REPORTED: + return "ATOM_CAR_CALM_MODE_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TELECOM_API_STATS: - return "ATOM_TELECOM_API_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_UI_EVENT_REPORTED: + return "ATOM_AUTOFILL_UI_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TELECOM_ERROR_STATS: - return "ATOM_TELECOM_ERROR_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FILL_REQUEST_REPORTED: + return "ATOM_AUTOFILL_FILL_REQUEST_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED: - return "ATOM_CELLULAR_RADIO_POWER_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FILL_RESPONSE_REPORTED: + return "ATOM_AUTOFILL_FILL_RESPONSE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_NUMBERS_INFO: - return "ATOM_EMERGENCY_NUMBERS_INFO"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_SAVE_EVENT_REPORTED: + return "ATOM_AUTOFILL_SAVE_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_NETWORK_VALIDATION: - return "ATOM_DATA_NETWORK_VALIDATION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_SESSION_COMMITTED: + return "ATOM_AUTOFILL_SESSION_COMMITTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_RAT_STATE_CHANGED: - return "ATOM_DATA_RAT_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED: + return "ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CONNECTED_CHANNEL_CHANGED: - return "ATOM_CONNECTED_CHANNEL_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ODREFRESH_REPORTED: + return "ATOM_ODREFRESH_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED: - return "ATOM_IWLAN_UNDERLYING_NETWORK_VALIDATION_RESULT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ODSIGN_REPORTED: + return "ATOM_ODSIGN_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_QUALIFIED_RAT_LIST_CHANGED: - return "ATOM_QUALIFIED_RAT_LIST_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_DEXOPT_JOB_ENDED: + return "ATOM_BACKGROUND_DEXOPT_JOB_ENDED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_IMS_CALL_DROP_STATS: - return "ATOM_QNS_IMS_CALL_DROP_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PREREBOOT_DEXOPT_JOB_ENDED: + return "ATOM_PREREBOOT_DEXOPT_JOB_ENDED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_FALLBACK_RESTRICTION_CHANGED: - return "ATOM_QNS_FALLBACK_RESTRICTION_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DATUM_REPORTED: + return "ATOM_ART_DATUM_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO: - return "ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEVICE_DATUM_REPORTED: + return "ATOM_ART_DEVICE_DATUM_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_HANDOVER_TIME_MILLIS: - return "ATOM_QNS_HANDOVER_TIME_MILLIS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DATUM_DELTA_REPORTED: + return "ATOM_ART_DATUM_DELTA_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_HANDOVER_PINGPONG: - return "ATOM_QNS_HANDOVER_PINGPONG"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEX2OAT_REPORTED: + return "ATOM_ART_DEX2OAT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_CONTROLLER: - return "ATOM_SATELLITE_CONTROLLER"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEVICE_STATUS: + return "ATOM_ART_DEVICE_STATUS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_SESSION: - return "ATOM_SATELLITE_SESSION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED: + return "ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_INCOMING_DATAGRAM: - return "ATOM_SATELLITE_INCOMING_DATAGRAM"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED: + return "ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_OUTGOING_DATAGRAM: - return "ATOM_SATELLITE_OUTGOING_DATAGRAM"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED: + return "ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_PROVISION: - return "ATOM_SATELLITE_PROVISION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED: + return "ATOM_APP_SEARCH_USAGE_SEARCH_INTENT_RAW_QUERY_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER: - return "ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED: + return "ATOM_APP_SEARCH_APPS_INDEXER_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ROAMING_SATELLITE_SESSION: - return "ATOM_CARRIER_ROAMING_SATELLITE_SESSION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_FUNCTIONS_REQUEST_REPORTED: + return "ATOM_APP_FUNCTIONS_REQUEST_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS: - return "ATOM_CARRIER_ROAMING_SATELLITE_CONTROLLER_STATS"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_REQUESTED: + return "ATOM_APEX_INSTALLATION_REQUESTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CONTROLLER_STATS_PER_PACKAGE: - return "ATOM_CONTROLLER_STATS_PER_PACKAGE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_STAGED: + return "ATOM_APEX_INSTALLATION_STAGED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_ENTITLEMENT: - return "ATOM_SATELLITE_ENTITLEMENT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INSTALLATION_ENDED: + return "ATOM_APEX_INSTALLATION_ENDED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_CONFIG_UPDATER: - return "ATOM_SATELLITE_CONFIG_UPDATER"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_BUTTON_PRESSED: + return "ATOM_AI_WALLPAPERS_BUTTON_PRESSED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_ACCESS_CONTROLLER: - return "ATOM_SATELLITE_ACCESS_CONTROLLER"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED: + return "ATOM_AI_WALLPAPERS_TEMPLATE_SELECTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_IDENTIFIER_DISCLOSED: - return "ATOM_CELLULAR_IDENTIFIER_DISCLOSED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_TERM_SELECTED: + return "ATOM_AI_WALLPAPERS_TERM_SELECTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED: - return "ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_WALLPAPER_SET: + return "ATOM_AI_WALLPAPERS_WALLPAPER_SET"; - case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED: - return "ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AI_WALLPAPERS_SESSION_SUMMARY: + return "ATOM_AI_WALLPAPERS_SESSION_SUMMARY"; - case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_DEVICE_INFO_REPORTED: - return "ATOM_THREADNETWORK_DEVICE_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_JSSCRIPTENGINE_LATENCY_REPORTED: + return "ATOM_JSSCRIPTENGINE_LATENCY_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_INTEGRITY_INFO_REPORTED: - return "ATOM_BOOT_INTEGRITY_INFO_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_API_CALLED: + return "ATOM_AD_SERVICES_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TV_LOW_POWER_STANDBY_POLICY: - return "ATOM_TV_LOW_POWER_STANDBY_POLICY"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED: + return "ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_EXTERNAL_TV_INPUT_EVENT: - return "ATOM_EXTERNAL_TV_INPUT_EVENT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED: + return "ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_UPROBESTATS_ATOM_REPORTED: - return "ATOM_TEST_UPROBESTATS_ATOM_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED: + return "ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_ACTIVITY_INFO: - return "ATOM_UWB_ACTIVITY_INFO"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED: + return "ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIATOR_UPDATED: - return "ATOM_MEDIATOR_UPDATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_FETCH_PROCESS_REPORTED: + return "ATOM_BACKGROUND_FETCH_PROCESS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER: - return "ATOM_SYSPROXY_BLUETOOTH_BYTES_TRANSFER"; + case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED: + return "ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SYSPROXY_CONNECTION_UPDATED: - return "ATOM_SYSPROXY_CONNECTION_UPDATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_BIDDING_PROCESS_REPORTED: + return "ATOM_RUN_AD_BIDDING_PROCESS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_COMPANION_CONNECTION_STATE: - return "ATOM_WEAR_COMPANION_CONNECTION_STATE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_SCORING_PROCESS_REPORTED: + return "ATOM_RUN_AD_SCORING_PROCESS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_ACTION_REPORTED: - return "ATOM_MEDIA_ACTION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_SELECTION_PROCESS_REPORTED: + return "ATOM_RUN_AD_SELECTION_PROCESS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CONTROLS_LAUNCHED: - return "ATOM_MEDIA_CONTROLS_LAUNCHED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED: + return "ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_SESSION_STATE_CHANGED: - return "ATOM_MEDIA_SESSION_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED: + return "ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY: - return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_API_LATENCY"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS: + return "ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE: - return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_SASS_DEVICE_UNAVAILABLE"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_GET_TOPICS_REPORTED: + return "ATOM_AD_SERVICES_GET_TOPICS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT: - return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FASTPAIR_API_TIMEOUT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED: + return "ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MODE_STATE_CHANGED: - return "ATOM_WEAR_MODE_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED: + return "ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_RENDERER_INITIALIZED: - return "ATOM_RENDERER_INITIALIZED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED: + return "ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEMA_VERSION_RECEIVED: - return "ATOM_SCHEMA_VERSION_RECEIVED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED: + return "ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_INSPECTED: - return "ATOM_LAYOUT_INSPECTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS: + return "ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_EXPRESSION_INSPECTED: - return "ATOM_LAYOUT_EXPRESSION_INSPECTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ERROR_REPORTED: + return "ATOM_AD_SERVICES_ERROR_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_LAYOUT_ANIMATIONS_INSPECTED: - return "ATOM_LAYOUT_ANIMATIONS_INSPECTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED: + return "ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_MATERIAL_COMPONENTS_INSPECTED: - return "ATOM_MATERIAL_COMPONENTS_INSPECTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION: + return "ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TILE_REQUESTED: - return "ATOM_TILE_REQUESTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION: + return "ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_STATE_RESPONSE_RECEIVED: - return "ATOM_STATE_RESPONSE_RECEIVED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_JOBS: + return "ATOM_AD_SERVICES_MEASUREMENT_JOBS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_TILE_RESPONSE_RECEIVED: - return "ATOM_TILE_RESPONSE_RECEIVED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT: + return "ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_INFLATION_FINISHED: - return "ATOM_INFLATION_FINISHED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_AD_ID_MATCH_FOR_DEBUG_KEYS: + return "ATOM_AD_SERVICES_MEASUREMENT_AD_ID_MATCH_FOR_DEBUG_KEYS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_INFLATION_FAILED: - return "ATOM_INFLATION_FAILED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_DATA_STORED: + return "ATOM_AD_SERVICES_ENROLLMENT_DATA_STORED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_IGNORED_INFLATION_FAILURES_REPORTED: - return "ATOM_IGNORED_INFLATION_FAILURES_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_FILE_DOWNLOADED: + return "ATOM_AD_SERVICES_ENROLLMENT_FILE_DOWNLOADED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_DRAWABLE_RENDERED: - return "ATOM_DRAWABLE_RENDERED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_MATCHED: + return "ATOM_AD_SERVICES_ENROLLMENT_MATCHED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_SYNC_REQUESTED: - return "ATOM_WEAR_TIME_SYNC_REQUESTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_CONSENT_MIGRATED: + return "ATOM_AD_SERVICES_CONSENT_MIGRATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_UPDATE_STARTED: - return "ATOM_WEAR_TIME_UPDATE_STARTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_FAILED: + return "ATOM_AD_SERVICES_ENROLLMENT_FAILED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED: - return "ATOM_WEAR_TIME_SYNC_ATTEMPT_COMPLETED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_CLICK_VERIFICATION: + return "ATOM_AD_SERVICES_MEASUREMENT_CLICK_VERIFICATION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_TIME_CHANGED: - return "ATOM_WEAR_TIME_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENCRYPTION_KEY_FETCHED: + return "ATOM_AD_SERVICES_ENCRYPTION_KEY_FETCHED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED: - return "ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENCRYPTION_KEY_DB_TRANSACTION_ENDED: + return "ATOM_AD_SERVICES_ENCRYPTION_KEY_DB_TRANSACTION_ENDED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED: - return "ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_DESTINATION_REGISTERED_BEACONS: + return "ATOM_DESTINATION_REGISTERED_BEACONS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED: - return "ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_REPORT_INTERACTION_API_CALLED: + return "ATOM_REPORT_INTERACTION_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WEAR_TIME_SESSION: - return "ATOM_WS_WEAR_TIME_SESSION"; + case ::perfetto::protos::pbzero::AtomId::ATOM_INTERACTION_REPORTING_TABLE_CLEARED: + return "ATOM_INTERACTION_REPORTING_TABLE_CLEARED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_INCOMING_CALL_ACTION_REPORTED: - return "ATOM_WS_INCOMING_CALL_ACTION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_MANIFEST_CONFIG_HELPER_CALLED: + return "ATOM_APP_MANIFEST_CONFIG_HELPER_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_DISCONNECTION_REPORTED: - return "ATOM_WS_CALL_DISCONNECTION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_FILTERING_PROCESS_JOIN_CA_REPORTED: + return "ATOM_AD_FILTERING_PROCESS_JOIN_CA_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_DURATION_REPORTED: - return "ATOM_WS_CALL_DURATION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_FILTERING_PROCESS_AD_SELECTION_REPORTED: + return "ATOM_AD_FILTERING_PROCESS_AD_SELECTION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED: - return "ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_COUNTER_HISTOGRAM_UPDATER_REPORTED: + return "ATOM_AD_COUNTER_HISTOGRAM_UPDATER_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_INTERACTION_REPORTED: - return "ATOM_WS_CALL_INTERACTION_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SIGNATURE_VERIFICATION: + return "ATOM_SIGNATURE_VERIFICATION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_ON_BODY_STATE_CHANGED: - return "ATOM_WS_ON_BODY_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_IMMEDIATE_SIGN_JOIN_STATUS_REPORTED: + return "ATOM_K_ANON_IMMEDIATE_SIGN_JOIN_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED: - return "ATOM_WS_WATCH_FACE_RESTRICTED_COMPLICATIONS_IMPACTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_BACKGROUND_JOB_STATUS_REPORTED: + return "ATOM_K_ANON_BACKGROUND_JOB_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED: - return "ATOM_WS_WATCH_FACE_DEFAULT_RESTRICTED_COMPLICATIONS_REMOVED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_INITIALIZE_STATUS_REPORTED: + return "ATOM_K_ANON_INITIALIZE_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED: - return "ATOM_WS_COMPLICATIONS_IMPACTED_NOTIFICATION_EVENT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_SIGN_STATUS_REPORTED: + return "ATOM_K_ANON_SIGN_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_REMOTE_EVENT_USAGE_REPORTED: - return "ATOM_WS_REMOTE_EVENT_USAGE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_JOIN_STATUS_REPORTED: + return "ATOM_K_ANON_JOIN_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_REQUESTED: - return "ATOM_WS_BUGREPORT_REQUESTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_K_ANON_KEY_ATTESTATION_STATUS_REPORTED: + return "ATOM_K_ANON_KEY_ATTESTATION_STATUS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_TRIGGERED: - return "ATOM_WS_BUGREPORT_TRIGGERED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_GET_AD_SELECTION_DATA_API_CALLED: + return "ATOM_GET_AD_SELECTION_DATA_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_FINISHED: - return "ATOM_WS_BUGREPORT_FINISHED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_GET_AD_SELECTION_DATA_BUYER_INPUT_GENERATED: + return "ATOM_GET_AD_SELECTION_DATA_BUYER_INPUT_GENERATED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BUGREPORT_RESULT_RECEIVED: - return "ATOM_WS_BUGREPORT_RESULT_RECEIVED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_JOB_SCHEDULING_REPORTED: + return "ATOM_BACKGROUND_JOB_SCHEDULING_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_STANDALONE_MODE_SNAPSHOT: - return "ATOM_WS_STANDALONE_MODE_SNAPSHOT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_ENCRYPTION_EPOCH_COMPUTATION_REPORTED: + return "ATOM_TOPICS_ENCRYPTION_EPOCH_COMPUTATION_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT: - return "ATOM_WS_FAVORITE_WATCH_FACE_SNAPSHOT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_ENCRYPTION_GET_TOPICS_REPORTED: + return "ATOM_TOPICS_ENCRYPTION_GET_TOPICS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT: - return "ATOM_WS_PHOTOS_WATCH_FACE_FEATURE_SNAPSHOT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ADSERVICES_SHELL_COMMAND_CALLED: + return "ATOM_ADSERVICES_SHELL_COMMAND_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT: - return "ATOM_WS_WATCH_FACE_CUSTOMIZATION_SNAPSHOT"; + case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_SIGNALS_API_CALLED: + return "ATOM_UPDATE_SIGNALS_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_MENU_OPENED: - return "ATOM_WEAR_POWER_MENU_OPENED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JOB_RUN: + return "ATOM_ENCODING_JOB_RUN"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_ASSISTANT_OPENED: - return "ATOM_WEAR_ASSISTANT_OPENED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JS_FETCH: + return "ATOM_ENCODING_JS_FETCH"; - case ::perfetto::protos::pbzero::AtomId::ATOM_FIRST_OVERLAY_STATE_CHANGED: - return "ATOM_FIRST_OVERLAY_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ENCODING_JS_EXECUTION: + return "ATOM_ENCODING_JS_EXECUTION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_NDP_REPORTED: - return "ATOM_WIFI_AWARE_NDP_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_PERSIST_AD_SELECTION_RESULT_CALLED: + return "ATOM_PERSIST_AD_SELECTION_RESULT_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_ATTACH_REPORTED: - return "ATOM_WIFI_AWARE_ATTACH_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SERVER_AUCTION_KEY_FETCH_CALLED: + return "ATOM_SERVER_AUCTION_KEY_FETCH_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SELF_RECOVERY_TRIGGERED: - return "ATOM_WIFI_SELF_RECOVERY_TRIGGERED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SERVER_AUCTION_BACKGROUND_KEY_FETCH_ENABLED: + return "ATOM_SERVER_AUCTION_BACKGROUND_KEY_FETCH_ENABLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STARTED: - return "ATOM_SOFT_AP_STARTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_PROCESS_ODP_REGISTRATION: + return "ATOM_AD_SERVICES_MEASUREMENT_PROCESS_ODP_REGISTRATION"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STOPPED: - return "ATOM_SOFT_AP_STOPPED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_NOTIFY_REGISTRATION_TO_ODP: + return "ATOM_AD_SERVICES_MEASUREMENT_NOTIFY_REGISTRATION_TO_ODP"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_RELEASED: - return "ATOM_WIFI_LOCK_RELEASED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SELECT_ADS_FROM_OUTCOMES_API_CALLED: + return "ATOM_SELECT_ADS_FROM_OUTCOMES_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_DEACTIVATED: - return "ATOM_WIFI_LOCK_DEACTIVATED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_REPORT_IMPRESSION_API_CALLED: + return "ATOM_REPORT_IMPRESSION_API_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONFIG_SAVED: - return "ATOM_WIFI_CONFIG_SAVED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ENROLLMENT_TRANSACTION_STATS: + return "ATOM_AD_SERVICES_ENROLLMENT_TRANSACTION_STATS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED: - return "ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_COBALT_LOGGER_EVENT_REPORTED: + return "ATOM_AD_SERVICES_COBALT_LOGGER_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_HAL_API_CALLED: - return "ATOM_WIFI_AWARE_HAL_API_CALLED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED: + return "ATOM_AD_SERVICES_COBALT_PERIODIC_JOB_EVENT_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED: - return "ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_SIGNALS_PROCESS_REPORTED: + return "ATOM_UPDATE_SIGNALS_PROCESS_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED: - return "ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED: + return "ATOM_TOPICS_SCHEDULE_EPOCH_JOB_SETTING_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_THREAD_TASK_EXECUTED: - return "ATOM_WIFI_THREAD_TASK_EXECUTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_SCHEDULE_ATTEMPTED: + return "ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_SCHEDULE_ATTEMPTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_STATE_CHANGED: - return "ATOM_WIFI_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_PERFORMED: + return "ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_PERFORMED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PNO_SCAN_STARTED: - return "ATOM_PNO_SCAN_STARTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_PERFORMED_ATTEMPTED_FAILURE_REPORTED: + return "ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_PERFORMED_ATTEMPTED_FAILURE_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_PNO_SCAN_STOPPED: - return "ATOM_PNO_SCAN_STOPPED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_BACKGROUND_JOB_RAN: + return "ATOM_SCHEDULED_CUSTOM_AUDIENCE_UPDATE_BACKGROUND_JOB_RAN"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_IS_UNUSABLE_REPORTED: - return "ATOM_WIFI_IS_UNUSABLE_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_STATUS_CALLED: + return "ATOM_THERMAL_STATUS_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AP_CAPABILITIES_REPORTED: - return "ATOM_WIFI_AP_CAPABILITIES_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_CALLED: + return "ATOM_THERMAL_HEADROOM_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STATE_CHANGED: - return "ATOM_SOFT_AP_STATE_CHANGED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED: + return "ATOM_THERMAL_HEADROOM_THRESHOLDS_CALLED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_SCORER_PREDICTION_RESULT_REPORTED: - return "ATOM_SCORER_PREDICTION_RESULT_REPORTED"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ADPF_HINT_SESSION_TID_CLEANUP: + return "ATOM_ADPF_HINT_SESSION_TID_CLEANUP"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_CAPABILITIES: - return "ATOM_WIFI_AWARE_CAPABILITIES"; + case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_HEADROOM_THRESHOLDS: + return "ATOM_THERMAL_HEADROOM_THRESHOLDS"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_MODULE_INFO: - return "ATOM_WIFI_MODULE_INFO"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ADPF_SESSION_SNAPSHOT: + return "ATOM_ADPF_SESSION_SNAPSHOT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SETTING_INFO: - return "ATOM_WIFI_SETTING_INFO"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED: + return "ATOM_ADAPTIVE_AUTH_UNLOCK_AFTER_LOCK_REPORTED"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_COMPLEX_SETTING_INFO: - return "ATOM_WIFI_COMPLEX_SETTING_INFO"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ACCOUNT_MANAGER_EVENT: + return "ATOM_ACCOUNT_MANAGER_EVENT"; - case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONFIGURED_NETWORK_INFO: - return "ATOM_WIFI_CONFIGURED_NETWORK_INFO"; + case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED: + return "ATOM_ACCESSIBILITY_CHECK_RESULT_REPORTED"; } return "PBZERO_UNKNOWN_ENUM_VALUE"; } @@ -65571,15 +65725,18 @@ namespace protos { namespace pbzero { class DataSourceConfig; class PriorityBoostConfig; +class TraceAttributes; class TraceConfig_AndroidReportConfig; class TraceConfig_BufferConfig; class TraceConfig_BuiltinDataSource; class TraceConfig_CmdTraceStartDelay; +class TraceConfig_CompressionConfig; +class TraceConfig_CompressionConfig_Deflate; +class TraceConfig_CompressionConfig_Zstd; class TraceConfig_DataSource; class TraceConfig_GuardrailOverrides; class TraceConfig_IncidentReportConfig; class TraceConfig_IncrementalStateConfig; -class TraceConfig_Note; class TraceConfig_ProducerConfig; class TraceConfig_SessionSemaphore; class TraceConfig_StatsdMetadata; @@ -65886,14 +66043,13 @@ namespace perfetto_pbzero_enum_TraceConfig_BufferConfig { enum ExperimentalMode : int32_t { MODE_UNSPECIFIED = 0, TRACE_BUFFER_V2 = 1, - TRACE_BUFFER_V2_SHADOW_MODE = 2, }; } // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig using TraceConfig_BufferConfig_ExperimentalMode = perfetto_pbzero_enum_TraceConfig_BufferConfig::ExperimentalMode; constexpr TraceConfig_BufferConfig_ExperimentalMode TraceConfig_BufferConfig_ExperimentalMode_MIN = TraceConfig_BufferConfig_ExperimentalMode::MODE_UNSPECIFIED; -constexpr TraceConfig_BufferConfig_ExperimentalMode TraceConfig_BufferConfig_ExperimentalMode_MAX = TraceConfig_BufferConfig_ExperimentalMode::TRACE_BUFFER_V2_SHADOW_MODE; +constexpr TraceConfig_BufferConfig_ExperimentalMode TraceConfig_BufferConfig_ExperimentalMode_MAX = TraceConfig_BufferConfig_ExperimentalMode::TRACE_BUFFER_V2; PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE @@ -65904,14 +66060,11 @@ const char* TraceConfig_BufferConfig_ExperimentalMode_Name(::perfetto::protos::p case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode::TRACE_BUFFER_V2: return "TRACE_BUFFER_V2"; - - case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode::TRACE_BUFFER_V2_SHADOW_MODE: - return "TRACE_BUFFER_V2_SHADOW_MODE"; } return "PBZERO_UNKNOWN_ENUM_VALUE"; } -class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder { public: TraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -65970,6 +66123,8 @@ class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder().as_string(); } bool has_compression_type() const { return at<24>().valid(); } int32_t compression_type() const { return at<24>().as_int32(); } + bool has_compression() const { return at<47>().valid(); } + ::protozero::ConstBytes compression() const { return at<47>().as_bytes(); } bool has_incident_report_config() const { return at<25>().valid(); } ::protozero::ConstBytes incident_report_config() const { return at<25>().as_bytes(); } bool has_statsd_logging() const { return at<31>().valid(); } @@ -65996,8 +66151,8 @@ class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder().as_int32(); } bool has_trace_all_machines() const { return at<43>().valid(); } bool trace_all_machines() const { return at<43>().as_bool(); } - bool has_notes() const { return at<46>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> notes() const { return GetRepeated<::protozero::ConstBytes>(46); } + bool has_trace_attributes() const { return at<48>().valid(); } + ::protozero::ConstBytes trace_attributes() const { return at<48>().as_bytes(); } }; class TraceConfig : public ::protozero::Message { @@ -66031,6 +66186,7 @@ class TraceConfig : public ::protozero::Message { kAllowUserBuildTracingFieldNumber = 19, kUniqueSessionNameFieldNumber = 22, kCompressionTypeFieldNumber = 24, + kCompressionFieldNumber = 47, kIncidentReportConfigFieldNumber = 25, kStatsdLoggingFieldNumber = 31, kTraceUuidMsbFieldNumber = 27, @@ -66044,7 +66200,7 @@ class TraceConfig : public ::protozero::Message { kWriteFlushModeFieldNumber = 44, kFflushPostWriteFieldNumber = 45, kTraceAllMachinesFieldNumber = 43, - kNotesFieldNumber = 46, + kTraceAttributesFieldNumber = 48, }; static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig"; } @@ -66056,12 +66212,12 @@ class TraceConfig : public ::protozero::Message { using GuardrailOverrides = ::perfetto::protos::pbzero::TraceConfig_GuardrailOverrides; using TriggerConfig = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig; using IncrementalStateConfig = ::perfetto::protos::pbzero::TraceConfig_IncrementalStateConfig; + using CompressionConfig = ::perfetto::protos::pbzero::TraceConfig_CompressionConfig; using IncidentReportConfig = ::perfetto::protos::pbzero::TraceConfig_IncidentReportConfig; using TraceFilter = ::perfetto::protos::pbzero::TraceConfig_TraceFilter; using AndroidReportConfig = ::perfetto::protos::pbzero::TraceConfig_AndroidReportConfig; using CmdTraceStartDelay = ::perfetto::protos::pbzero::TraceConfig_CmdTraceStartDelay; using SessionSemaphore = ::perfetto::protos::pbzero::TraceConfig_SessionSemaphore; - using Note = ::perfetto::protos::pbzero::TraceConfig_Note; using LockdownModeOperation = ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation; static inline const char* LockdownModeOperation_Name(LockdownModeOperation value) { @@ -66581,6 +66737,20 @@ class TraceConfig : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_Compression = + ::protozero::proto_utils::FieldMetadata< + 47, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_CompressionConfig, + TraceConfig>; + + static constexpr FieldMetadata_Compression kCompression{}; + template T* set_compression() { + return BeginNestedMessage(47); + } + + using FieldMetadata_IncidentReportConfig = ::protozero::proto_utils::FieldMetadata< 25, @@ -66791,89 +66961,19 @@ class TraceConfig : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_Notes = + using FieldMetadata_TraceAttributes = ::protozero::proto_utils::FieldMetadata< - 46, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + 48, + ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kMessage, - TraceConfig_Note, + TraceAttributes, TraceConfig>; - static constexpr FieldMetadata_Notes kNotes{}; - template T* add_notes() { - return BeginNestedMessage(46); - } - -}; - -class TraceConfig_Note_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_Note_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_Note_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_Note_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_key() const { return at<1>().valid(); } - ::protozero::ConstChars key() const { return at<1>().as_string(); } - bool has_value() const { return at<2>().valid(); } - ::protozero::ConstChars value() const { return at<2>().as_string(); } -}; - -class TraceConfig_Note : public ::protozero::Message { - public: - using Decoder = TraceConfig_Note_Decoder; - enum : int32_t { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.Note"; } - - - using FieldMetadata_Key = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_Note>; - - static constexpr FieldMetadata_Key kKey{}; - void set_key(const char* data, size_t size) { - AppendBytes(FieldMetadata_Key::kFieldId, data, size); - } - void set_key(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size); - } - void set_key(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_TraceAttributes kTraceAttributes{}; + template T* set_trace_attributes() { + return BeginNestedMessage(48); } - using FieldMetadata_Value = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_Note>; - - static constexpr FieldMetadata_Value kValue{}; - void set_value(const char* data, size_t size) { - AppendBytes(FieldMetadata_Value::kFieldId, data, size); - } - void set_value(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); - } - void set_value(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } }; class TraceConfig_SessionSemaphore_Decoder : public ::protozero::TypedProtoDecoder { @@ -67475,2803 +67575,364 @@ class TraceConfig_IncidentReportConfig : public ::protozero::Message { static constexpr uint32_t field_id = FieldMetadata_DestinationPackage::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DestinationClass = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_IncidentReportConfig>; - - static constexpr FieldMetadata_DestinationClass kDestinationClass{}; - void set_destination_class(const char* data, size_t size) { - AppendBytes(FieldMetadata_DestinationClass::kFieldId, data, size); - } - void set_destination_class(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_DestinationClass::kFieldId, chars.data, chars.size); - } - void set_destination_class(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_DestinationClass::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PrivacyLevel = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - TraceConfig_IncidentReportConfig>; - - static constexpr FieldMetadata_PrivacyLevel kPrivacyLevel{}; - void set_privacy_level(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_PrivacyLevel::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_SkipIncidentd = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_IncidentReportConfig>; - - static constexpr FieldMetadata_SkipIncidentd kSkipIncidentd{}; - void set_skip_incidentd(bool value) { - static constexpr uint32_t field_id = FieldMetadata_SkipIncidentd::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_SkipDropbox = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_IncidentReportConfig>; - - static constexpr FieldMetadata_SkipDropbox kSkipDropbox{}; - void set_skip_dropbox(bool value) { - static constexpr uint32_t field_id = FieldMetadata_SkipDropbox::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_IncrementalStateConfig_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_IncrementalStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_IncrementalStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_IncrementalStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_clear_period_ms() const { return at<1>().valid(); } - uint32_t clear_period_ms() const { return at<1>().as_uint32(); } -}; - -class TraceConfig_IncrementalStateConfig : public ::protozero::Message { - public: - using Decoder = TraceConfig_IncrementalStateConfig_Decoder; - enum : int32_t { - kClearPeriodMsFieldNumber = 1, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncrementalStateConfig"; } - - - using FieldMetadata_ClearPeriodMs = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_IncrementalStateConfig>; - - static constexpr FieldMetadata_ClearPeriodMs kClearPeriodMs{}; - void set_clear_period_ms(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ClearPeriodMs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_TriggerConfig_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_TriggerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_TriggerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_TriggerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_trigger_mode() const { return at<1>().valid(); } - int32_t trigger_mode() const { return at<1>().as_int32(); } - bool has_use_clone_snapshot_if_available() const { return at<5>().valid(); } - bool use_clone_snapshot_if_available() const { return at<5>().as_bool(); } - bool has_triggers() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> triggers() const { return GetRepeated<::protozero::ConstBytes>(2); } - bool has_trigger_timeout_ms() const { return at<3>().valid(); } - uint32_t trigger_timeout_ms() const { return at<3>().as_uint32(); } -}; - -class TraceConfig_TriggerConfig : public ::protozero::Message { - public: - using Decoder = TraceConfig_TriggerConfig_Decoder; - enum : int32_t { - kTriggerModeFieldNumber = 1, - kUseCloneSnapshotIfAvailableFieldNumber = 5, - kTriggersFieldNumber = 2, - kTriggerTimeoutMsFieldNumber = 3, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig"; } - - using Trigger = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_Trigger; - - using TriggerMode = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode; - static inline const char* TriggerMode_Name(TriggerMode value) { - return ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode_Name(value); - } - static inline const TriggerMode UNSPECIFIED = TriggerMode::UNSPECIFIED; - static inline const TriggerMode START_TRACING = TriggerMode::START_TRACING; - static inline const TriggerMode STOP_TRACING = TriggerMode::STOP_TRACING; - static inline const TriggerMode CLONE_SNAPSHOT = TriggerMode::CLONE_SNAPSHOT; - - using FieldMetadata_TriggerMode = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - TraceConfig_TriggerConfig_TriggerMode, - TraceConfig_TriggerConfig>; - - static constexpr FieldMetadata_TriggerMode kTriggerMode{}; - void set_trigger_mode(TraceConfig_TriggerConfig_TriggerMode value) { - static constexpr uint32_t field_id = FieldMetadata_TriggerMode::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_UseCloneSnapshotIfAvailable = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_TriggerConfig>; - - static constexpr FieldMetadata_UseCloneSnapshotIfAvailable kUseCloneSnapshotIfAvailable{}; - void set_use_clone_snapshot_if_available(bool value) { - static constexpr uint32_t field_id = FieldMetadata_UseCloneSnapshotIfAvailable::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Triggers = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TraceConfig_TriggerConfig_Trigger, - TraceConfig_TriggerConfig>; - - static constexpr FieldMetadata_Triggers kTriggers{}; - template T* add_triggers() { - return BeginNestedMessage(2); - } - - - using FieldMetadata_TriggerTimeoutMs = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_TriggerConfig>; - - static constexpr FieldMetadata_TriggerTimeoutMs kTriggerTimeoutMs{}; - void set_trigger_timeout_ms(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_TriggerTimeoutMs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_TriggerConfig_Trigger_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_TriggerConfig_Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_TriggerConfig_Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_TriggerConfig_Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_name() const { return at<1>().valid(); } - ::protozero::ConstChars name() const { return at<1>().as_string(); } - bool has_producer_name_regex() const { return at<2>().valid(); } - ::protozero::ConstChars producer_name_regex() const { return at<2>().as_string(); } - bool has_stop_delay_ms() const { return at<3>().valid(); } - uint32_t stop_delay_ms() const { return at<3>().as_uint32(); } - bool has_max_per_24_h() const { return at<4>().valid(); } - uint32_t max_per_24_h() const { return at<4>().as_uint32(); } - bool has_skip_probability() const { return at<5>().valid(); } - double skip_probability() const { return at<5>().as_double(); } -}; - -class TraceConfig_TriggerConfig_Trigger : public ::protozero::Message { - public: - using Decoder = TraceConfig_TriggerConfig_Trigger_Decoder; - enum : int32_t { - kNameFieldNumber = 1, - kProducerNameRegexFieldNumber = 2, - kStopDelayMsFieldNumber = 3, - kMaxPer24HFieldNumber = 4, - kSkipProbabilityFieldNumber = 5, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig.Trigger"; } - - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_TriggerConfig_Trigger>; - - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ProducerNameRegex = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_TriggerConfig_Trigger>; - - static constexpr FieldMetadata_ProducerNameRegex kProducerNameRegex{}; - void set_producer_name_regex(const char* data, size_t size) { - AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, data, size); - } - void set_producer_name_regex(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, chars.data, chars.size); - } - void set_producer_name_regex(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegex::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StopDelayMs = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_TriggerConfig_Trigger>; - - static constexpr FieldMetadata_StopDelayMs kStopDelayMs{}; - void set_stop_delay_ms(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MaxPer24H = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_TriggerConfig_Trigger>; - - static constexpr FieldMetadata_MaxPer24H kMaxPer24H{}; - void set_max_per_24_h(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_MaxPer24H::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_SkipProbability = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kDouble, - double, - TraceConfig_TriggerConfig_Trigger>; - - static constexpr FieldMetadata_SkipProbability kSkipProbability{}; - void set_skip_probability(double value) { - static constexpr uint32_t field_id = FieldMetadata_SkipProbability::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kDouble> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_GuardrailOverrides_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_GuardrailOverrides_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_GuardrailOverrides_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_GuardrailOverrides_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_max_upload_per_day_bytes() const { return at<1>().valid(); } - uint64_t max_upload_per_day_bytes() const { return at<1>().as_uint64(); } - bool has_max_tracing_buffer_size_kb() const { return at<2>().valid(); } - uint32_t max_tracing_buffer_size_kb() const { return at<2>().as_uint32(); } -}; - -class TraceConfig_GuardrailOverrides : public ::protozero::Message { - public: - using Decoder = TraceConfig_GuardrailOverrides_Decoder; - enum : int32_t { - kMaxUploadPerDayBytesFieldNumber = 1, - kMaxTracingBufferSizeKbFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.GuardrailOverrides"; } - - - using FieldMetadata_MaxUploadPerDayBytes = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TraceConfig_GuardrailOverrides>; - - static constexpr FieldMetadata_MaxUploadPerDayBytes kMaxUploadPerDayBytes{}; - void set_max_upload_per_day_bytes(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_MaxUploadPerDayBytes::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MaxTracingBufferSizeKb = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_GuardrailOverrides>; - - static constexpr FieldMetadata_MaxTracingBufferSizeKb kMaxTracingBufferSizeKb{}; - void set_max_tracing_buffer_size_kb(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_MaxTracingBufferSizeKb::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_StatsdMetadata_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_StatsdMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_StatsdMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_StatsdMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_triggering_alert_id() const { return at<1>().valid(); } - int64_t triggering_alert_id() const { return at<1>().as_int64(); } - bool has_triggering_config_uid() const { return at<2>().valid(); } - int32_t triggering_config_uid() const { return at<2>().as_int32(); } - bool has_triggering_config_id() const { return at<3>().valid(); } - int64_t triggering_config_id() const { return at<3>().as_int64(); } - bool has_triggering_subscription_id() const { return at<4>().valid(); } - int64_t triggering_subscription_id() const { return at<4>().as_int64(); } -}; - -class TraceConfig_StatsdMetadata : public ::protozero::Message { - public: - using Decoder = TraceConfig_StatsdMetadata_Decoder; - enum : int32_t { - kTriggeringAlertIdFieldNumber = 1, - kTriggeringConfigUidFieldNumber = 2, - kTriggeringConfigIdFieldNumber = 3, - kTriggeringSubscriptionIdFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.StatsdMetadata"; } - - - using FieldMetadata_TriggeringAlertId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TraceConfig_StatsdMetadata>; - - static constexpr FieldMetadata_TriggeringAlertId kTriggeringAlertId{}; - void set_triggering_alert_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_TriggeringAlertId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TriggeringConfigUid = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - TraceConfig_StatsdMetadata>; - - static constexpr FieldMetadata_TriggeringConfigUid kTriggeringConfigUid{}; - void set_triggering_config_uid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigUid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TriggeringConfigId = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TraceConfig_StatsdMetadata>; - - static constexpr FieldMetadata_TriggeringConfigId kTriggeringConfigId{}; - void set_triggering_config_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TriggeringSubscriptionId = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TraceConfig_StatsdMetadata>; - - static constexpr FieldMetadata_TriggeringSubscriptionId kTriggeringSubscriptionId{}; - void set_triggering_subscription_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_TriggeringSubscriptionId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_ProducerConfig_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_ProducerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_ProducerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_ProducerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_producer_name() const { return at<1>().valid(); } - ::protozero::ConstChars producer_name() const { return at<1>().as_string(); } - bool has_shm_size_kb() const { return at<2>().valid(); } - uint32_t shm_size_kb() const { return at<2>().as_uint32(); } - bool has_page_size_kb() const { return at<3>().valid(); } - uint32_t page_size_kb() const { return at<3>().as_uint32(); } -}; - -class TraceConfig_ProducerConfig : public ::protozero::Message { - public: - using Decoder = TraceConfig_ProducerConfig_Decoder; - enum : int32_t { - kProducerNameFieldNumber = 1, - kShmSizeKbFieldNumber = 2, - kPageSizeKbFieldNumber = 3, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.ProducerConfig"; } - - - using FieldMetadata_ProducerName = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_ProducerConfig>; - - static constexpr FieldMetadata_ProducerName kProducerName{}; - void set_producer_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size); - } - void set_producer_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size); - } - void set_producer_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ShmSizeKb = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_ProducerConfig>; - - static constexpr FieldMetadata_ShmSizeKb kShmSizeKb{}; - void set_shm_size_kb(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ShmSizeKb::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PageSizeKb = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_ProducerConfig>; - - static constexpr FieldMetadata_PageSizeKb kPageSizeKb{}; - void set_page_size_kb(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_PageSizeKb::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_BuiltinDataSource_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_BuiltinDataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_BuiltinDataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_BuiltinDataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_disable_clock_snapshotting() const { return at<1>().valid(); } - bool disable_clock_snapshotting() const { return at<1>().as_bool(); } - bool has_disable_trace_config() const { return at<2>().valid(); } - bool disable_trace_config() const { return at<2>().as_bool(); } - bool has_disable_system_info() const { return at<3>().valid(); } - bool disable_system_info() const { return at<3>().as_bool(); } - bool has_disable_service_events() const { return at<4>().valid(); } - bool disable_service_events() const { return at<4>().as_bool(); } - bool has_primary_trace_clock() const { return at<5>().valid(); } - int32_t primary_trace_clock() const { return at<5>().as_int32(); } - bool has_snapshot_interval_ms() const { return at<6>().valid(); } - uint32_t snapshot_interval_ms() const { return at<6>().as_uint32(); } - bool has_prefer_suspend_clock_for_snapshot() const { return at<7>().valid(); } - bool prefer_suspend_clock_for_snapshot() const { return at<7>().as_bool(); } - bool has_disable_chunk_usage_histograms() const { return at<8>().valid(); } - bool disable_chunk_usage_histograms() const { return at<8>().as_bool(); } - bool has_disable_extension_descriptors() const { return at<9>().valid(); } - bool disable_extension_descriptors() const { return at<9>().as_bool(); } -}; - -class TraceConfig_BuiltinDataSource : public ::protozero::Message { - public: - using Decoder = TraceConfig_BuiltinDataSource_Decoder; - enum : int32_t { - kDisableClockSnapshottingFieldNumber = 1, - kDisableTraceConfigFieldNumber = 2, - kDisableSystemInfoFieldNumber = 3, - kDisableServiceEventsFieldNumber = 4, - kPrimaryTraceClockFieldNumber = 5, - kSnapshotIntervalMsFieldNumber = 6, - kPreferSuspendClockForSnapshotFieldNumber = 7, - kDisableChunkUsageHistogramsFieldNumber = 8, - kDisableExtensionDescriptorsFieldNumber = 9, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BuiltinDataSource"; } - - - using FieldMetadata_DisableClockSnapshotting = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_DisableClockSnapshotting kDisableClockSnapshotting{}; - void set_disable_clock_snapshotting(bool value) { - static constexpr uint32_t field_id = FieldMetadata_DisableClockSnapshotting::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisableTraceConfig = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_DisableTraceConfig kDisableTraceConfig{}; - void set_disable_trace_config(bool value) { - static constexpr uint32_t field_id = FieldMetadata_DisableTraceConfig::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisableSystemInfo = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_DisableSystemInfo kDisableSystemInfo{}; - void set_disable_system_info(bool value) { - static constexpr uint32_t field_id = FieldMetadata_DisableSystemInfo::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisableServiceEvents = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_DisableServiceEvents kDisableServiceEvents{}; - void set_disable_service_events(bool value) { - static constexpr uint32_t field_id = FieldMetadata_DisableServiceEvents::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PrimaryTraceClock = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - BuiltinClock, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock{}; - void set_primary_trace_clock(BuiltinClock value) { - static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_SnapshotIntervalMs = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_SnapshotIntervalMs kSnapshotIntervalMs{}; - void set_snapshot_interval_ms(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_SnapshotIntervalMs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PreferSuspendClockForSnapshot = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_PreferSuspendClockForSnapshot kPreferSuspendClockForSnapshot{}; - void set_prefer_suspend_clock_for_snapshot(bool value) { - static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForSnapshot::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisableChunkUsageHistograms = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_DisableChunkUsageHistograms kDisableChunkUsageHistograms{}; - void set_disable_chunk_usage_histograms(bool value) { - static constexpr uint32_t field_id = FieldMetadata_DisableChunkUsageHistograms::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisableExtensionDescriptors = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BuiltinDataSource>; - - static constexpr FieldMetadata_DisableExtensionDescriptors kDisableExtensionDescriptors{}; - void set_disable_extension_descriptors(bool value) { - static constexpr uint32_t field_id = FieldMetadata_DisableExtensionDescriptors::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_DataSource_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_DataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_config() const { return at<1>().valid(); } - ::protozero::ConstBytes config() const { return at<1>().as_bytes(); } - bool has_producer_name_filter() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_filter() const { return GetRepeated<::protozero::ConstChars>(2); } - bool has_producer_name_regex_filter() const { return at<3>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_regex_filter() const { return GetRepeated<::protozero::ConstChars>(3); } - bool has_machine_name_filter() const { return at<4>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstChars> machine_name_filter() const { return GetRepeated<::protozero::ConstChars>(4); } -}; - -class TraceConfig_DataSource : public ::protozero::Message { - public: - using Decoder = TraceConfig_DataSource_Decoder; - enum : int32_t { - kConfigFieldNumber = 1, - kProducerNameFilterFieldNumber = 2, - kProducerNameRegexFilterFieldNumber = 3, - kMachineNameFilterFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.DataSource"; } - - - using FieldMetadata_Config = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - DataSourceConfig, - TraceConfig_DataSource>; - - static constexpr FieldMetadata_Config kConfig{}; - template T* set_config() { - return BeginNestedMessage(1); - } - - - using FieldMetadata_ProducerNameFilter = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_DataSource>; - - static constexpr FieldMetadata_ProducerNameFilter kProducerNameFilter{}; - void add_producer_name_filter(const char* data, size_t size) { - AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, data, size); - } - void add_producer_name_filter(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, chars.data, chars.size); - } - void add_producer_name_filter(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_ProducerNameFilter::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ProducerNameRegexFilter = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_DataSource>; - - static constexpr FieldMetadata_ProducerNameRegexFilter kProducerNameRegexFilter{}; - void add_producer_name_regex_filter(const char* data, size_t size) { - AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, data, size); - } - void add_producer_name_regex_filter(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, chars.data, chars.size); - } - void add_producer_name_regex_filter(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegexFilter::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MachineNameFilter = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_DataSource>; - - static constexpr FieldMetadata_MachineNameFilter kMachineNameFilter{}; - void add_machine_name_filter(const char* data, size_t size) { - AppendBytes(FieldMetadata_MachineNameFilter::kFieldId, data, size); - } - void add_machine_name_filter(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_MachineNameFilter::kFieldId, chars.data, chars.size); - } - void add_machine_name_filter(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_MachineNameFilter::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } -}; - -class TraceConfig_BufferConfig_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceConfig_BufferConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceConfig_BufferConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceConfig_BufferConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_size_kb() const { return at<1>().valid(); } - uint32_t size_kb() const { return at<1>().as_uint32(); } - bool has_fill_policy() const { return at<4>().valid(); } - int32_t fill_policy() const { return at<4>().as_int32(); } - bool has_transfer_on_clone() const { return at<5>().valid(); } - bool transfer_on_clone() const { return at<5>().as_bool(); } - bool has_clear_before_clone() const { return at<6>().valid(); } - bool clear_before_clone() const { return at<6>().as_bool(); } - bool has_name() const { return at<7>().valid(); } - ::protozero::ConstChars name() const { return at<7>().as_string(); } - bool has_experimental_mode() const { return at<8>().valid(); } - int32_t experimental_mode() const { return at<8>().as_int32(); } -}; - -class TraceConfig_BufferConfig : public ::protozero::Message { - public: - using Decoder = TraceConfig_BufferConfig_Decoder; - enum : int32_t { - kSizeKbFieldNumber = 1, - kFillPolicyFieldNumber = 4, - kTransferOnCloneFieldNumber = 5, - kClearBeforeCloneFieldNumber = 6, - kNameFieldNumber = 7, - kExperimentalModeFieldNumber = 8, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BufferConfig"; } - - - using FillPolicy = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy; - static inline const char* FillPolicy_Name(FillPolicy value) { - return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy_Name(value); - } - - using ExperimentalMode = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode; - static inline const char* ExperimentalMode_Name(ExperimentalMode value) { - return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode_Name(value); - } - static inline const FillPolicy UNSPECIFIED = FillPolicy::UNSPECIFIED; - static inline const FillPolicy RING_BUFFER = FillPolicy::RING_BUFFER; - static inline const FillPolicy DISCARD = FillPolicy::DISCARD; - static inline const ExperimentalMode MODE_UNSPECIFIED = ExperimentalMode::MODE_UNSPECIFIED; - static inline const ExperimentalMode TRACE_BUFFER_V2 = ExperimentalMode::TRACE_BUFFER_V2; - static inline const ExperimentalMode TRACE_BUFFER_V2_SHADOW_MODE = ExperimentalMode::TRACE_BUFFER_V2_SHADOW_MODE; - - using FieldMetadata_SizeKb = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TraceConfig_BufferConfig>; - - static constexpr FieldMetadata_SizeKb kSizeKb{}; - void set_size_kb(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FillPolicy = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - TraceConfig_BufferConfig_FillPolicy, - TraceConfig_BufferConfig>; - - static constexpr FieldMetadata_FillPolicy kFillPolicy{}; - void set_fill_policy(TraceConfig_BufferConfig_FillPolicy value) { - static constexpr uint32_t field_id = FieldMetadata_FillPolicy::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TransferOnClone = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BufferConfig>; - - static constexpr FieldMetadata_TransferOnClone kTransferOnClone{}; - void set_transfer_on_clone(bool value) { - static constexpr uint32_t field_id = FieldMetadata_TransferOnClone::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ClearBeforeClone = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TraceConfig_BufferConfig>; - - static constexpr FieldMetadata_ClearBeforeClone kClearBeforeClone{}; - void set_clear_before_clone(bool value) { - static constexpr uint32_t field_id = FieldMetadata_ClearBeforeClone::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - TraceConfig_BufferConfig>; - - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ExperimentalMode = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - TraceConfig_BufferConfig_ExperimentalMode, - TraceConfig_BufferConfig>; - - static constexpr FieldMetadata_ExperimentalMode kExperimentalMode{}; - void set_experimental_mode(TraceConfig_BufferConfig_ExperimentalMode value) { - static constexpr uint32_t field_id = FieldMetadata_ExperimentalMode::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/clock_snapshot.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class ClockSnapshot_Clock; -enum BuiltinClock : int32_t; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -namespace perfetto_pbzero_enum_ClockSnapshot_Clock { -enum BuiltinClocks : int32_t { - UNKNOWN = 0, - REALTIME = 1, - REALTIME_COARSE = 2, - MONOTONIC = 3, - MONOTONIC_COARSE = 4, - MONOTONIC_RAW = 5, - BOOTTIME = 6, - BUILTIN_CLOCK_MAX_ID = 63, -}; -} // namespace perfetto_pbzero_enum_ClockSnapshot_Clock -using ClockSnapshot_Clock_BuiltinClocks = perfetto_pbzero_enum_ClockSnapshot_Clock::BuiltinClocks; - - -constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MIN = ClockSnapshot_Clock_BuiltinClocks::UNKNOWN; -constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MAX = ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* ClockSnapshot_Clock_BuiltinClocks_Name(::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks value) { - switch (value) { - case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::UNKNOWN: - return "UNKNOWN"; - - case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME: - return "REALTIME"; - - case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME_COARSE: - return "REALTIME_COARSE"; - - case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC: - return "MONOTONIC"; - - case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_COARSE: - return "MONOTONIC_COARSE"; - - case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_RAW: - return "MONOTONIC_RAW"; - - case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BOOTTIME: - return "BOOTTIME"; - - case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID: - return "BUILTIN_CLOCK_MAX_ID"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -class ClockSnapshot_Decoder : public ::protozero::TypedProtoDecoder { - public: - ClockSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ClockSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ClockSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_clocks() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> clocks() const { return GetRepeated<::protozero::ConstBytes>(1); } - bool has_primary_trace_clock() const { return at<2>().valid(); } - int32_t primary_trace_clock() const { return at<2>().as_int32(); } -}; - -class ClockSnapshot : public ::protozero::Message { - public: - using Decoder = ClockSnapshot_Decoder; - enum : int32_t { - kClocksFieldNumber = 1, - kPrimaryTraceClockFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot"; } - - using Clock = ::perfetto::protos::pbzero::ClockSnapshot_Clock; - - using FieldMetadata_Clocks = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ClockSnapshot_Clock, - ClockSnapshot>; - - static constexpr FieldMetadata_Clocks kClocks{}; - template T* add_clocks() { - return BeginNestedMessage(1); - } - - - using FieldMetadata_PrimaryTraceClock = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - BuiltinClock, - ClockSnapshot>; - - static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock{}; - void set_primary_trace_clock(BuiltinClock value) { - static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } -}; - -class ClockSnapshot_Clock_Decoder : public ::protozero::TypedProtoDecoder { - public: - ClockSnapshot_Clock_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ClockSnapshot_Clock_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ClockSnapshot_Clock_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_clock_id() const { return at<1>().valid(); } - uint32_t clock_id() const { return at<1>().as_uint32(); } - bool has_timestamp() const { return at<2>().valid(); } - uint64_t timestamp() const { return at<2>().as_uint64(); } - bool has_is_incremental() const { return at<3>().valid(); } - bool is_incremental() const { return at<3>().as_bool(); } - bool has_unit_multiplier_ns() const { return at<4>().valid(); } - uint64_t unit_multiplier_ns() const { return at<4>().as_uint64(); } -}; - -class ClockSnapshot_Clock : public ::protozero::Message { - public: - using Decoder = ClockSnapshot_Clock_Decoder; - enum : int32_t { - kClockIdFieldNumber = 1, - kTimestampFieldNumber = 2, - kIsIncrementalFieldNumber = 3, - kUnitMultiplierNsFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot.Clock"; } - - - using BuiltinClocks = ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks; - static inline const char* BuiltinClocks_Name(BuiltinClocks value) { - return ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks_Name(value); - } - static inline const BuiltinClocks UNKNOWN = BuiltinClocks::UNKNOWN; - static inline const BuiltinClocks REALTIME = BuiltinClocks::REALTIME; - static inline const BuiltinClocks REALTIME_COARSE = BuiltinClocks::REALTIME_COARSE; - static inline const BuiltinClocks MONOTONIC = BuiltinClocks::MONOTONIC; - static inline const BuiltinClocks MONOTONIC_COARSE = BuiltinClocks::MONOTONIC_COARSE; - static inline const BuiltinClocks MONOTONIC_RAW = BuiltinClocks::MONOTONIC_RAW; - static inline const BuiltinClocks BOOTTIME = BuiltinClocks::BOOTTIME; - static inline const BuiltinClocks BUILTIN_CLOCK_MAX_ID = BuiltinClocks::BUILTIN_CLOCK_MAX_ID; - - using FieldMetadata_ClockId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - ClockSnapshot_Clock>; - - static constexpr FieldMetadata_ClockId kClockId{}; - void set_clock_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ClockId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Timestamp = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - ClockSnapshot_Clock>; - - static constexpr FieldMetadata_Timestamp kTimestamp{}; - void set_timestamp(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_IsIncremental = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - ClockSnapshot_Clock>; - - static constexpr FieldMetadata_IsIncremental kIsIncremental{}; - void set_is_incremental(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_UnitMultiplierNs = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - ClockSnapshot_Clock>; - - static constexpr FieldMetadata_UnitMultiplierNs kUnitMultiplierNs{}; - void set_unit_multiplier_ns(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_UnitMultiplierNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_uuid.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - - -namespace perfetto { -namespace protos { -namespace pbzero { - -class TraceUuid_Decoder : public ::protozero::TypedProtoDecoder { - public: - TraceUuid_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TraceUuid_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TraceUuid_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_msb() const { return at<1>().valid(); } - int64_t msb() const { return at<1>().as_int64(); } - bool has_lsb() const { return at<2>().valid(); } - int64_t lsb() const { return at<2>().as_int64(); } -}; - -class TraceUuid : public ::protozero::Message { - public: - using Decoder = TraceUuid_Decoder; - enum : int32_t { - kMsbFieldNumber = 1, - kLsbFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TraceUuid"; } - - - using FieldMetadata_Msb = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TraceUuid>; - - static constexpr FieldMetadata_Msb kMsb{}; - void set_msb(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Msb::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Lsb = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TraceUuid>; - - static constexpr FieldMetadata_Lsb kLsb{}; - void set_lsb(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Lsb::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/trigger.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - - -namespace perfetto { -namespace protos { -namespace pbzero { - -class Trigger_Decoder : public ::protozero::TypedProtoDecoder { - public: - Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_trigger_name() const { return at<1>().valid(); } - ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); } - bool has_producer_name() const { return at<2>().valid(); } - ::protozero::ConstChars producer_name() const { return at<2>().as_string(); } - bool has_trusted_producer_uid() const { return at<3>().valid(); } - int32_t trusted_producer_uid() const { return at<3>().as_int32(); } - bool has_stop_delay_ms() const { return at<4>().valid(); } - uint64_t stop_delay_ms() const { return at<4>().as_uint64(); } -}; - -class Trigger : public ::protozero::Message { - public: - using Decoder = Trigger_Decoder; - enum : int32_t { - kTriggerNameFieldNumber = 1, - kProducerNameFieldNumber = 2, - kTrustedProducerUidFieldNumber = 3, - kStopDelayMsFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.Trigger"; } - - - using FieldMetadata_TriggerName = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - Trigger>; - - static constexpr FieldMetadata_TriggerName kTriggerName{}; - void set_trigger_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size); - } - void set_trigger_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size); - } - void set_trigger_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ProducerName = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - Trigger>; - - static constexpr FieldMetadata_ProducerName kProducerName{}; - void set_producer_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size); - } - void set_producer_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size); - } - void set_producer_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TrustedProducerUid = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - Trigger>; - - static constexpr FieldMetadata_TrustedProducerUid kTrustedProducerUid{}; - void set_trusted_producer_uid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_TrustedProducerUid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StopDelayMs = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - Trigger>; - - static constexpr FieldMetadata_StopDelayMs kStopDelayMs{}; - void set_stop_delay_ms(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_aflags.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_AFLAGS_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_AFLAGS_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class AndroidAflags_Flag; -namespace perfetto_pbzero_enum_AndroidAflags { -enum FlagPermission : int32_t; -} // namespace perfetto_pbzero_enum_AndroidAflags -using AndroidAflags_FlagPermission = perfetto_pbzero_enum_AndroidAflags::FlagPermission; -namespace perfetto_pbzero_enum_AndroidAflags { -enum FlagStorageBackend : int32_t; -} // namespace perfetto_pbzero_enum_AndroidAflags -using AndroidAflags_FlagStorageBackend = perfetto_pbzero_enum_AndroidAflags::FlagStorageBackend; -namespace perfetto_pbzero_enum_AndroidAflags { -enum FlagType : int32_t; -} // namespace perfetto_pbzero_enum_AndroidAflags -using AndroidAflags_FlagType = perfetto_pbzero_enum_AndroidAflags::FlagType; -namespace perfetto_pbzero_enum_AndroidAflags { -enum ValuePickedFrom : int32_t; -} // namespace perfetto_pbzero_enum_AndroidAflags -using AndroidAflags_ValuePickedFrom = perfetto_pbzero_enum_AndroidAflags::ValuePickedFrom; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -namespace perfetto_pbzero_enum_AndroidAflags { -enum FlagPermission : int32_t { - FLAG_PERMISSION_UNSPECIFIED = 0, - FLAG_PERMISSION_READ_ONLY = 1, - FLAG_PERMISSION_READ_WRITE = 2, -}; -} // namespace perfetto_pbzero_enum_AndroidAflags -using AndroidAflags_FlagPermission = perfetto_pbzero_enum_AndroidAflags::FlagPermission; - - -constexpr AndroidAflags_FlagPermission AndroidAflags_FlagPermission_MIN = AndroidAflags_FlagPermission::FLAG_PERMISSION_UNSPECIFIED; -constexpr AndroidAflags_FlagPermission AndroidAflags_FlagPermission_MAX = AndroidAflags_FlagPermission::FLAG_PERMISSION_READ_WRITE; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* AndroidAflags_FlagPermission_Name(::perfetto::protos::pbzero::AndroidAflags_FlagPermission value) { - switch (value) { - case ::perfetto::protos::pbzero::AndroidAflags_FlagPermission::FLAG_PERMISSION_UNSPECIFIED: - return "FLAG_PERMISSION_UNSPECIFIED"; - - case ::perfetto::protos::pbzero::AndroidAflags_FlagPermission::FLAG_PERMISSION_READ_ONLY: - return "FLAG_PERMISSION_READ_ONLY"; - - case ::perfetto::protos::pbzero::AndroidAflags_FlagPermission::FLAG_PERMISSION_READ_WRITE: - return "FLAG_PERMISSION_READ_WRITE"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_AndroidAflags { -enum ValuePickedFrom : int32_t { - VALUE_PICKED_FROM_UNSPECIFIED = 0, - VALUE_PICKED_FROM_DEFAULT = 1, - VALUE_PICKED_FROM_SERVER = 2, - VALUE_PICKED_FROM_LOCAL = 3, -}; -} // namespace perfetto_pbzero_enum_AndroidAflags -using AndroidAflags_ValuePickedFrom = perfetto_pbzero_enum_AndroidAflags::ValuePickedFrom; - - -constexpr AndroidAflags_ValuePickedFrom AndroidAflags_ValuePickedFrom_MIN = AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_UNSPECIFIED; -constexpr AndroidAflags_ValuePickedFrom AndroidAflags_ValuePickedFrom_MAX = AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_LOCAL; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* AndroidAflags_ValuePickedFrom_Name(::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom value) { - switch (value) { - case ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_UNSPECIFIED: - return "VALUE_PICKED_FROM_UNSPECIFIED"; - - case ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_DEFAULT: - return "VALUE_PICKED_FROM_DEFAULT"; - - case ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_SERVER: - return "VALUE_PICKED_FROM_SERVER"; - - case ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_LOCAL: - return "VALUE_PICKED_FROM_LOCAL"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_AndroidAflags { -enum FlagStorageBackend : int32_t { - FLAG_STORAGE_BACKEND_UNSPECIFIED = 0, - FLAG_STORAGE_BACKEND_NONE = 1, - FLAG_STORAGE_BACKEND_ACONFIGD = 2, - FLAG_STORAGE_BACKEND_DEVICE_CONFIG = 3, -}; -} // namespace perfetto_pbzero_enum_AndroidAflags -using AndroidAflags_FlagStorageBackend = perfetto_pbzero_enum_AndroidAflags::FlagStorageBackend; - - -constexpr AndroidAflags_FlagStorageBackend AndroidAflags_FlagStorageBackend_MIN = AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_UNSPECIFIED; -constexpr AndroidAflags_FlagStorageBackend AndroidAflags_FlagStorageBackend_MAX = AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_DEVICE_CONFIG; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* AndroidAflags_FlagStorageBackend_Name(::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend value) { - switch (value) { - case ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_UNSPECIFIED: - return "FLAG_STORAGE_BACKEND_UNSPECIFIED"; - - case ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_NONE: - return "FLAG_STORAGE_BACKEND_NONE"; - - case ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_ACONFIGD: - return "FLAG_STORAGE_BACKEND_ACONFIGD"; - - case ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_DEVICE_CONFIG: - return "FLAG_STORAGE_BACKEND_DEVICE_CONFIG"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_AndroidAflags { -enum FlagType : int32_t { - FLAG_TYPE_UNSPECIFIED = 0, - FLAG_TYPE_BOOLEAN = 1, - FLAG_TYPE_INTEGER = 2, -}; -} // namespace perfetto_pbzero_enum_AndroidAflags -using AndroidAflags_FlagType = perfetto_pbzero_enum_AndroidAflags::FlagType; - - -constexpr AndroidAflags_FlagType AndroidAflags_FlagType_MIN = AndroidAflags_FlagType::FLAG_TYPE_UNSPECIFIED; -constexpr AndroidAflags_FlagType AndroidAflags_FlagType_MAX = AndroidAflags_FlagType::FLAG_TYPE_INTEGER; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* AndroidAflags_FlagType_Name(::perfetto::protos::pbzero::AndroidAflags_FlagType value) { - switch (value) { - case ::perfetto::protos::pbzero::AndroidAflags_FlagType::FLAG_TYPE_UNSPECIFIED: - return "FLAG_TYPE_UNSPECIFIED"; - - case ::perfetto::protos::pbzero::AndroidAflags_FlagType::FLAG_TYPE_BOOLEAN: - return "FLAG_TYPE_BOOLEAN"; - - case ::perfetto::protos::pbzero::AndroidAflags_FlagType::FLAG_TYPE_INTEGER: - return "FLAG_TYPE_INTEGER"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -class AndroidAflags_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidAflags_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidAflags_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidAflags_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_flags() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> flags() const { return GetRepeated<::protozero::ConstBytes>(1); } - bool has_error() const { return at<2>().valid(); } - ::protozero::ConstChars error() const { return at<2>().as_string(); } -}; - -class AndroidAflags : public ::protozero::Message { - public: - using Decoder = AndroidAflags_Decoder; - enum : int32_t { - kFlagsFieldNumber = 1, - kErrorFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidAflags"; } - - using Flag = ::perfetto::protos::pbzero::AndroidAflags_Flag; - - using FlagPermission = ::perfetto::protos::pbzero::AndroidAflags_FlagPermission; - static inline const char* FlagPermission_Name(FlagPermission value) { - return ::perfetto::protos::pbzero::AndroidAflags_FlagPermission_Name(value); - } - - using ValuePickedFrom = ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom; - static inline const char* ValuePickedFrom_Name(ValuePickedFrom value) { - return ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom_Name(value); - } - - using FlagStorageBackend = ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend; - static inline const char* FlagStorageBackend_Name(FlagStorageBackend value) { - return ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend_Name(value); - } - - using FlagType = ::perfetto::protos::pbzero::AndroidAflags_FlagType; - static inline const char* FlagType_Name(FlagType value) { - return ::perfetto::protos::pbzero::AndroidAflags_FlagType_Name(value); - } - static inline const FlagPermission FLAG_PERMISSION_UNSPECIFIED = FlagPermission::FLAG_PERMISSION_UNSPECIFIED; - static inline const FlagPermission FLAG_PERMISSION_READ_ONLY = FlagPermission::FLAG_PERMISSION_READ_ONLY; - static inline const FlagPermission FLAG_PERMISSION_READ_WRITE = FlagPermission::FLAG_PERMISSION_READ_WRITE; - static inline const ValuePickedFrom VALUE_PICKED_FROM_UNSPECIFIED = ValuePickedFrom::VALUE_PICKED_FROM_UNSPECIFIED; - static inline const ValuePickedFrom VALUE_PICKED_FROM_DEFAULT = ValuePickedFrom::VALUE_PICKED_FROM_DEFAULT; - static inline const ValuePickedFrom VALUE_PICKED_FROM_SERVER = ValuePickedFrom::VALUE_PICKED_FROM_SERVER; - static inline const ValuePickedFrom VALUE_PICKED_FROM_LOCAL = ValuePickedFrom::VALUE_PICKED_FROM_LOCAL; - static inline const FlagStorageBackend FLAG_STORAGE_BACKEND_UNSPECIFIED = FlagStorageBackend::FLAG_STORAGE_BACKEND_UNSPECIFIED; - static inline const FlagStorageBackend FLAG_STORAGE_BACKEND_NONE = FlagStorageBackend::FLAG_STORAGE_BACKEND_NONE; - static inline const FlagStorageBackend FLAG_STORAGE_BACKEND_ACONFIGD = FlagStorageBackend::FLAG_STORAGE_BACKEND_ACONFIGD; - static inline const FlagStorageBackend FLAG_STORAGE_BACKEND_DEVICE_CONFIG = FlagStorageBackend::FLAG_STORAGE_BACKEND_DEVICE_CONFIG; - static inline const FlagType FLAG_TYPE_UNSPECIFIED = FlagType::FLAG_TYPE_UNSPECIFIED; - static inline const FlagType FLAG_TYPE_BOOLEAN = FlagType::FLAG_TYPE_BOOLEAN; - static inline const FlagType FLAG_TYPE_INTEGER = FlagType::FLAG_TYPE_INTEGER; - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidAflags_Flag, - AndroidAflags>; - - static constexpr FieldMetadata_Flags kFlags{}; - template T* add_flags() { - return BeginNestedMessage(1); - } - - - using FieldMetadata_Error = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidAflags>; - - static constexpr FieldMetadata_Error kError{}; - void set_error(const char* data, size_t size) { - AppendBytes(FieldMetadata_Error::kFieldId, data, size); - } - void set_error(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Error::kFieldId, chars.data, chars.size); - } - void set_error(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } -}; - -class AndroidAflags_Flag_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidAflags_Flag_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidAflags_Flag_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidAflags_Flag_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_flag_namespace() const { return at<1>().valid(); } - ::protozero::ConstChars flag_namespace() const { return at<1>().as_string(); } - bool has_name() const { return at<2>().valid(); } - ::protozero::ConstChars name() const { return at<2>().as_string(); } - bool has_pkg() const { return at<3>().valid(); } - ::protozero::ConstChars pkg() const { return at<3>().as_string(); } - bool has_container() const { return at<4>().valid(); } - ::protozero::ConstChars container() const { return at<4>().as_string(); } - bool has_value() const { return at<5>().valid(); } - ::protozero::ConstChars value() const { return at<5>().as_string(); } - bool has_staged_value() const { return at<6>().valid(); } - ::protozero::ConstChars staged_value() const { return at<6>().as_string(); } - bool has_permission() const { return at<7>().valid(); } - int32_t permission() const { return at<7>().as_int32(); } - bool has_value_picked_from() const { return at<8>().valid(); } - int32_t value_picked_from() const { return at<8>().as_int32(); } - bool has_storage_backend() const { return at<9>().valid(); } - int32_t storage_backend() const { return at<9>().as_int32(); } - bool has_type() const { return at<10>().valid(); } - int32_t type() const { return at<10>().as_int32(); } -}; - -class AndroidAflags_Flag : public ::protozero::Message { - public: - using Decoder = AndroidAflags_Flag_Decoder; - enum : int32_t { - kFlagNamespaceFieldNumber = 1, - kNameFieldNumber = 2, - kPkgFieldNumber = 3, - kContainerFieldNumber = 4, - kValueFieldNumber = 5, - kStagedValueFieldNumber = 6, - kPermissionFieldNumber = 7, - kValuePickedFromFieldNumber = 8, - kStorageBackendFieldNumber = 9, - kTypeFieldNumber = 10, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidAflags.Flag"; } - - - using FieldMetadata_FlagNamespace = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_FlagNamespace kFlagNamespace{}; - void set_flag_namespace(const char* data, size_t size) { - AppendBytes(FieldMetadata_FlagNamespace::kFieldId, data, size); - } - void set_flag_namespace(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_FlagNamespace::kFieldId, chars.data, chars.size); - } - void set_flag_namespace(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_FlagNamespace::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Pkg = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_Pkg kPkg{}; - void set_pkg(const char* data, size_t size) { - AppendBytes(FieldMetadata_Pkg::kFieldId, data, size); - } - void set_pkg(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Pkg::kFieldId, chars.data, chars.size); - } - void set_pkg(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Pkg::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Container = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_Container kContainer{}; - void set_container(const char* data, size_t size) { - AppendBytes(FieldMetadata_Container::kFieldId, data, size); - } - void set_container(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Container::kFieldId, chars.data, chars.size); - } - void set_container(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Container::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Value = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_Value kValue{}; - void set_value(const char* data, size_t size) { - AppendBytes(FieldMetadata_Value::kFieldId, data, size); - } - void set_value(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); - } - void set_value(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StagedValue = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_StagedValue kStagedValue{}; - void set_staged_value(const char* data, size_t size) { - AppendBytes(FieldMetadata_StagedValue::kFieldId, data, size); - } - void set_staged_value(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_StagedValue::kFieldId, chars.data, chars.size); - } - void set_staged_value(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_StagedValue::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Permission = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - AndroidAflags_FlagPermission, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_Permission kPermission{}; - void set_permission(AndroidAflags_FlagPermission value) { - static constexpr uint32_t field_id = FieldMetadata_Permission::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ValuePickedFrom = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - AndroidAflags_ValuePickedFrom, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_ValuePickedFrom kValuePickedFrom{}; - void set_value_picked_from(AndroidAflags_ValuePickedFrom value) { - static constexpr uint32_t field_id = FieldMetadata_ValuePickedFrom::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StorageBackend = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - AndroidAflags_FlagStorageBackend, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_StorageBackend kStorageBackend{}; - void set_storage_backend(AndroidAflags_FlagStorageBackend value) { - static constexpr uint32_t field_id = FieldMetadata_StorageBackend::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Type = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - AndroidAflags_FlagType, - AndroidAflags_Flag>; - - static constexpr FieldMetadata_Type kType{}; - void set_type(AndroidAflags_FlagType value) { - static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_game_intervention_list.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_GAME_INTERVENTION_LIST_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_GAME_INTERVENTION_LIST_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class AndroidGameInterventionList_GameModeInfo; -class AndroidGameInterventionList_GamePackageInfo; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -class AndroidGameInterventionList_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidGameInterventionList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidGameInterventionList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidGameInterventionList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_game_packages() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_packages() const { return GetRepeated<::protozero::ConstBytes>(1); } - bool has_parse_error() const { return at<2>().valid(); } - bool parse_error() const { return at<2>().as_bool(); } - bool has_read_error() const { return at<3>().valid(); } - bool read_error() const { return at<3>().as_bool(); } -}; - -class AndroidGameInterventionList : public ::protozero::Message { - public: - using Decoder = AndroidGameInterventionList_Decoder; - enum : int32_t { - kGamePackagesFieldNumber = 1, - kParseErrorFieldNumber = 2, - kReadErrorFieldNumber = 3, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList"; } - - using GameModeInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GameModeInfo; - using GamePackageInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GamePackageInfo; - - using FieldMetadata_GamePackages = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidGameInterventionList_GamePackageInfo, - AndroidGameInterventionList>; - - static constexpr FieldMetadata_GamePackages kGamePackages{}; - template T* add_game_packages() { - return BeginNestedMessage(1); - } - - - using FieldMetadata_ParseError = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - AndroidGameInterventionList>; - - static constexpr FieldMetadata_ParseError kParseError{}; - void set_parse_error(bool value) { - static constexpr uint32_t field_id = FieldMetadata_ParseError::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ReadError = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - AndroidGameInterventionList>; - - static constexpr FieldMetadata_ReadError kReadError{}; - void set_read_error(bool value) { - static constexpr uint32_t field_id = FieldMetadata_ReadError::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } -}; - -class AndroidGameInterventionList_GamePackageInfo_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidGameInterventionList_GamePackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_name() const { return at<1>().valid(); } - ::protozero::ConstChars name() const { return at<1>().as_string(); } - bool has_uid() const { return at<2>().valid(); } - uint64_t uid() const { return at<2>().as_uint64(); } - bool has_current_mode() const { return at<3>().valid(); } - uint32_t current_mode() const { return at<3>().as_uint32(); } - bool has_game_mode_info() const { return at<4>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_mode_info() const { return GetRepeated<::protozero::ConstBytes>(4); } -}; - -class AndroidGameInterventionList_GamePackageInfo : public ::protozero::Message { - public: - using Decoder = AndroidGameInterventionList_GamePackageInfo_Decoder; - enum : int32_t { - kNameFieldNumber = 1, - kUidFieldNumber = 2, - kCurrentModeFieldNumber = 3, - kGameModeInfoFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GamePackageInfo"; } - - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidGameInterventionList_GamePackageInfo>; - - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Uid = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - AndroidGameInterventionList_GamePackageInfo>; - - static constexpr FieldMetadata_Uid kUid{}; - void set_uid(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CurrentMode = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidGameInterventionList_GamePackageInfo>; - - static constexpr FieldMetadata_CurrentMode kCurrentMode{}; - void set_current_mode(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_CurrentMode::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_GameModeInfo = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidGameInterventionList_GameModeInfo, - AndroidGameInterventionList_GamePackageInfo>; - - static constexpr FieldMetadata_GameModeInfo kGameModeInfo{}; - template T* add_game_mode_info() { - return BeginNestedMessage(4); - } - -}; - -class AndroidGameInterventionList_GameModeInfo_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidGameInterventionList_GameModeInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidGameInterventionList_GameModeInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidGameInterventionList_GameModeInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_mode() const { return at<1>().valid(); } - uint32_t mode() const { return at<1>().as_uint32(); } - bool has_use_angle() const { return at<2>().valid(); } - bool use_angle() const { return at<2>().as_bool(); } - bool has_resolution_downscale() const { return at<3>().valid(); } - float resolution_downscale() const { return at<3>().as_float(); } - bool has_fps() const { return at<4>().valid(); } - float fps() const { return at<4>().as_float(); } -}; - -class AndroidGameInterventionList_GameModeInfo : public ::protozero::Message { - public: - using Decoder = AndroidGameInterventionList_GameModeInfo_Decoder; - enum : int32_t { - kModeFieldNumber = 1, - kUseAngleFieldNumber = 2, - kResolutionDownscaleFieldNumber = 3, - kFpsFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GameModeInfo"; } - + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } - using FieldMetadata_Mode = + using FieldMetadata_DestinationClass = ::protozero::proto_utils::FieldMetadata< - 1, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidGameInterventionList_GameModeInfo>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_IncidentReportConfig>; - static constexpr FieldMetadata_Mode kMode{}; - void set_mode(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + static constexpr FieldMetadata_DestinationClass kDestinationClass{}; + void set_destination_class(const char* data, size_t size) { + AppendBytes(FieldMetadata_DestinationClass::kFieldId, data, size); + } + void set_destination_class(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DestinationClass::kFieldId, chars.data, chars.size); + } + void set_destination_class(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DestinationClass::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_UseAngle = + using FieldMetadata_PrivacyLevel = ::protozero::proto_utils::FieldMetadata< - 2, + 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - AndroidGameInterventionList_GameModeInfo>; + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TraceConfig_IncidentReportConfig>; - static constexpr FieldMetadata_UseAngle kUseAngle{}; - void set_use_angle(bool value) { - static constexpr uint32_t field_id = FieldMetadata_UseAngle::kFieldId; + static constexpr FieldMetadata_PrivacyLevel kPrivacyLevel{}; + void set_privacy_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrivacyLevel::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> + ::protozero::proto_utils::ProtoSchemaType::kInt32> ::Append(*this, field_id, value); } - using FieldMetadata_ResolutionDownscale = + using FieldMetadata_SkipIncidentd = ::protozero::proto_utils::FieldMetadata< - 3, + 5, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidGameInterventionList_GameModeInfo>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_IncidentReportConfig>; - static constexpr FieldMetadata_ResolutionDownscale kResolutionDownscale{}; - void set_resolution_downscale(float value) { - static constexpr uint32_t field_id = FieldMetadata_ResolutionDownscale::kFieldId; + static constexpr FieldMetadata_SkipIncidentd kSkipIncidentd{}; + void set_skip_incidentd(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SkipIncidentd::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_Fps = + using FieldMetadata_SkipDropbox = ::protozero::proto_utils::FieldMetadata< 4, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidGameInterventionList_GameModeInfo>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_IncidentReportConfig>; - static constexpr FieldMetadata_Fps kFps{}; - void set_fps(float value) { - static constexpr uint32_t field_id = FieldMetadata_Fps::kFieldId; + static constexpr FieldMetadata_SkipDropbox kSkipDropbox{}; + void set_skip_dropbox(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SkipDropbox::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } }; -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_log.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_LOG_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_LOG_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class AndroidLogPacket_LogEvent; -class AndroidLogPacket_LogEvent_Arg; -class AndroidLogPacket_Stats; -enum AndroidLogId : int32_t; -enum AndroidLogPriority : int32_t; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -class AndroidLogPacket_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_CompressionConfig_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidLogPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidLogPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidLogPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_events() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> events() const { return GetRepeated<::protozero::ConstBytes>(1); } - bool has_stats() const { return at<2>().valid(); } - ::protozero::ConstBytes stats() const { return at<2>().as_bytes(); } + TraceConfig_CompressionConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_CompressionConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_CompressionConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_deflate() const { return at<1>().valid(); } + ::protozero::ConstBytes deflate() const { return at<1>().as_bytes(); } + bool has_zstd() const { return at<2>().valid(); } + ::protozero::ConstBytes zstd() const { return at<2>().as_bytes(); } }; -class AndroidLogPacket : public ::protozero::Message { +class TraceConfig_CompressionConfig : public ::protozero::Message { public: - using Decoder = AndroidLogPacket_Decoder; + using Decoder = TraceConfig_CompressionConfig_Decoder; enum : int32_t { - kEventsFieldNumber = 1, - kStatsFieldNumber = 2, + kDeflateFieldNumber = 1, + kZstdFieldNumber = 2, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.CompressionConfig"; } - using LogEvent = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent; - using Stats = ::perfetto::protos::pbzero::AndroidLogPacket_Stats; + using Deflate = ::perfetto::protos::pbzero::TraceConfig_CompressionConfig_Deflate; + using Zstd = ::perfetto::protos::pbzero::TraceConfig_CompressionConfig_Zstd; - using FieldMetadata_Events = + using FieldMetadata_Deflate = ::protozero::proto_utils::FieldMetadata< 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidLogPacket_LogEvent, - AndroidLogPacket>; + TraceConfig_CompressionConfig_Deflate, + TraceConfig_CompressionConfig>; - static constexpr FieldMetadata_Events kEvents{}; - template T* add_events() { + static constexpr FieldMetadata_Deflate kDeflate{}; + template T* set_deflate() { return BeginNestedMessage(1); } - using FieldMetadata_Stats = + using FieldMetadata_Zstd = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidLogPacket_Stats, - AndroidLogPacket>; + TraceConfig_CompressionConfig_Zstd, + TraceConfig_CompressionConfig>; - static constexpr FieldMetadata_Stats kStats{}; - template T* set_stats() { + static constexpr FieldMetadata_Zstd kZstd{}; + template T* set_zstd() { return BeginNestedMessage(2); } }; -class AndroidLogPacket_Stats_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_CompressionConfig_Zstd_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidLogPacket_Stats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidLogPacket_Stats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidLogPacket_Stats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_num_total() const { return at<1>().valid(); } - uint64_t num_total() const { return at<1>().as_uint64(); } - bool has_num_failed() const { return at<2>().valid(); } - uint64_t num_failed() const { return at<2>().as_uint64(); } - bool has_num_skipped() const { return at<3>().valid(); } - uint64_t num_skipped() const { return at<3>().as_uint64(); } + TraceConfig_CompressionConfig_Zstd_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_CompressionConfig_Zstd_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_CompressionConfig_Zstd_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_level() const { return at<1>().valid(); } + int32_t level() const { return at<1>().as_int32(); } }; -class AndroidLogPacket_Stats : public ::protozero::Message { +class TraceConfig_CompressionConfig_Zstd : public ::protozero::Message { public: - using Decoder = AndroidLogPacket_Stats_Decoder; + using Decoder = TraceConfig_CompressionConfig_Zstd_Decoder; enum : int32_t { - kNumTotalFieldNumber = 1, - kNumFailedFieldNumber = 2, - kNumSkippedFieldNumber = 3, + kLevelFieldNumber = 1, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.Stats"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.CompressionConfig.Zstd"; } - using FieldMetadata_NumTotal = + using FieldMetadata_Level = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - AndroidLogPacket_Stats>; + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TraceConfig_CompressionConfig_Zstd>; - static constexpr FieldMetadata_NumTotal kNumTotal{}; - void set_num_total(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_NumTotal::kFieldId; + static constexpr FieldMetadata_Level kLevel{}; + void set_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::protozero::proto_utils::ProtoSchemaType::kInt32> ::Append(*this, field_id, value); } +}; - using FieldMetadata_NumFailed = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - AndroidLogPacket_Stats>; - - static constexpr FieldMetadata_NumFailed kNumFailed{}; - void set_num_failed(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_NumFailed::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } +class TraceConfig_CompressionConfig_Deflate_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_CompressionConfig_Deflate_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_CompressionConfig_Deflate_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_CompressionConfig_Deflate_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; - using FieldMetadata_NumSkipped = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - AndroidLogPacket_Stats>; +class TraceConfig_CompressionConfig_Deflate : public ::protozero::Message { + public: + using Decoder = TraceConfig_CompressionConfig_Deflate_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.CompressionConfig.Deflate"; } - static constexpr FieldMetadata_NumSkipped kNumSkipped{}; - void set_num_skipped(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_NumSkipped::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } }; -class AndroidLogPacket_LogEvent_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_IncrementalStateConfig_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidLogPacket_LogEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidLogPacket_LogEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidLogPacket_LogEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_log_id() const { return at<1>().valid(); } - int32_t log_id() const { return at<1>().as_int32(); } - bool has_pid() const { return at<2>().valid(); } - int32_t pid() const { return at<2>().as_int32(); } - bool has_tid() const { return at<3>().valid(); } - int32_t tid() const { return at<3>().as_int32(); } - bool has_uid() const { return at<4>().valid(); } - int32_t uid() const { return at<4>().as_int32(); } - bool has_timestamp() const { return at<5>().valid(); } - uint64_t timestamp() const { return at<5>().as_uint64(); } - bool has_tag() const { return at<6>().valid(); } - ::protozero::ConstChars tag() const { return at<6>().as_string(); } - bool has_prio() const { return at<7>().valid(); } - int32_t prio() const { return at<7>().as_int32(); } - bool has_message() const { return at<8>().valid(); } - ::protozero::ConstChars message() const { return at<8>().as_string(); } - bool has_args() const { return at<9>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(9); } + TraceConfig_IncrementalStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_IncrementalStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_IncrementalStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_clear_period_ms() const { return at<1>().valid(); } + uint32_t clear_period_ms() const { return at<1>().as_uint32(); } }; -class AndroidLogPacket_LogEvent : public ::protozero::Message { +class TraceConfig_IncrementalStateConfig : public ::protozero::Message { public: - using Decoder = AndroidLogPacket_LogEvent_Decoder; + using Decoder = TraceConfig_IncrementalStateConfig_Decoder; enum : int32_t { - kLogIdFieldNumber = 1, - kPidFieldNumber = 2, - kTidFieldNumber = 3, - kUidFieldNumber = 4, - kTimestampFieldNumber = 5, - kTagFieldNumber = 6, - kPrioFieldNumber = 7, - kMessageFieldNumber = 8, - kArgsFieldNumber = 9, + kClearPeriodMsFieldNumber = 1, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncrementalStateConfig"; } - using Arg = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent_Arg; - using FieldMetadata_LogId = + using FieldMetadata_ClearPeriodMs = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - AndroidLogId, - AndroidLogPacket_LogEvent>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_IncrementalStateConfig>; - static constexpr FieldMetadata_LogId kLogId{}; - void set_log_id(AndroidLogId value) { - static constexpr uint32_t field_id = FieldMetadata_LogId::kFieldId; + static constexpr FieldMetadata_ClearPeriodMs kClearPeriodMs{}; + void set_clear_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClearPeriodMs::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } +}; - using FieldMetadata_Pid = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidLogPacket_LogEvent>; +class TraceConfig_TriggerConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_TriggerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_TriggerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_TriggerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trigger_mode() const { return at<1>().valid(); } + int32_t trigger_mode() const { return at<1>().as_int32(); } + bool has_use_clone_snapshot_if_available() const { return at<5>().valid(); } + bool use_clone_snapshot_if_available() const { return at<5>().as_bool(); } + bool has_triggers() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> triggers() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_trigger_timeout_ms() const { return at<3>().valid(); } + uint32_t trigger_timeout_ms() const { return at<3>().as_uint32(); } +}; - static constexpr FieldMetadata_Pid kPid{}; - void set_pid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } +class TraceConfig_TriggerConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_TriggerConfig_Decoder; + enum : int32_t { + kTriggerModeFieldNumber = 1, + kUseCloneSnapshotIfAvailableFieldNumber = 5, + kTriggersFieldNumber = 2, + kTriggerTimeoutMsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig"; } - using FieldMetadata_Tid = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidLogPacket_LogEvent>; + using Trigger = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_Trigger; - static constexpr FieldMetadata_Tid kTid{}; - void set_tid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); + using TriggerMode = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode; + static inline const char* TriggerMode_Name(TriggerMode value) { + return ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode_Name(value); } + static inline const TriggerMode UNSPECIFIED = TriggerMode::UNSPECIFIED; + static inline const TriggerMode START_TRACING = TriggerMode::START_TRACING; + static inline const TriggerMode STOP_TRACING = TriggerMode::STOP_TRACING; + static inline const TriggerMode CLONE_SNAPSHOT = TriggerMode::CLONE_SNAPSHOT; - using FieldMetadata_Uid = + using FieldMetadata_TriggerMode = ::protozero::proto_utils::FieldMetadata< - 4, + 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidLogPacket_LogEvent>; + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_TriggerConfig_TriggerMode, + TraceConfig_TriggerConfig>; - static constexpr FieldMetadata_Uid kUid{}; - void set_uid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + static constexpr FieldMetadata_TriggerMode kTriggerMode{}; + void set_trigger_mode(TraceConfig_TriggerConfig_TriggerMode value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerMode::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kEnum> ::Append(*this, field_id, value); } - using FieldMetadata_Timestamp = + using FieldMetadata_UseCloneSnapshotIfAvailable = ::protozero::proto_utils::FieldMetadata< 5, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - AndroidLogPacket_LogEvent>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_TriggerConfig>; - static constexpr FieldMetadata_Timestamp kTimestamp{}; - void set_timestamp(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + static constexpr FieldMetadata_UseCloneSnapshotIfAvailable kUseCloneSnapshotIfAvailable{}; + void set_use_clone_snapshot_if_available(bool value) { + static constexpr uint32_t field_id = FieldMetadata_UseCloneSnapshotIfAvailable::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_Tag = + using FieldMetadata_Triggers = ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidLogPacket_LogEvent>; + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_TriggerConfig_Trigger, + TraceConfig_TriggerConfig>; - static constexpr FieldMetadata_Tag kTag{}; - void set_tag(const char* data, size_t size) { - AppendBytes(FieldMetadata_Tag::kFieldId, data, size); - } - void set_tag(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); - } - void set_tag(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_Triggers kTriggers{}; + template T* add_triggers() { + return BeginNestedMessage(2); } - using FieldMetadata_Prio = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - AndroidLogPriority, - AndroidLogPacket_LogEvent>; - - static constexpr FieldMetadata_Prio kPrio{}; - void set_prio(AndroidLogPriority value) { - static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - using FieldMetadata_Message = + using FieldMetadata_TriggerTimeoutMs = ::protozero::proto_utils::FieldMetadata< - 8, + 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidLogPacket_LogEvent>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_TriggerConfig>; - static constexpr FieldMetadata_Message kMessage{}; - void set_message(const char* data, size_t size) { - AppendBytes(FieldMetadata_Message::kFieldId, data, size); - } - void set_message(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size); - } - void set_message(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId; + static constexpr FieldMetadata_TriggerTimeoutMs kTriggerTimeoutMs{}; + void set_trigger_timeout_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerTimeoutMs::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } - - using FieldMetadata_Args = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidLogPacket_LogEvent_Arg, - AndroidLogPacket_LogEvent>; - - static constexpr FieldMetadata_Args kArgs{}; - template T* add_args() { - return BeginNestedMessage(9); - } - }; -class AndroidLogPacket_LogEvent_Arg_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_TriggerConfig_Trigger_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidLogPacket_LogEvent_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidLogPacket_LogEvent_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidLogPacket_LogEvent_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + TraceConfig_TriggerConfig_Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_TriggerConfig_Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_TriggerConfig_Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} bool has_name() const { return at<1>().valid(); } ::protozero::ConstChars name() const { return at<1>().as_string(); } - bool has_int_value() const { return at<2>().valid(); } - int64_t int_value() const { return at<2>().as_int64(); } - bool has_float_value() const { return at<3>().valid(); } - float float_value() const { return at<3>().as_float(); } - bool has_string_value() const { return at<4>().valid(); } - ::protozero::ConstChars string_value() const { return at<4>().as_string(); } + bool has_producer_name_regex() const { return at<2>().valid(); } + ::protozero::ConstChars producer_name_regex() const { return at<2>().as_string(); } + bool has_stop_delay_ms() const { return at<3>().valid(); } + uint32_t stop_delay_ms() const { return at<3>().as_uint32(); } + bool has_max_per_24_h() const { return at<4>().valid(); } + uint32_t max_per_24_h() const { return at<4>().as_uint32(); } + bool has_skip_probability() const { return at<5>().valid(); } + double skip_probability() const { return at<5>().as_double(); } }; -class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message { +class TraceConfig_TriggerConfig_Trigger : public ::protozero::Message { public: - using Decoder = AndroidLogPacket_LogEvent_Arg_Decoder; + using Decoder = TraceConfig_TriggerConfig_Trigger_Decoder; enum : int32_t { kNameFieldNumber = 1, - kIntValueFieldNumber = 2, - kFloatValueFieldNumber = 3, - kStringValueFieldNumber = 4, + kProducerNameRegexFieldNumber = 2, + kStopDelayMsFieldNumber = 3, + kMaxPer24HFieldNumber = 4, + kSkipProbabilityFieldNumber = 5, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent.Arg"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig.Trigger"; } using FieldMetadata_Name = @@ -70280,7 +67941,7 @@ class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message { ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kString, std::string, - AndroidLogPacket_LogEvent_Arg>; + TraceConfig_TriggerConfig_Trigger>; static constexpr FieldMetadata_Name kName{}; void set_name(const char* data, size_t size) { @@ -70298,767 +67959,727 @@ class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_IntValue = + using FieldMetadata_ProducerNameRegex = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidLogPacket_LogEvent_Arg>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_TriggerConfig_Trigger>; - static constexpr FieldMetadata_IntValue kIntValue{}; - void set_int_value(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + static constexpr FieldMetadata_ProducerNameRegex kProducerNameRegex{}; + void set_producer_name_regex(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, data, size); + } + void set_producer_name_regex(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, chars.data, chars.size); + } + void set_producer_name_regex(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegex::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_FloatValue = + using FieldMetadata_StopDelayMs = ::protozero::proto_utils::FieldMetadata< 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidLogPacket_LogEvent_Arg>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_TriggerConfig_Trigger>; - static constexpr FieldMetadata_FloatValue kFloatValue{}; - void set_float_value(float value) { - static constexpr uint32_t field_id = FieldMetadata_FloatValue::kFieldId; + static constexpr FieldMetadata_StopDelayMs kStopDelayMs{}; + void set_stop_delay_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } - using FieldMetadata_StringValue = + using FieldMetadata_MaxPer24H = ::protozero::proto_utils::FieldMetadata< 4, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidLogPacket_LogEvent_Arg>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_TriggerConfig_Trigger>; - static constexpr FieldMetadata_StringValue kStringValue{}; - void set_string_value(const char* data, size_t size) { - AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); - } - void set_string_value(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size); - } - void set_string_value(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; + static constexpr FieldMetadata_MaxPer24H kMaxPer24H{}; + void set_max_per_24_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxPer24H::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_system_property.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_SYSTEM_PROPERTY_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_SYSTEM_PROPERTY_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" -namespace perfetto { -namespace protos { -namespace pbzero { -class AndroidSystemProperty_PropertyValue; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. + using FieldMetadata_SkipProbability = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + TraceConfig_TriggerConfig_Trigger>; -namespace perfetto { -namespace protos { -namespace pbzero { + static constexpr FieldMetadata_SkipProbability kSkipProbability{}; + void set_skip_probability(double value) { + static constexpr uint32_t field_id = FieldMetadata_SkipProbability::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } +}; -class AndroidSystemProperty_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_GuardrailOverrides_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidSystemProperty_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidSystemProperty_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidSystemProperty_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_values() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> values() const { return GetRepeated<::protozero::ConstBytes>(1); } + TraceConfig_GuardrailOverrides_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_GuardrailOverrides_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_GuardrailOverrides_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_max_upload_per_day_bytes() const { return at<1>().valid(); } + uint64_t max_upload_per_day_bytes() const { return at<1>().as_uint64(); } + bool has_max_tracing_buffer_size_kb() const { return at<2>().valid(); } + uint32_t max_tracing_buffer_size_kb() const { return at<2>().as_uint32(); } }; -class AndroidSystemProperty : public ::protozero::Message { +class TraceConfig_GuardrailOverrides : public ::protozero::Message { public: - using Decoder = AndroidSystemProperty_Decoder; + using Decoder = TraceConfig_GuardrailOverrides_Decoder; enum : int32_t { - kValuesFieldNumber = 1, + kMaxUploadPerDayBytesFieldNumber = 1, + kMaxTracingBufferSizeKbFieldNumber = 2, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.GuardrailOverrides"; } - using PropertyValue = ::perfetto::protos::pbzero::AndroidSystemProperty_PropertyValue; - using FieldMetadata_Values = + using FieldMetadata_MaxUploadPerDayBytes = ::protozero::proto_utils::FieldMetadata< 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidSystemProperty_PropertyValue, - AndroidSystemProperty>; + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceConfig_GuardrailOverrides>; - static constexpr FieldMetadata_Values kValues{}; - template T* add_values() { - return BeginNestedMessage(1); + static constexpr FieldMetadata_MaxUploadPerDayBytes kMaxUploadPerDayBytes{}; + void set_max_upload_per_day_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxUploadPerDayBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); } + using FieldMetadata_MaxTracingBufferSizeKb = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_GuardrailOverrides>; + + static constexpr FieldMetadata_MaxTracingBufferSizeKb kMaxTracingBufferSizeKb{}; + void set_max_tracing_buffer_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxTracingBufferSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } }; -class AndroidSystemProperty_PropertyValue_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_StatsdMetadata_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidSystemProperty_PropertyValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidSystemProperty_PropertyValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidSystemProperty_PropertyValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_name() const { return at<1>().valid(); } - ::protozero::ConstChars name() const { return at<1>().as_string(); } - bool has_value() const { return at<2>().valid(); } - ::protozero::ConstChars value() const { return at<2>().as_string(); } + TraceConfig_StatsdMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_StatsdMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_StatsdMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_triggering_alert_id() const { return at<1>().valid(); } + int64_t triggering_alert_id() const { return at<1>().as_int64(); } + bool has_triggering_config_uid() const { return at<2>().valid(); } + int32_t triggering_config_uid() const { return at<2>().as_int32(); } + bool has_triggering_config_id() const { return at<3>().valid(); } + int64_t triggering_config_id() const { return at<3>().as_int64(); } + bool has_triggering_subscription_id() const { return at<4>().valid(); } + int64_t triggering_subscription_id() const { return at<4>().as_int64(); } }; -class AndroidSystemProperty_PropertyValue : public ::protozero::Message { +class TraceConfig_StatsdMetadata : public ::protozero::Message { public: - using Decoder = AndroidSystemProperty_PropertyValue_Decoder; + using Decoder = TraceConfig_StatsdMetadata_Decoder; enum : int32_t { - kNameFieldNumber = 1, - kValueFieldNumber = 2, + kTriggeringAlertIdFieldNumber = 1, + kTriggeringConfigUidFieldNumber = 2, + kTriggeringConfigIdFieldNumber = 3, + kTriggeringSubscriptionIdFieldNumber = 4, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty.PropertyValue"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.StatsdMetadata"; } - using FieldMetadata_Name = + using FieldMetadata_TriggeringAlertId = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidSystemProperty_PropertyValue>; + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceConfig_StatsdMetadata>; - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + static constexpr FieldMetadata_TriggeringAlertId kTriggeringAlertId{}; + void set_triggering_alert_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggeringAlertId::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> + ::protozero::proto_utils::ProtoSchemaType::kInt64> ::Append(*this, field_id, value); } - using FieldMetadata_Value = + using FieldMetadata_TriggeringConfigUid = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - AndroidSystemProperty_PropertyValue>; + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TraceConfig_StatsdMetadata>; - static constexpr FieldMetadata_Value kValue{}; - void set_value(const char* data, size_t size) { - AppendBytes(FieldMetadata_Value::kFieldId, data, size); - } - void set_value(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); - } - void set_value(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + static constexpr FieldMetadata_TriggeringConfigUid kTriggeringConfigUid{}; + void set_triggering_config_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigUid::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> + ::protozero::proto_utils::ProtoSchemaType::kInt32> ::Append(*this, field_id, value); } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/camera_event.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CAMERA_EVENT_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CAMERA_EVENT_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class AndroidCameraFrameEvent_CameraNodeProcessingDetails; -class AndroidCameraSessionStats_CameraGraph; -class AndroidCameraSessionStats_CameraGraph_CameraEdge; -class AndroidCameraSessionStats_CameraGraph_CameraNode; -namespace perfetto_pbzero_enum_AndroidCameraFrameEvent { -enum CaptureResultStatus : int32_t; -} // namespace perfetto_pbzero_enum_AndroidCameraFrameEvent -using AndroidCameraFrameEvent_CaptureResultStatus = perfetto_pbzero_enum_AndroidCameraFrameEvent::CaptureResultStatus; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -namespace perfetto_pbzero_enum_AndroidCameraFrameEvent { -enum CaptureResultStatus : int32_t { - STATUS_UNSPECIFIED = 0, - STATUS_OK = 1, - STATUS_EARLY_METADATA_ERROR = 2, - STATUS_FINAL_METADATA_ERROR = 3, - STATUS_BUFFER_ERROR = 4, - STATUS_FLUSH_ERROR = 5, -}; -} // namespace perfetto_pbzero_enum_AndroidCameraFrameEvent -using AndroidCameraFrameEvent_CaptureResultStatus = perfetto_pbzero_enum_AndroidCameraFrameEvent::CaptureResultStatus; - - -constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent_CaptureResultStatus_MIN = AndroidCameraFrameEvent_CaptureResultStatus::STATUS_UNSPECIFIED; -constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent_CaptureResultStatus_MAX = AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FLUSH_ERROR; - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* AndroidCameraFrameEvent_CaptureResultStatus_Name(::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus value) { - switch (value) { - case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_UNSPECIFIED: - return "STATUS_UNSPECIFIED"; - - case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_OK: - return "STATUS_OK"; - - case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_EARLY_METADATA_ERROR: - return "STATUS_EARLY_METADATA_ERROR"; + using FieldMetadata_TriggeringConfigId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceConfig_StatsdMetadata>; - case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FINAL_METADATA_ERROR: - return "STATUS_FINAL_METADATA_ERROR"; + static constexpr FieldMetadata_TriggeringConfigId kTriggeringConfigId{}; + void set_triggering_config_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } - case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_BUFFER_ERROR: - return "STATUS_BUFFER_ERROR"; + using FieldMetadata_TriggeringSubscriptionId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceConfig_StatsdMetadata>; - case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FLUSH_ERROR: - return "STATUS_FLUSH_ERROR"; + static constexpr FieldMetadata_TriggeringSubscriptionId kTriggeringSubscriptionId{}; + void set_triggering_subscription_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggeringSubscriptionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} +}; -class AndroidCameraSessionStats_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_ProducerConfig_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidCameraSessionStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidCameraSessionStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidCameraSessionStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_session_id() const { return at<1>().valid(); } - uint64_t session_id() const { return at<1>().as_uint64(); } - bool has_graph() const { return at<2>().valid(); } - ::protozero::ConstBytes graph() const { return at<2>().as_bytes(); } + TraceConfig_ProducerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_ProducerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_ProducerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_producer_name() const { return at<1>().valid(); } + ::protozero::ConstChars producer_name() const { return at<1>().as_string(); } + bool has_shm_size_kb() const { return at<2>().valid(); } + uint32_t shm_size_kb() const { return at<2>().as_uint32(); } + bool has_page_size_kb() const { return at<3>().valid(); } + uint32_t page_size_kb() const { return at<3>().as_uint32(); } }; -class AndroidCameraSessionStats : public ::protozero::Message { +class TraceConfig_ProducerConfig : public ::protozero::Message { public: - using Decoder = AndroidCameraSessionStats_Decoder; + using Decoder = TraceConfig_ProducerConfig_Decoder; enum : int32_t { - kSessionIdFieldNumber = 1, - kGraphFieldNumber = 2, + kProducerNameFieldNumber = 1, + kShmSizeKbFieldNumber = 2, + kPageSizeKbFieldNumber = 3, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.ProducerConfig"; } - using CameraGraph = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph; - using FieldMetadata_SessionId = + using FieldMetadata_ProducerName = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - AndroidCameraSessionStats>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_ProducerConfig>; - static constexpr FieldMetadata_SessionId kSessionId{}; - void set_session_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId; + static constexpr FieldMetadata_ProducerName kProducerName{}; + void set_producer_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size); + } + void set_producer_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size); + } + void set_producer_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_Graph = + using FieldMetadata_ShmSizeKb = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidCameraSessionStats_CameraGraph, - AndroidCameraSessionStats>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_ProducerConfig>; - static constexpr FieldMetadata_Graph kGraph{}; - template T* set_graph() { - return BeginNestedMessage(2); + static constexpr FieldMetadata_ShmSizeKb kShmSizeKb{}; + void set_shm_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ShmSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); } + using FieldMetadata_PageSizeKb = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_ProducerConfig>; + + static constexpr FieldMetadata_PageSizeKb kPageSizeKb{}; + void set_page_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PageSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } }; -class AndroidCameraSessionStats_CameraGraph_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_BuiltinDataSource_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidCameraSessionStats_CameraGraph_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidCameraSessionStats_CameraGraph_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidCameraSessionStats_CameraGraph_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_nodes() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nodes() const { return GetRepeated<::protozero::ConstBytes>(1); } - bool has_edges() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> edges() const { return GetRepeated<::protozero::ConstBytes>(2); } + TraceConfig_BuiltinDataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_BuiltinDataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_BuiltinDataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_disable_clock_snapshotting() const { return at<1>().valid(); } + bool disable_clock_snapshotting() const { return at<1>().as_bool(); } + bool has_disable_trace_config() const { return at<2>().valid(); } + bool disable_trace_config() const { return at<2>().as_bool(); } + bool has_disable_system_info() const { return at<3>().valid(); } + bool disable_system_info() const { return at<3>().as_bool(); } + bool has_disable_service_events() const { return at<4>().valid(); } + bool disable_service_events() const { return at<4>().as_bool(); } + bool has_primary_trace_clock() const { return at<5>().valid(); } + int32_t primary_trace_clock() const { return at<5>().as_int32(); } + bool has_snapshot_interval_ms() const { return at<6>().valid(); } + uint32_t snapshot_interval_ms() const { return at<6>().as_uint32(); } + bool has_prefer_suspend_clock_for_snapshot() const { return at<7>().valid(); } + bool prefer_suspend_clock_for_snapshot() const { return at<7>().as_bool(); } + bool has_disable_chunk_usage_histograms() const { return at<8>().valid(); } + bool disable_chunk_usage_histograms() const { return at<8>().as_bool(); } + bool has_disable_extension_descriptors() const { return at<9>().valid(); } + bool disable_extension_descriptors() const { return at<9>().as_bool(); } + bool has_enable_concurrent_session_events() const { return at<10>().valid(); } + bool enable_concurrent_session_events() const { return at<10>().as_bool(); } }; -class AndroidCameraSessionStats_CameraGraph : public ::protozero::Message { +class TraceConfig_BuiltinDataSource : public ::protozero::Message { public: - using Decoder = AndroidCameraSessionStats_CameraGraph_Decoder; + using Decoder = TraceConfig_BuiltinDataSource_Decoder; enum : int32_t { - kNodesFieldNumber = 1, - kEdgesFieldNumber = 2, + kDisableClockSnapshottingFieldNumber = 1, + kDisableTraceConfigFieldNumber = 2, + kDisableSystemInfoFieldNumber = 3, + kDisableServiceEventsFieldNumber = 4, + kPrimaryTraceClockFieldNumber = 5, + kSnapshotIntervalMsFieldNumber = 6, + kPreferSuspendClockForSnapshotFieldNumber = 7, + kDisableChunkUsageHistogramsFieldNumber = 8, + kDisableExtensionDescriptorsFieldNumber = 9, + kEnableConcurrentSessionEventsFieldNumber = 10, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BuiltinDataSource"; } - using CameraNode = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph_CameraNode; - using CameraEdge = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph_CameraEdge; - using FieldMetadata_Nodes = + using FieldMetadata_DisableClockSnapshotting = ::protozero::proto_utils::FieldMetadata< 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidCameraSessionStats_CameraGraph_CameraNode, - AndroidCameraSessionStats_CameraGraph>; + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; - static constexpr FieldMetadata_Nodes kNodes{}; - template T* add_nodes() { - return BeginNestedMessage(1); + static constexpr FieldMetadata_DisableClockSnapshotting kDisableClockSnapshotting{}; + void set_disable_clock_snapshotting(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableClockSnapshotting::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); } - - using FieldMetadata_Edges = + using FieldMetadata_DisableTraceConfig = ::protozero::proto_utils::FieldMetadata< 2, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidCameraSessionStats_CameraGraph_CameraEdge, - AndroidCameraSessionStats_CameraGraph>; + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; - static constexpr FieldMetadata_Edges kEdges{}; - template T* add_edges() { - return BeginNestedMessage(2); + static constexpr FieldMetadata_DisableTraceConfig kDisableTraceConfig{}; + void set_disable_trace_config(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableTraceConfig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); } -}; + using FieldMetadata_DisableSystemInfo = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; -class AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_output_node_id() const { return at<1>().valid(); } - int64_t output_node_id() const { return at<1>().as_int64(); } - bool has_output_id() const { return at<2>().valid(); } - int64_t output_id() const { return at<2>().as_int64(); } - bool has_input_node_id() const { return at<3>().valid(); } - int64_t input_node_id() const { return at<3>().as_int64(); } - bool has_input_id() const { return at<4>().valid(); } - int64_t input_id() const { return at<4>().as_int64(); } - bool has_vendor_data_version() const { return at<5>().valid(); } - int32_t vendor_data_version() const { return at<5>().as_int32(); } - bool has_vendor_data() const { return at<6>().valid(); } - ::protozero::ConstBytes vendor_data() const { return at<6>().as_bytes(); } -}; + static constexpr FieldMetadata_DisableSystemInfo kDisableSystemInfo{}; + void set_disable_system_info(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableSystemInfo::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } -class AndroidCameraSessionStats_CameraGraph_CameraEdge : public ::protozero::Message { - public: - using Decoder = AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder; - enum : int32_t { - kOutputNodeIdFieldNumber = 1, - kOutputIdFieldNumber = 2, - kInputNodeIdFieldNumber = 3, - kInputIdFieldNumber = 4, - kVendorDataVersionFieldNumber = 5, - kVendorDataFieldNumber = 6, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge"; } + using FieldMetadata_DisableServiceEvents = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; + static constexpr FieldMetadata_DisableServiceEvents kDisableServiceEvents{}; + void set_disable_service_events(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableServiceEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } - using FieldMetadata_OutputNodeId = + using FieldMetadata_PrimaryTraceClock = ::protozero::proto_utils::FieldMetadata< - 1, + 5, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraSessionStats_CameraGraph_CameraEdge>; + ::protozero::proto_utils::ProtoSchemaType::kEnum, + BuiltinClock, + TraceConfig_BuiltinDataSource>; - static constexpr FieldMetadata_OutputNodeId kOutputNodeId{}; - void set_output_node_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_OutputNodeId::kFieldId; + static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock{}; + void set_primary_trace_clock(BuiltinClock value) { + static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kEnum> ::Append(*this, field_id, value); } - using FieldMetadata_OutputId = + using FieldMetadata_SnapshotIntervalMs = ::protozero::proto_utils::FieldMetadata< - 2, + 6, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraSessionStats_CameraGraph_CameraEdge>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_BuiltinDataSource>; - static constexpr FieldMetadata_OutputId kOutputId{}; - void set_output_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_OutputId::kFieldId; + static constexpr FieldMetadata_SnapshotIntervalMs kSnapshotIntervalMs{}; + void set_snapshot_interval_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SnapshotIntervalMs::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } - using FieldMetadata_InputNodeId = + using FieldMetadata_PreferSuspendClockForSnapshot = ::protozero::proto_utils::FieldMetadata< - 3, + 7, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraSessionStats_CameraGraph_CameraEdge>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; - static constexpr FieldMetadata_InputNodeId kInputNodeId{}; - void set_input_node_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_InputNodeId::kFieldId; + static constexpr FieldMetadata_PreferSuspendClockForSnapshot kPreferSuspendClockForSnapshot{}; + void set_prefer_suspend_clock_for_snapshot(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForSnapshot::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_InputId = + using FieldMetadata_DisableChunkUsageHistograms = ::protozero::proto_utils::FieldMetadata< - 4, + 8, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraSessionStats_CameraGraph_CameraEdge>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; - static constexpr FieldMetadata_InputId kInputId{}; - void set_input_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_InputId::kFieldId; + static constexpr FieldMetadata_DisableChunkUsageHistograms kDisableChunkUsageHistograms{}; + void set_disable_chunk_usage_histograms(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableChunkUsageHistograms::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_VendorDataVersion = + using FieldMetadata_DisableExtensionDescriptors = ::protozero::proto_utils::FieldMetadata< - 5, + 9, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidCameraSessionStats_CameraGraph_CameraEdge>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; - static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{}; - void set_vendor_data_version(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId; + static constexpr FieldMetadata_DisableExtensionDescriptors kDisableExtensionDescriptors{}; + void set_disable_extension_descriptors(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableExtensionDescriptors::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_VendorData = + using FieldMetadata_EnableConcurrentSessionEvents = ::protozero::proto_utils::FieldMetadata< - 6, + 10, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBytes, - std::string, - AndroidCameraSessionStats_CameraGraph_CameraEdge>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; - static constexpr FieldMetadata_VendorData kVendorData{}; - void set_vendor_data(const uint8_t* data, size_t size) { - AppendBytes(FieldMetadata_VendorData::kFieldId, data, size); - } - void set_vendor_data(::protozero::ConstBytes bytes) { - AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size); - } - void set_vendor_data(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId; + static constexpr FieldMetadata_EnableConcurrentSessionEvents kEnableConcurrentSessionEvents{}; + void set_enable_concurrent_session_events(bool value) { + static constexpr uint32_t field_id = FieldMetadata_EnableConcurrentSessionEvents::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } }; -class AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_DataSource_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_node_id() const { return at<1>().valid(); } - int64_t node_id() const { return at<1>().as_int64(); } - bool has_input_ids() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator input_ids() const { return GetRepeated(2); } - bool has_output_ids() const { return at<3>().valid(); } - ::protozero::RepeatedFieldIterator output_ids() const { return GetRepeated(3); } - bool has_vendor_data_version() const { return at<4>().valid(); } - int32_t vendor_data_version() const { return at<4>().as_int32(); } - bool has_vendor_data() const { return at<5>().valid(); } - ::protozero::ConstBytes vendor_data() const { return at<5>().as_bytes(); } + TraceConfig_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_DataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_config() const { return at<1>().valid(); } + ::protozero::ConstBytes config() const { return at<1>().as_bytes(); } + bool has_producer_name_filter() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_filter() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_producer_name_regex_filter() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_regex_filter() const { return GetRepeated<::protozero::ConstChars>(3); } + bool has_machine_name_filter() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> machine_name_filter() const { return GetRepeated<::protozero::ConstChars>(4); } }; -class AndroidCameraSessionStats_CameraGraph_CameraNode : public ::protozero::Message { +class TraceConfig_DataSource : public ::protozero::Message { public: - using Decoder = AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder; + using Decoder = TraceConfig_DataSource_Decoder; enum : int32_t { - kNodeIdFieldNumber = 1, - kInputIdsFieldNumber = 2, - kOutputIdsFieldNumber = 3, - kVendorDataVersionFieldNumber = 4, - kVendorDataFieldNumber = 5, + kConfigFieldNumber = 1, + kProducerNameFilterFieldNumber = 2, + kProducerNameRegexFilterFieldNumber = 3, + kMachineNameFilterFieldNumber = 4, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.DataSource"; } - using FieldMetadata_NodeId = + using FieldMetadata_Config = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraSessionStats_CameraGraph_CameraNode>; + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DataSourceConfig, + TraceConfig_DataSource>; - static constexpr FieldMetadata_NodeId kNodeId{}; - void set_node_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_NodeId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_Config kConfig{}; + template T* set_config() { + return BeginNestedMessage(1); } - using FieldMetadata_InputIds = + + using FieldMetadata_ProducerNameFilter = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraSessionStats_CameraGraph_CameraNode>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_DataSource>; - static constexpr FieldMetadata_InputIds kInputIds{}; - void add_input_ids(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_InputIds::kFieldId; + static constexpr FieldMetadata_ProducerNameFilter kProducerNameFilter{}; + void add_producer_name_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, data, size); + } + void add_producer_name_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, chars.data, chars.size); + } + void add_producer_name_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerNameFilter::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_OutputIds = + using FieldMetadata_ProducerNameRegexFilter = ::protozero::proto_utils::FieldMetadata< 3, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraSessionStats_CameraGraph_CameraNode>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_DataSource>; - static constexpr FieldMetadata_OutputIds kOutputIds{}; - void add_output_ids(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_OutputIds::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_ProducerNameRegexFilter kProducerNameRegexFilter{}; + void add_producer_name_regex_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, data, size); } - - using FieldMetadata_VendorDataVersion = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidCameraSessionStats_CameraGraph_CameraNode>; - - static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{}; - void set_vendor_data_version(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId; + void add_producer_name_regex_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, chars.data, chars.size); + } + void add_producer_name_regex_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegexFilter::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_VendorData = + using FieldMetadata_MachineNameFilter = ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBytes, + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, std::string, - AndroidCameraSessionStats_CameraGraph_CameraNode>; + TraceConfig_DataSource>; - static constexpr FieldMetadata_VendorData kVendorData{}; - void set_vendor_data(const uint8_t* data, size_t size) { - AppendBytes(FieldMetadata_VendorData::kFieldId, data, size); + static constexpr FieldMetadata_MachineNameFilter kMachineNameFilter{}; + void add_machine_name_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_MachineNameFilter::kFieldId, data, size); } - void set_vendor_data(::protozero::ConstBytes bytes) { - AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size); + void add_machine_name_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_MachineNameFilter::kFieldId, chars.data, chars.size); } - void set_vendor_data(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId; + void add_machine_name_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MachineNameFilter::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } }; -class AndroidCameraFrameEvent_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidCameraFrameEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidCameraFrameEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidCameraFrameEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_session_id() const { return at<1>().valid(); } - uint64_t session_id() const { return at<1>().as_uint64(); } - bool has_camera_id() const { return at<2>().valid(); } - uint32_t camera_id() const { return at<2>().as_uint32(); } - bool has_frame_number() const { return at<3>().valid(); } - int64_t frame_number() const { return at<3>().as_int64(); } - bool has_request_id() const { return at<4>().valid(); } - int64_t request_id() const { return at<4>().as_int64(); } - bool has_request_received_ns() const { return at<5>().valid(); } - int64_t request_received_ns() const { return at<5>().as_int64(); } - bool has_request_processing_started_ns() const { return at<6>().valid(); } - int64_t request_processing_started_ns() const { return at<6>().as_int64(); } - bool has_start_of_exposure_ns() const { return at<7>().valid(); } - int64_t start_of_exposure_ns() const { return at<7>().as_int64(); } - bool has_start_of_frame_ns() const { return at<8>().valid(); } - int64_t start_of_frame_ns() const { return at<8>().as_int64(); } - bool has_responses_all_sent_ns() const { return at<9>().valid(); } - int64_t responses_all_sent_ns() const { return at<9>().as_int64(); } - bool has_capture_result_status() const { return at<10>().valid(); } - int32_t capture_result_status() const { return at<10>().as_int32(); } - bool has_skipped_sensor_frames() const { return at<11>().valid(); } - int32_t skipped_sensor_frames() const { return at<11>().as_int32(); } - bool has_capture_intent() const { return at<12>().valid(); } - int32_t capture_intent() const { return at<12>().as_int32(); } - bool has_num_streams() const { return at<13>().valid(); } - int32_t num_streams() const { return at<13>().as_int32(); } - bool has_node_processing_details() const { return at<14>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> node_processing_details() const { return GetRepeated<::protozero::ConstBytes>(14); } - bool has_vendor_data_version() const { return at<15>().valid(); } - int32_t vendor_data_version() const { return at<15>().as_int32(); } - bool has_vendor_data() const { return at<16>().valid(); } - ::protozero::ConstBytes vendor_data() const { return at<16>().as_bytes(); } -}; - -class AndroidCameraFrameEvent : public ::protozero::Message { - public: - using Decoder = AndroidCameraFrameEvent_Decoder; +class TraceConfig_BufferConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_BufferConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_BufferConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_BufferConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_size_kb() const { return at<1>().valid(); } + uint32_t size_kb() const { return at<1>().as_uint32(); } + bool has_fill_policy() const { return at<4>().valid(); } + int32_t fill_policy() const { return at<4>().as_int32(); } + bool has_transfer_on_clone() const { return at<5>().valid(); } + bool transfer_on_clone() const { return at<5>().as_bool(); } + bool has_clear_before_clone() const { return at<6>().valid(); } + bool clear_before_clone() const { return at<6>().as_bool(); } + bool has_name() const { return at<7>().valid(); } + ::protozero::ConstChars name() const { return at<7>().as_string(); } + bool has_experimental_mode() const { return at<8>().valid(); } + int32_t experimental_mode() const { return at<8>().as_int32(); } +}; + +class TraceConfig_BufferConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_BufferConfig_Decoder; enum : int32_t { - kSessionIdFieldNumber = 1, - kCameraIdFieldNumber = 2, - kFrameNumberFieldNumber = 3, - kRequestIdFieldNumber = 4, - kRequestReceivedNsFieldNumber = 5, - kRequestProcessingStartedNsFieldNumber = 6, - kStartOfExposureNsFieldNumber = 7, - kStartOfFrameNsFieldNumber = 8, - kResponsesAllSentNsFieldNumber = 9, - kCaptureResultStatusFieldNumber = 10, - kSkippedSensorFramesFieldNumber = 11, - kCaptureIntentFieldNumber = 12, - kNumStreamsFieldNumber = 13, - kNodeProcessingDetailsFieldNumber = 14, - kVendorDataVersionFieldNumber = 15, - kVendorDataFieldNumber = 16, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraFrameEvent"; } - - using CameraNodeProcessingDetails = ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CameraNodeProcessingDetails; - - using CaptureResultStatus = ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus; - static inline const char* CaptureResultStatus_Name(CaptureResultStatus value) { - return ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus_Name(value); - } - static inline const CaptureResultStatus STATUS_UNSPECIFIED = CaptureResultStatus::STATUS_UNSPECIFIED; - static inline const CaptureResultStatus STATUS_OK = CaptureResultStatus::STATUS_OK; - static inline const CaptureResultStatus STATUS_EARLY_METADATA_ERROR = CaptureResultStatus::STATUS_EARLY_METADATA_ERROR; - static inline const CaptureResultStatus STATUS_FINAL_METADATA_ERROR = CaptureResultStatus::STATUS_FINAL_METADATA_ERROR; - static inline const CaptureResultStatus STATUS_BUFFER_ERROR = CaptureResultStatus::STATUS_BUFFER_ERROR; - static inline const CaptureResultStatus STATUS_FLUSH_ERROR = CaptureResultStatus::STATUS_FLUSH_ERROR; + kSizeKbFieldNumber = 1, + kFillPolicyFieldNumber = 4, + kTransferOnCloneFieldNumber = 5, + kClearBeforeCloneFieldNumber = 6, + kNameFieldNumber = 7, + kExperimentalModeFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BufferConfig"; } - using FieldMetadata_SessionId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - AndroidCameraFrameEvent>; - static constexpr FieldMetadata_SessionId kSessionId{}; - void set_session_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); + using FillPolicy = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy; + static inline const char* FillPolicy_Name(FillPolicy value) { + return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy_Name(value); + } + + using ExperimentalMode = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode; + static inline const char* ExperimentalMode_Name(ExperimentalMode value) { + return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_ExperimentalMode_Name(value); } + static inline const FillPolicy UNSPECIFIED = FillPolicy::UNSPECIFIED; + static inline const FillPolicy RING_BUFFER = FillPolicy::RING_BUFFER; + static inline const FillPolicy DISCARD = FillPolicy::DISCARD; + static inline const ExperimentalMode MODE_UNSPECIFIED = ExperimentalMode::MODE_UNSPECIFIED; + static inline const ExperimentalMode TRACE_BUFFER_V2 = ExperimentalMode::TRACE_BUFFER_V2; - using FieldMetadata_CameraId = + using FieldMetadata_SizeKb = ::protozero::proto_utils::FieldMetadata< - 2, + 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kUint32, uint32_t, - AndroidCameraFrameEvent>; + TraceConfig_BufferConfig>; - static constexpr FieldMetadata_CameraId kCameraId{}; - void set_camera_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_CameraId::kFieldId; + static constexpr FieldMetadata_SizeKb kSizeKb{}; + void set_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -71066,299 +68687,408 @@ class AndroidCameraFrameEvent : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_FrameNumber = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent>; - - static constexpr FieldMetadata_FrameNumber kFrameNumber{}; - void set_frame_number(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_RequestId = + using FieldMetadata_FillPolicy = ::protozero::proto_utils::FieldMetadata< 4, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_BufferConfig_FillPolicy, + TraceConfig_BufferConfig>; - static constexpr FieldMetadata_RequestId kRequestId{}; - void set_request_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_RequestId::kFieldId; + static constexpr FieldMetadata_FillPolicy kFillPolicy{}; + void set_fill_policy(TraceConfig_BufferConfig_FillPolicy value) { + static constexpr uint32_t field_id = FieldMetadata_FillPolicy::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kEnum> ::Append(*this, field_id, value); } - using FieldMetadata_RequestReceivedNs = + using FieldMetadata_TransferOnClone = ::protozero::proto_utils::FieldMetadata< 5, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BufferConfig>; - static constexpr FieldMetadata_RequestReceivedNs kRequestReceivedNs{}; - void set_request_received_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_RequestReceivedNs::kFieldId; + static constexpr FieldMetadata_TransferOnClone kTransferOnClone{}; + void set_transfer_on_clone(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TransferOnClone::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_RequestProcessingStartedNs = + using FieldMetadata_ClearBeforeClone = ::protozero::proto_utils::FieldMetadata< 6, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BufferConfig>; - static constexpr FieldMetadata_RequestProcessingStartedNs kRequestProcessingStartedNs{}; - void set_request_processing_started_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_RequestProcessingStartedNs::kFieldId; + static constexpr FieldMetadata_ClearBeforeClone kClearBeforeClone{}; + void set_clear_before_clone(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ClearBeforeClone::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_StartOfExposureNs = + using FieldMetadata_Name = ::protozero::proto_utils::FieldMetadata< 7, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_BufferConfig>; - static constexpr FieldMetadata_StartOfExposureNs kStartOfExposureNs{}; - void set_start_of_exposure_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_StartOfExposureNs::kFieldId; + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_StartOfFrameNs = + using FieldMetadata_ExperimentalMode = ::protozero::proto_utils::FieldMetadata< 8, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_BufferConfig_ExperimentalMode, + TraceConfig_BufferConfig>; - static constexpr FieldMetadata_StartOfFrameNs kStartOfFrameNs{}; - void set_start_of_frame_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_StartOfFrameNs::kFieldId; + static constexpr FieldMetadata_ExperimentalMode kExperimentalMode{}; + void set_experimental_mode(TraceConfig_BufferConfig_ExperimentalMode value) { + static constexpr uint32_t field_id = FieldMetadata_ExperimentalMode::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kEnum> ::Append(*this, field_id, value); } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/clock_snapshot.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CLOCK_SNAPSHOT_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class ClockSnapshot_Clock; +enum BuiltinClock : int32_t; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +namespace perfetto_pbzero_enum_ClockSnapshot_Clock { +enum BuiltinClocks : int32_t { + UNKNOWN = 0, + REALTIME = 1, + REALTIME_COARSE = 2, + MONOTONIC = 3, + MONOTONIC_COARSE = 4, + MONOTONIC_RAW = 5, + BOOTTIME = 6, + BUILTIN_CLOCK_MAX_ID = 63, +}; +} // namespace perfetto_pbzero_enum_ClockSnapshot_Clock +using ClockSnapshot_Clock_BuiltinClocks = perfetto_pbzero_enum_ClockSnapshot_Clock::BuiltinClocks; + + +constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MIN = ClockSnapshot_Clock_BuiltinClocks::UNKNOWN; +constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MAX = ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ClockSnapshot_Clock_BuiltinClocks_Name(::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks value) { + switch (value) { + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::UNKNOWN: + return "UNKNOWN"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME: + return "REALTIME"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME_COARSE: + return "REALTIME_COARSE"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC: + return "MONOTONIC"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_COARSE: + return "MONOTONIC_COARSE"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_RAW: + return "MONOTONIC_RAW"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BOOTTIME: + return "BOOTTIME"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID: + return "BUILTIN_CLOCK_MAX_ID"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class ClockSnapshot_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClockSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClockSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClockSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_clocks() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> clocks() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_primary_trace_clock() const { return at<2>().valid(); } + int32_t primary_trace_clock() const { return at<2>().as_int32(); } +}; + +class ClockSnapshot : public ::protozero::Message { + public: + using Decoder = ClockSnapshot_Decoder; + enum : int32_t { + kClocksFieldNumber = 1, + kPrimaryTraceClockFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot"; } - using FieldMetadata_ResponsesAllSentNs = + using Clock = ::perfetto::protos::pbzero::ClockSnapshot_Clock; + + using FieldMetadata_Clocks = ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent>; + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClockSnapshot_Clock, + ClockSnapshot>; - static constexpr FieldMetadata_ResponsesAllSentNs kResponsesAllSentNs{}; - void set_responses_all_sent_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_ResponsesAllSentNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_Clocks kClocks{}; + template T* add_clocks() { + return BeginNestedMessage(1); } - using FieldMetadata_CaptureResultStatus = + + using FieldMetadata_PrimaryTraceClock = ::protozero::proto_utils::FieldMetadata< - 10, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kEnum, - AndroidCameraFrameEvent_CaptureResultStatus, - AndroidCameraFrameEvent>; + BuiltinClock, + ClockSnapshot>; - static constexpr FieldMetadata_CaptureResultStatus kCaptureResultStatus{}; - void set_capture_result_status(AndroidCameraFrameEvent_CaptureResultStatus value) { - static constexpr uint32_t field_id = FieldMetadata_CaptureResultStatus::kFieldId; + static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock{}; + void set_primary_trace_clock(BuiltinClock value) { + static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< ::protozero::proto_utils::ProtoSchemaType::kEnum> ::Append(*this, field_id, value); } +}; - using FieldMetadata_SkippedSensorFrames = - ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidCameraFrameEvent>; +class ClockSnapshot_Clock_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClockSnapshot_Clock_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClockSnapshot_Clock_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClockSnapshot_Clock_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_clock_id() const { return at<1>().valid(); } + uint32_t clock_id() const { return at<1>().as_uint32(); } + bool has_timestamp() const { return at<2>().valid(); } + uint64_t timestamp() const { return at<2>().as_uint64(); } + bool has_is_incremental() const { return at<3>().valid(); } + bool is_incremental() const { return at<3>().as_bool(); } + bool has_unit_multiplier_ns() const { return at<4>().valid(); } + uint64_t unit_multiplier_ns() const { return at<4>().as_uint64(); } +}; - static constexpr FieldMetadata_SkippedSensorFrames kSkippedSensorFrames{}; - void set_skipped_sensor_frames(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_SkippedSensorFrames::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); +class ClockSnapshot_Clock : public ::protozero::Message { + public: + using Decoder = ClockSnapshot_Clock_Decoder; + enum : int32_t { + kClockIdFieldNumber = 1, + kTimestampFieldNumber = 2, + kIsIncrementalFieldNumber = 3, + kUnitMultiplierNsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot.Clock"; } + + + using BuiltinClocks = ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks; + static inline const char* BuiltinClocks_Name(BuiltinClocks value) { + return ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks_Name(value); } + static inline const BuiltinClocks UNKNOWN = BuiltinClocks::UNKNOWN; + static inline const BuiltinClocks REALTIME = BuiltinClocks::REALTIME; + static inline const BuiltinClocks REALTIME_COARSE = BuiltinClocks::REALTIME_COARSE; + static inline const BuiltinClocks MONOTONIC = BuiltinClocks::MONOTONIC; + static inline const BuiltinClocks MONOTONIC_COARSE = BuiltinClocks::MONOTONIC_COARSE; + static inline const BuiltinClocks MONOTONIC_RAW = BuiltinClocks::MONOTONIC_RAW; + static inline const BuiltinClocks BOOTTIME = BuiltinClocks::BOOTTIME; + static inline const BuiltinClocks BUILTIN_CLOCK_MAX_ID = BuiltinClocks::BUILTIN_CLOCK_MAX_ID; - using FieldMetadata_CaptureIntent = + using FieldMetadata_ClockId = ::protozero::proto_utils::FieldMetadata< - 12, + 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ClockSnapshot_Clock>; - static constexpr FieldMetadata_CaptureIntent kCaptureIntent{}; - void set_capture_intent(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_CaptureIntent::kFieldId; + static constexpr FieldMetadata_ClockId kClockId{}; + void set_clock_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClockId::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } - using FieldMetadata_NumStreams = + using FieldMetadata_Timestamp = ::protozero::proto_utils::FieldMetadata< - 13, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockSnapshot_Clock>; - static constexpr FieldMetadata_NumStreams kNumStreams{}; - void set_num_streams(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_NumStreams::kFieldId; + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } - using FieldMetadata_NodeProcessingDetails = - ::protozero::proto_utils::FieldMetadata< - 14, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidCameraFrameEvent_CameraNodeProcessingDetails, - AndroidCameraFrameEvent>; - - static constexpr FieldMetadata_NodeProcessingDetails kNodeProcessingDetails{}; - template T* add_node_processing_details() { - return BeginNestedMessage(14); - } - - - using FieldMetadata_VendorDataVersion = + using FieldMetadata_IsIncremental = ::protozero::proto_utils::FieldMetadata< - 15, + 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ClockSnapshot_Clock>; - static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{}; - void set_vendor_data_version(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId; + static constexpr FieldMetadata_IsIncremental kIsIncremental{}; + void set_is_incremental(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_VendorData = + using FieldMetadata_UnitMultiplierNs = ::protozero::proto_utils::FieldMetadata< - 16, + 4, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBytes, - std::string, - AndroidCameraFrameEvent>; + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockSnapshot_Clock>; - static constexpr FieldMetadata_VendorData kVendorData{}; - void set_vendor_data(const uint8_t* data, size_t size) { - AppendBytes(FieldMetadata_VendorData::kFieldId, data, size); - } - void set_vendor_data(::protozero::ConstBytes bytes) { - AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size); - } - void set_vendor_data(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId; + static constexpr FieldMetadata_UnitMultiplierNs kUnitMultiplierNs{}; + void set_unit_multiplier_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnitMultiplierNs::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } }; -class AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder : public ::protozero::TypedProtoDecoder { +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/trace_uuid.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRACE_UUID_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class TraceUuid_Decoder : public ::protozero::TypedProtoDecoder { public: - AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_node_id() const { return at<1>().valid(); } - int64_t node_id() const { return at<1>().as_int64(); } - bool has_start_processing_ns() const { return at<2>().valid(); } - int64_t start_processing_ns() const { return at<2>().as_int64(); } - bool has_end_processing_ns() const { return at<3>().valid(); } - int64_t end_processing_ns() const { return at<3>().as_int64(); } - bool has_scheduling_latency_ns() const { return at<4>().valid(); } - int64_t scheduling_latency_ns() const { return at<4>().as_int64(); } + TraceUuid_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceUuid_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceUuid_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_msb() const { return at<1>().valid(); } + int64_t msb() const { return at<1>().as_int64(); } + bool has_lsb() const { return at<2>().valid(); } + int64_t lsb() const { return at<2>().as_int64(); } }; -class AndroidCameraFrameEvent_CameraNodeProcessingDetails : public ::protozero::Message { +class TraceUuid : public ::protozero::Message { public: - using Decoder = AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder; + using Decoder = TraceUuid_Decoder; enum : int32_t { - kNodeIdFieldNumber = 1, - kStartProcessingNsFieldNumber = 2, - kEndProcessingNsFieldNumber = 3, - kSchedulingLatencyNsFieldNumber = 4, + kMsbFieldNumber = 1, + kLsbFieldNumber = 2, }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails"; } + static constexpr const char* GetName() { return ".perfetto.protos.TraceUuid"; } - using FieldMetadata_NodeId = + using FieldMetadata_Msb = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kInt64, int64_t, - AndroidCameraFrameEvent_CameraNodeProcessingDetails>; + TraceUuid>; - static constexpr FieldMetadata_NodeId kNodeId{}; - void set_node_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_NodeId::kFieldId; + static constexpr FieldMetadata_Msb kMsb{}; + void set_msb(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Msb::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -71366,53 +69096,17 @@ class AndroidCameraFrameEvent_CameraNodeProcessingDetails : public ::protozero:: ::Append(*this, field_id, value); } - using FieldMetadata_StartProcessingNs = + using FieldMetadata_Lsb = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kInt64, int64_t, - AndroidCameraFrameEvent_CameraNodeProcessingDetails>; - - static constexpr FieldMetadata_StartProcessingNs kStartProcessingNs{}; - void set_start_processing_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_StartProcessingNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_EndProcessingNs = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent_CameraNodeProcessingDetails>; - - static constexpr FieldMetadata_EndProcessingNs kEndProcessingNs{}; - void set_end_processing_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_EndProcessingNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_SchedulingLatencyNs = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidCameraFrameEvent_CameraNodeProcessingDetails>; + TraceUuid>; - static constexpr FieldMetadata_SchedulingLatencyNs kSchedulingLatencyNs{}; - void set_scheduling_latency_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_SchedulingLatencyNs::kFieldId; + static constexpr FieldMetadata_Lsb kLsb{}; + void set_lsb(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lsb::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -71425,11 +69119,11 @@ class AndroidCameraFrameEvent_CameraNodeProcessingDetails : public ::protozero:: } // Namespace. } // Namespace. #endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/cpu_per_uid_data.pbzero.h +// gen_amalgamated begin header: gen/protos/perfetto/trace/trigger.pbzero.h // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CPU_PER_UID_DATA_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CPU_PER_UID_DATA_PROTO_H_ +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_TRIGGER_PROTO_H_ #include #include @@ -71445,74 +69139,115 @@ namespace perfetto { namespace protos { namespace pbzero { -class CpuPerUidData_Decoder : public ::protozero::TypedProtoDecoder { +class Trigger_Decoder : public ::protozero::TypedProtoDecoder { public: - CpuPerUidData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit CpuPerUidData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit CpuPerUidData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_cluster_count() const { return at<1>().valid(); } - uint32_t cluster_count() const { return at<1>().as_uint32(); } - bool has_uid() const { return at<2>().valid(); } - ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> uid(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(2, parse_error_ptr); } - bool has_total_time_ms() const { return at<3>().valid(); } - ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> total_time_ms(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(3, parse_error_ptr); } + Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trigger_name() const { return at<1>().valid(); } + ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); } + bool has_producer_name() const { return at<2>().valid(); } + ::protozero::ConstChars producer_name() const { return at<2>().as_string(); } + bool has_trusted_producer_uid() const { return at<3>().valid(); } + int32_t trusted_producer_uid() const { return at<3>().as_int32(); } + bool has_stop_delay_ms() const { return at<4>().valid(); } + uint64_t stop_delay_ms() const { return at<4>().as_uint64(); } }; -class CpuPerUidData : public ::protozero::Message { +class Trigger : public ::protozero::Message { public: - using Decoder = CpuPerUidData_Decoder; + using Decoder = Trigger_Decoder; enum : int32_t { - kClusterCountFieldNumber = 1, - kUidFieldNumber = 2, - kTotalTimeMsFieldNumber = 3, + kTriggerNameFieldNumber = 1, + kProducerNameFieldNumber = 2, + kTrustedProducerUidFieldNumber = 3, + kStopDelayMsFieldNumber = 4, }; - static constexpr const char* GetName() { return ".perfetto.protos.CpuPerUidData"; } + static constexpr const char* GetName() { return ".perfetto.protos.Trigger"; } - using FieldMetadata_ClusterCount = + using FieldMetadata_TriggerName = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - CpuPerUidData>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Trigger>; - static constexpr FieldMetadata_ClusterCount kClusterCount{}; - void set_cluster_count(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ClusterCount::kFieldId; + static constexpr FieldMetadata_TriggerName kTriggerName{}; + void set_trigger_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size); + } + void set_trigger_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size); + } + void set_trigger_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_Uid = + using FieldMetadata_ProducerName = ::protozero::proto_utils::FieldMetadata< 2, - ::protozero::proto_utils::RepetitionType::kRepeatedPacked, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - CpuPerUidData>; + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Trigger>; - static constexpr FieldMetadata_Uid kUid{}; - void set_uid(const ::protozero::PackedVarInt& packed_buffer) { - AppendBytes(FieldMetadata_Uid::kFieldId, packed_buffer.data(), - packed_buffer.size()); + static constexpr FieldMetadata_ProducerName kProducerName{}; + void set_producer_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size); + } + void set_producer_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size); + } + void set_producer_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); } - using FieldMetadata_TotalTimeMs = + using FieldMetadata_TrustedProducerUid = ::protozero::proto_utils::FieldMetadata< 3, - ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Trigger>; + + static constexpr FieldMetadata_TrustedProducerUid kTrustedProducerUid{}; + void set_trusted_producer_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TrustedProducerUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StopDelayMs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kUint64, uint64_t, - CpuPerUidData>; + Trigger>; - static constexpr FieldMetadata_TotalTimeMs kTotalTimeMs{}; - void set_total_time_ms(const ::protozero::PackedVarInt& packed_buffer) { - AppendBytes(FieldMetadata_TotalTimeMs::kFieldId, packed_buffer.data(), - packed_buffer.size()); + static constexpr FieldMetadata_StopDelayMs kStopDelayMs{}; + void set_stop_delay_ms(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); } }; @@ -71520,11 +69255,11 @@ class CpuPerUidData : public ::protozero::Message { } // Namespace. } // Namespace. #endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/frame_timeline_event.pbzero.h +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_aflags.pbzero.h // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_FRAME_TIMELINE_EVENT_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_FRAME_TIMELINE_EVENT_PROTO_H_ +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_AFLAGS_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_AFLAGS_PROTO_H_ #include #include @@ -71538,27 +69273,23 @@ class CpuPerUidData : public ::protozero::Message { namespace perfetto { namespace protos { namespace pbzero { -class FrameTimelineEvent_ActualDisplayFrameStart; -class FrameTimelineEvent_ActualSurfaceFrameStart; -class FrameTimelineEvent_ExpectedDisplayFrameStart; -class FrameTimelineEvent_ExpectedSurfaceFrameStart; -class FrameTimelineEvent_FrameEnd; -namespace perfetto_pbzero_enum_FrameTimelineEvent_ActualSurfaceFrameStart { -enum LatchedFenceState : int32_t; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent_ActualSurfaceFrameStart -using FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState = perfetto_pbzero_enum_FrameTimelineEvent_ActualSurfaceFrameStart::LatchedFenceState; -namespace perfetto_pbzero_enum_FrameTimelineEvent { -enum JankSeverityType : int32_t; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent -using FrameTimelineEvent_JankSeverityType = perfetto_pbzero_enum_FrameTimelineEvent::JankSeverityType; -namespace perfetto_pbzero_enum_FrameTimelineEvent { -enum PredictionType : int32_t; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent -using FrameTimelineEvent_PredictionType = perfetto_pbzero_enum_FrameTimelineEvent::PredictionType; -namespace perfetto_pbzero_enum_FrameTimelineEvent { -enum PresentType : int32_t; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent -using FrameTimelineEvent_PresentType = perfetto_pbzero_enum_FrameTimelineEvent::PresentType; +class AndroidAflags_Flag; +namespace perfetto_pbzero_enum_AndroidAflags { +enum FlagPermission : int32_t; +} // namespace perfetto_pbzero_enum_AndroidAflags +using AndroidAflags_FlagPermission = perfetto_pbzero_enum_AndroidAflags::FlagPermission; +namespace perfetto_pbzero_enum_AndroidAflags { +enum FlagStorageBackend : int32_t; +} // namespace perfetto_pbzero_enum_AndroidAflags +using AndroidAflags_FlagStorageBackend = perfetto_pbzero_enum_AndroidAflags::FlagStorageBackend; +namespace perfetto_pbzero_enum_AndroidAflags { +enum FlagType : int32_t; +} // namespace perfetto_pbzero_enum_AndroidAflags +using AndroidAflags_FlagType = perfetto_pbzero_enum_AndroidAflags::FlagType; +namespace perfetto_pbzero_enum_AndroidAflags { +enum ValuePickedFrom : int32_t; +} // namespace perfetto_pbzero_enum_AndroidAflags +using AndroidAflags_ValuePickedFrom = perfetto_pbzero_enum_AndroidAflags::ValuePickedFrom; } // Namespace pbzero. } // Namespace protos. } // Namespace perfetto. @@ -71567,625 +69298,443 @@ namespace perfetto { namespace protos { namespace pbzero { -namespace perfetto_pbzero_enum_FrameTimelineEvent { -enum JankType : int32_t { - JANK_UNSPECIFIED = 0, - JANK_NONE = 1, - JANK_SF_SCHEDULING = 2, - JANK_PREDICTION_ERROR = 4, - JANK_DISPLAY_HAL = 8, - JANK_SF_CPU_DEADLINE_MISSED = 16, - JANK_SF_GPU_DEADLINE_MISSED = 32, - JANK_APP_DEADLINE_MISSED = 64, - JANK_BUFFER_STUFFING = 128, - JANK_UNKNOWN = 256, - JANK_SF_STUFFING = 512, - JANK_DROPPED = 1024, - JANK_NON_ANIMATING = 2048, - JANK_APP_RESYNCED_JITTER = 4096, - JANK_DISPLAY_NOT_ON = 8192, - JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS = 16384, - JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS = 32768, -}; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent -using FrameTimelineEvent_JankType = perfetto_pbzero_enum_FrameTimelineEvent::JankType; - - -constexpr FrameTimelineEvent_JankType FrameTimelineEvent_JankType_MIN = FrameTimelineEvent_JankType::JANK_UNSPECIFIED; -constexpr FrameTimelineEvent_JankType FrameTimelineEvent_JankType_MAX = FrameTimelineEvent_JankType::JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* FrameTimelineEvent_JankType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_JankType value) { - switch (value) { - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_UNSPECIFIED: - return "JANK_UNSPECIFIED"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_NONE: - return "JANK_NONE"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_SCHEDULING: - return "JANK_SF_SCHEDULING"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_PREDICTION_ERROR: - return "JANK_PREDICTION_ERROR"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_HAL: - return "JANK_DISPLAY_HAL"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_CPU_DEADLINE_MISSED: - return "JANK_SF_CPU_DEADLINE_MISSED"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_GPU_DEADLINE_MISSED: - return "JANK_SF_GPU_DEADLINE_MISSED"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_APP_DEADLINE_MISSED: - return "JANK_APP_DEADLINE_MISSED"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_BUFFER_STUFFING: - return "JANK_BUFFER_STUFFING"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_UNKNOWN: - return "JANK_UNKNOWN"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_STUFFING: - return "JANK_SF_STUFFING"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DROPPED: - return "JANK_DROPPED"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_NON_ANIMATING: - return "JANK_NON_ANIMATING"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_APP_RESYNCED_JITTER: - return "JANK_APP_RESYNCED_JITTER"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_NOT_ON: - return "JANK_DISPLAY_NOT_ON"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS: - return "JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS: - return "JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_FrameTimelineEvent { -enum JankSeverityType : int32_t { - SEVERITY_UNKNOWN = 0, - SEVERITY_NONE = 1, - SEVERITY_PARTIAL = 2, - SEVERITY_FULL = 3, +namespace perfetto_pbzero_enum_AndroidAflags { +enum FlagPermission : int32_t { + FLAG_PERMISSION_UNSPECIFIED = 0, + FLAG_PERMISSION_READ_ONLY = 1, + FLAG_PERMISSION_READ_WRITE = 2, }; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent -using FrameTimelineEvent_JankSeverityType = perfetto_pbzero_enum_FrameTimelineEvent::JankSeverityType; +} // namespace perfetto_pbzero_enum_AndroidAflags +using AndroidAflags_FlagPermission = perfetto_pbzero_enum_AndroidAflags::FlagPermission; -constexpr FrameTimelineEvent_JankSeverityType FrameTimelineEvent_JankSeverityType_MIN = FrameTimelineEvent_JankSeverityType::SEVERITY_UNKNOWN; -constexpr FrameTimelineEvent_JankSeverityType FrameTimelineEvent_JankSeverityType_MAX = FrameTimelineEvent_JankSeverityType::SEVERITY_FULL; +constexpr AndroidAflags_FlagPermission AndroidAflags_FlagPermission_MIN = AndroidAflags_FlagPermission::FLAG_PERMISSION_UNSPECIFIED; +constexpr AndroidAflags_FlagPermission AndroidAflags_FlagPermission_MAX = AndroidAflags_FlagPermission::FLAG_PERMISSION_READ_WRITE; PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* FrameTimelineEvent_JankSeverityType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType value) { +const char* AndroidAflags_FlagPermission_Name(::perfetto::protos::pbzero::AndroidAflags_FlagPermission value) { switch (value) { - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_UNKNOWN: - return "SEVERITY_UNKNOWN"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_NONE: - return "SEVERITY_NONE"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagPermission::FLAG_PERMISSION_UNSPECIFIED: + return "FLAG_PERMISSION_UNSPECIFIED"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_PARTIAL: - return "SEVERITY_PARTIAL"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagPermission::FLAG_PERMISSION_READ_ONLY: + return "FLAG_PERMISSION_READ_ONLY"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_FULL: - return "SEVERITY_FULL"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagPermission::FLAG_PERMISSION_READ_WRITE: + return "FLAG_PERMISSION_READ_WRITE"; } return "PBZERO_UNKNOWN_ENUM_VALUE"; } -namespace perfetto_pbzero_enum_FrameTimelineEvent { -enum PresentType : int32_t { - PRESENT_UNSPECIFIED = 0, - PRESENT_ON_TIME = 1, - PRESENT_LATE = 2, - PRESENT_EARLY = 3, - PRESENT_DROPPED = 4, - PRESENT_UNKNOWN = 5, +namespace perfetto_pbzero_enum_AndroidAflags { +enum ValuePickedFrom : int32_t { + VALUE_PICKED_FROM_UNSPECIFIED = 0, + VALUE_PICKED_FROM_DEFAULT = 1, + VALUE_PICKED_FROM_SERVER = 2, + VALUE_PICKED_FROM_LOCAL = 3, }; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent -using FrameTimelineEvent_PresentType = perfetto_pbzero_enum_FrameTimelineEvent::PresentType; +} // namespace perfetto_pbzero_enum_AndroidAflags +using AndroidAflags_ValuePickedFrom = perfetto_pbzero_enum_AndroidAflags::ValuePickedFrom; -constexpr FrameTimelineEvent_PresentType FrameTimelineEvent_PresentType_MIN = FrameTimelineEvent_PresentType::PRESENT_UNSPECIFIED; -constexpr FrameTimelineEvent_PresentType FrameTimelineEvent_PresentType_MAX = FrameTimelineEvent_PresentType::PRESENT_UNKNOWN; +constexpr AndroidAflags_ValuePickedFrom AndroidAflags_ValuePickedFrom_MIN = AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_UNSPECIFIED; +constexpr AndroidAflags_ValuePickedFrom AndroidAflags_ValuePickedFrom_MAX = AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_LOCAL; PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* FrameTimelineEvent_PresentType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_PresentType value) { +const char* AndroidAflags_ValuePickedFrom_Name(::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom value) { switch (value) { - case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_UNSPECIFIED: - return "PRESENT_UNSPECIFIED"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_ON_TIME: - return "PRESENT_ON_TIME"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_LATE: - return "PRESENT_LATE"; + case ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_UNSPECIFIED: + return "VALUE_PICKED_FROM_UNSPECIFIED"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_EARLY: - return "PRESENT_EARLY"; + case ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_DEFAULT: + return "VALUE_PICKED_FROM_DEFAULT"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_DROPPED: - return "PRESENT_DROPPED"; + case ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_SERVER: + return "VALUE_PICKED_FROM_SERVER"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_UNKNOWN: - return "PRESENT_UNKNOWN"; + case ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom::VALUE_PICKED_FROM_LOCAL: + return "VALUE_PICKED_FROM_LOCAL"; } return "PBZERO_UNKNOWN_ENUM_VALUE"; } -namespace perfetto_pbzero_enum_FrameTimelineEvent { -enum PredictionType : int32_t { - PREDICTION_UNSPECIFIED = 0, - PREDICTION_VALID = 1, - PREDICTION_EXPIRED = 2, - PREDICTION_UNKNOWN = 3, +namespace perfetto_pbzero_enum_AndroidAflags { +enum FlagStorageBackend : int32_t { + FLAG_STORAGE_BACKEND_UNSPECIFIED = 0, + FLAG_STORAGE_BACKEND_NONE = 1, + FLAG_STORAGE_BACKEND_ACONFIGD = 2, + FLAG_STORAGE_BACKEND_DEVICE_CONFIG = 3, }; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent -using FrameTimelineEvent_PredictionType = perfetto_pbzero_enum_FrameTimelineEvent::PredictionType; +} // namespace perfetto_pbzero_enum_AndroidAflags +using AndroidAflags_FlagStorageBackend = perfetto_pbzero_enum_AndroidAflags::FlagStorageBackend; -constexpr FrameTimelineEvent_PredictionType FrameTimelineEvent_PredictionType_MIN = FrameTimelineEvent_PredictionType::PREDICTION_UNSPECIFIED; -constexpr FrameTimelineEvent_PredictionType FrameTimelineEvent_PredictionType_MAX = FrameTimelineEvent_PredictionType::PREDICTION_UNKNOWN; +constexpr AndroidAflags_FlagStorageBackend AndroidAflags_FlagStorageBackend_MIN = AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_UNSPECIFIED; +constexpr AndroidAflags_FlagStorageBackend AndroidAflags_FlagStorageBackend_MAX = AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_DEVICE_CONFIG; PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* FrameTimelineEvent_PredictionType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType value) { +const char* AndroidAflags_FlagStorageBackend_Name(::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend value) { switch (value) { - case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_UNSPECIFIED: - return "PREDICTION_UNSPECIFIED"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_UNSPECIFIED: + return "FLAG_STORAGE_BACKEND_UNSPECIFIED"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_VALID: - return "PREDICTION_VALID"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_NONE: + return "FLAG_STORAGE_BACKEND_NONE"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_EXPIRED: - return "PREDICTION_EXPIRED"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_ACONFIGD: + return "FLAG_STORAGE_BACKEND_ACONFIGD"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_UNKNOWN: - return "PREDICTION_UNKNOWN"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend::FLAG_STORAGE_BACKEND_DEVICE_CONFIG: + return "FLAG_STORAGE_BACKEND_DEVICE_CONFIG"; } return "PBZERO_UNKNOWN_ENUM_VALUE"; } -namespace perfetto_pbzero_enum_FrameTimelineEvent_ActualSurfaceFrameStart { -enum LatchedFenceState : int32_t { - LATCHED_UNKNOWN = 0, - LATCHED_SIGNALED = 1, - LATCHED_UNSIGNALED = 2, - LATCHED_DELAYED_LATCH_UNSIGNALED = 3, +namespace perfetto_pbzero_enum_AndroidAflags { +enum FlagType : int32_t { + FLAG_TYPE_UNSPECIFIED = 0, + FLAG_TYPE_BOOLEAN = 1, + FLAG_TYPE_INTEGER = 2, }; -} // namespace perfetto_pbzero_enum_FrameTimelineEvent_ActualSurfaceFrameStart -using FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState = perfetto_pbzero_enum_FrameTimelineEvent_ActualSurfaceFrameStart::LatchedFenceState; +} // namespace perfetto_pbzero_enum_AndroidAflags +using AndroidAflags_FlagType = perfetto_pbzero_enum_AndroidAflags::FlagType; -constexpr FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState_MIN = FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState::LATCHED_UNKNOWN; -constexpr FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState_MAX = FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState::LATCHED_DELAYED_LATCH_UNSIGNALED; +constexpr AndroidAflags_FlagType AndroidAflags_FlagType_MIN = AndroidAflags_FlagType::FLAG_TYPE_UNSPECIFIED; +constexpr AndroidAflags_FlagType AndroidAflags_FlagType_MAX = AndroidAflags_FlagType::FLAG_TYPE_INTEGER; PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState_Name(::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState value) { +const char* AndroidAflags_FlagType_Name(::perfetto::protos::pbzero::AndroidAflags_FlagType value) { switch (value) { - case ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState::LATCHED_UNKNOWN: - return "LATCHED_UNKNOWN"; - - case ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState::LATCHED_SIGNALED: - return "LATCHED_SIGNALED"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagType::FLAG_TYPE_UNSPECIFIED: + return "FLAG_TYPE_UNSPECIFIED"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState::LATCHED_UNSIGNALED: - return "LATCHED_UNSIGNALED"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagType::FLAG_TYPE_BOOLEAN: + return "FLAG_TYPE_BOOLEAN"; - case ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState::LATCHED_DELAYED_LATCH_UNSIGNALED: - return "LATCHED_DELAYED_LATCH_UNSIGNALED"; + case ::perfetto::protos::pbzero::AndroidAflags_FlagType::FLAG_TYPE_INTEGER: + return "FLAG_TYPE_INTEGER"; } return "PBZERO_UNKNOWN_ENUM_VALUE"; } -class FrameTimelineEvent_Decoder : public ::protozero::TypedProtoDecoder { - public: - FrameTimelineEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit FrameTimelineEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit FrameTimelineEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_expected_display_frame_start() const { return at<1>().valid(); } - ::protozero::ConstBytes expected_display_frame_start() const { return at<1>().as_bytes(); } - bool has_actual_display_frame_start() const { return at<2>().valid(); } - ::protozero::ConstBytes actual_display_frame_start() const { return at<2>().as_bytes(); } - bool has_expected_surface_frame_start() const { return at<3>().valid(); } - ::protozero::ConstBytes expected_surface_frame_start() const { return at<3>().as_bytes(); } - bool has_actual_surface_frame_start() const { return at<4>().valid(); } - ::protozero::ConstBytes actual_surface_frame_start() const { return at<4>().as_bytes(); } - bool has_frame_end() const { return at<5>().valid(); } - ::protozero::ConstBytes frame_end() const { return at<5>().as_bytes(); } -}; - -class FrameTimelineEvent : public ::protozero::Message { - public: - using Decoder = FrameTimelineEvent_Decoder; - enum : int32_t { - kExpectedDisplayFrameStartFieldNumber = 1, - kActualDisplayFrameStartFieldNumber = 2, - kExpectedSurfaceFrameStartFieldNumber = 3, - kActualSurfaceFrameStartFieldNumber = 4, - kFrameEndFieldNumber = 5, - }; - static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent"; } - - using ExpectedSurfaceFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ExpectedSurfaceFrameStart; - using ActualSurfaceFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart; - using ExpectedDisplayFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ExpectedDisplayFrameStart; - using ActualDisplayFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualDisplayFrameStart; - using FrameEnd = ::perfetto::protos::pbzero::FrameTimelineEvent_FrameEnd; - - using JankType = ::perfetto::protos::pbzero::FrameTimelineEvent_JankType; - static inline const char* JankType_Name(JankType value) { - return ::perfetto::protos::pbzero::FrameTimelineEvent_JankType_Name(value); - } - - using JankSeverityType = ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType; - static inline const char* JankSeverityType_Name(JankSeverityType value) { - return ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType_Name(value); - } - - using PresentType = ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType; - static inline const char* PresentType_Name(PresentType value) { - return ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType_Name(value); - } - - using PredictionType = ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType; - static inline const char* PredictionType_Name(PredictionType value) { - return ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType_Name(value); - } - static inline const JankType JANK_UNSPECIFIED = JankType::JANK_UNSPECIFIED; - static inline const JankType JANK_NONE = JankType::JANK_NONE; - static inline const JankType JANK_SF_SCHEDULING = JankType::JANK_SF_SCHEDULING; - static inline const JankType JANK_PREDICTION_ERROR = JankType::JANK_PREDICTION_ERROR; - static inline const JankType JANK_DISPLAY_HAL = JankType::JANK_DISPLAY_HAL; - static inline const JankType JANK_SF_CPU_DEADLINE_MISSED = JankType::JANK_SF_CPU_DEADLINE_MISSED; - static inline const JankType JANK_SF_GPU_DEADLINE_MISSED = JankType::JANK_SF_GPU_DEADLINE_MISSED; - static inline const JankType JANK_APP_DEADLINE_MISSED = JankType::JANK_APP_DEADLINE_MISSED; - static inline const JankType JANK_BUFFER_STUFFING = JankType::JANK_BUFFER_STUFFING; - static inline const JankType JANK_UNKNOWN = JankType::JANK_UNKNOWN; - static inline const JankType JANK_SF_STUFFING = JankType::JANK_SF_STUFFING; - static inline const JankType JANK_DROPPED = JankType::JANK_DROPPED; - static inline const JankType JANK_NON_ANIMATING = JankType::JANK_NON_ANIMATING; - static inline const JankType JANK_APP_RESYNCED_JITTER = JankType::JANK_APP_RESYNCED_JITTER; - static inline const JankType JANK_DISPLAY_NOT_ON = JankType::JANK_DISPLAY_NOT_ON; - static inline const JankType JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS = JankType::JANK_DISPLAY_MODE_CHANGE_IN_PROGRESS; - static inline const JankType JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS = JankType::JANK_DISPLAY_POWER_MODE_CHANGE_IN_PROGRESS; - static inline const JankSeverityType SEVERITY_UNKNOWN = JankSeverityType::SEVERITY_UNKNOWN; - static inline const JankSeverityType SEVERITY_NONE = JankSeverityType::SEVERITY_NONE; - static inline const JankSeverityType SEVERITY_PARTIAL = JankSeverityType::SEVERITY_PARTIAL; - static inline const JankSeverityType SEVERITY_FULL = JankSeverityType::SEVERITY_FULL; - static inline const PresentType PRESENT_UNSPECIFIED = PresentType::PRESENT_UNSPECIFIED; - static inline const PresentType PRESENT_ON_TIME = PresentType::PRESENT_ON_TIME; - static inline const PresentType PRESENT_LATE = PresentType::PRESENT_LATE; - static inline const PresentType PRESENT_EARLY = PresentType::PRESENT_EARLY; - static inline const PresentType PRESENT_DROPPED = PresentType::PRESENT_DROPPED; - static inline const PresentType PRESENT_UNKNOWN = PresentType::PRESENT_UNKNOWN; - static inline const PredictionType PREDICTION_UNSPECIFIED = PredictionType::PREDICTION_UNSPECIFIED; - static inline const PredictionType PREDICTION_VALID = PredictionType::PREDICTION_VALID; - static inline const PredictionType PREDICTION_EXPIRED = PredictionType::PREDICTION_EXPIRED; - static inline const PredictionType PREDICTION_UNKNOWN = PredictionType::PREDICTION_UNKNOWN; - - using FieldMetadata_ExpectedDisplayFrameStart = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FrameTimelineEvent_ExpectedDisplayFrameStart, - FrameTimelineEvent>; - - static constexpr FieldMetadata_ExpectedDisplayFrameStart kExpectedDisplayFrameStart{}; - template T* set_expected_display_frame_start() { - return BeginNestedMessage(1); - } +class AndroidAflags_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidAflags_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidAflags_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidAflags_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_flags() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> flags() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_error() const { return at<2>().valid(); } + ::protozero::ConstChars error() const { return at<2>().as_string(); } +}; +class AndroidAflags : public ::protozero::Message { + public: + using Decoder = AndroidAflags_Decoder; + enum : int32_t { + kFlagsFieldNumber = 1, + kErrorFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidAflags"; } - using FieldMetadata_ActualDisplayFrameStart = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FrameTimelineEvent_ActualDisplayFrameStart, - FrameTimelineEvent>; + using Flag = ::perfetto::protos::pbzero::AndroidAflags_Flag; - static constexpr FieldMetadata_ActualDisplayFrameStart kActualDisplayFrameStart{}; - template T* set_actual_display_frame_start() { - return BeginNestedMessage(2); + using FlagPermission = ::perfetto::protos::pbzero::AndroidAflags_FlagPermission; + static inline const char* FlagPermission_Name(FlagPermission value) { + return ::perfetto::protos::pbzero::AndroidAflags_FlagPermission_Name(value); } - - using FieldMetadata_ExpectedSurfaceFrameStart = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FrameTimelineEvent_ExpectedSurfaceFrameStart, - FrameTimelineEvent>; - - static constexpr FieldMetadata_ExpectedSurfaceFrameStart kExpectedSurfaceFrameStart{}; - template T* set_expected_surface_frame_start() { - return BeginNestedMessage(3); + using ValuePickedFrom = ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom; + static inline const char* ValuePickedFrom_Name(ValuePickedFrom value) { + return ::perfetto::protos::pbzero::AndroidAflags_ValuePickedFrom_Name(value); } - - using FieldMetadata_ActualSurfaceFrameStart = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FrameTimelineEvent_ActualSurfaceFrameStart, - FrameTimelineEvent>; - - static constexpr FieldMetadata_ActualSurfaceFrameStart kActualSurfaceFrameStart{}; - template T* set_actual_surface_frame_start() { - return BeginNestedMessage(4); + using FlagStorageBackend = ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend; + static inline const char* FlagStorageBackend_Name(FlagStorageBackend value) { + return ::perfetto::protos::pbzero::AndroidAflags_FlagStorageBackend_Name(value); } + using FlagType = ::perfetto::protos::pbzero::AndroidAflags_FlagType; + static inline const char* FlagType_Name(FlagType value) { + return ::perfetto::protos::pbzero::AndroidAflags_FlagType_Name(value); + } + static inline const FlagPermission FLAG_PERMISSION_UNSPECIFIED = FlagPermission::FLAG_PERMISSION_UNSPECIFIED; + static inline const FlagPermission FLAG_PERMISSION_READ_ONLY = FlagPermission::FLAG_PERMISSION_READ_ONLY; + static inline const FlagPermission FLAG_PERMISSION_READ_WRITE = FlagPermission::FLAG_PERMISSION_READ_WRITE; + static inline const ValuePickedFrom VALUE_PICKED_FROM_UNSPECIFIED = ValuePickedFrom::VALUE_PICKED_FROM_UNSPECIFIED; + static inline const ValuePickedFrom VALUE_PICKED_FROM_DEFAULT = ValuePickedFrom::VALUE_PICKED_FROM_DEFAULT; + static inline const ValuePickedFrom VALUE_PICKED_FROM_SERVER = ValuePickedFrom::VALUE_PICKED_FROM_SERVER; + static inline const ValuePickedFrom VALUE_PICKED_FROM_LOCAL = ValuePickedFrom::VALUE_PICKED_FROM_LOCAL; + static inline const FlagStorageBackend FLAG_STORAGE_BACKEND_UNSPECIFIED = FlagStorageBackend::FLAG_STORAGE_BACKEND_UNSPECIFIED; + static inline const FlagStorageBackend FLAG_STORAGE_BACKEND_NONE = FlagStorageBackend::FLAG_STORAGE_BACKEND_NONE; + static inline const FlagStorageBackend FLAG_STORAGE_BACKEND_ACONFIGD = FlagStorageBackend::FLAG_STORAGE_BACKEND_ACONFIGD; + static inline const FlagStorageBackend FLAG_STORAGE_BACKEND_DEVICE_CONFIG = FlagStorageBackend::FLAG_STORAGE_BACKEND_DEVICE_CONFIG; + static inline const FlagType FLAG_TYPE_UNSPECIFIED = FlagType::FLAG_TYPE_UNSPECIFIED; + static inline const FlagType FLAG_TYPE_BOOLEAN = FlagType::FLAG_TYPE_BOOLEAN; + static inline const FlagType FLAG_TYPE_INTEGER = FlagType::FLAG_TYPE_INTEGER; - using FieldMetadata_FrameEnd = + using FieldMetadata_Flags = ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, ::protozero::proto_utils::ProtoSchemaType::kMessage, - FrameTimelineEvent_FrameEnd, - FrameTimelineEvent>; + AndroidAflags_Flag, + AndroidAflags>; - static constexpr FieldMetadata_FrameEnd kFrameEnd{}; - template T* set_frame_end() { - return BeginNestedMessage(5); + static constexpr FieldMetadata_Flags kFlags{}; + template T* add_flags() { + return BeginNestedMessage(1); } -}; - -class FrameTimelineEvent_FrameEnd_Decoder : public ::protozero::TypedProtoDecoder { - public: - FrameTimelineEvent_FrameEnd_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit FrameTimelineEvent_FrameEnd_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit FrameTimelineEvent_FrameEnd_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_cookie() const { return at<1>().valid(); } - int64_t cookie() const { return at<1>().as_int64(); } -}; - -class FrameTimelineEvent_FrameEnd : public ::protozero::Message { - public: - using Decoder = FrameTimelineEvent_FrameEnd_Decoder; - enum : int32_t { - kCookieFieldNumber = 1, - }; - static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.FrameEnd"; } - - using FieldMetadata_Cookie = + using FieldMetadata_Error = ::protozero::proto_utils::FieldMetadata< - 1, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_FrameEnd>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidAflags>; - static constexpr FieldMetadata_Cookie kCookie{}; - void set_cookie(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + static constexpr FieldMetadata_Error kError{}; + void set_error(const char* data, size_t size) { + AppendBytes(FieldMetadata_Error::kFieldId, data, size); + } + void set_error(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Error::kFieldId, chars.data, chars.size); + } + void set_error(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } }; -class FrameTimelineEvent_ActualDisplayFrameStart_Decoder : public ::protozero::TypedProtoDecoder { +class AndroidAflags_Flag_Decoder : public ::protozero::TypedProtoDecoder { public: - FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_cookie() const { return at<1>().valid(); } - int64_t cookie() const { return at<1>().as_int64(); } - bool has_token() const { return at<2>().valid(); } - int64_t token() const { return at<2>().as_int64(); } - bool has_pid() const { return at<3>().valid(); } - int32_t pid() const { return at<3>().as_int32(); } - bool has_present_type() const { return at<4>().valid(); } - int32_t present_type() const { return at<4>().as_int32(); } - bool has_on_time_finish() const { return at<5>().valid(); } - bool on_time_finish() const { return at<5>().as_bool(); } - bool has_gpu_composition() const { return at<6>().valid(); } - bool gpu_composition() const { return at<6>().as_bool(); } - bool has_jank_type() const { return at<7>().valid(); } - int32_t jank_type() const { return at<7>().as_int32(); } - bool has_prediction_type() const { return at<8>().valid(); } - int32_t prediction_type() const { return at<8>().as_int32(); } - bool has_jank_severity_type() const { return at<9>().valid(); } - int32_t jank_severity_type() const { return at<9>().as_int32(); } - bool has_present_delay_millis() const { return at<10>().valid(); } - float present_delay_millis() const { return at<10>().as_float(); } - bool has_jank_severity_score() const { return at<11>().valid(); } - float jank_severity_score() const { return at<11>().as_float(); } - bool has_jank_type_experimental() const { return at<12>().valid(); } - int32_t jank_type_experimental() const { return at<12>().as_int32(); } - bool has_present_type_experimental() const { return at<13>().valid(); } - int32_t present_type_experimental() const { return at<13>().as_int32(); } - bool has_jank_debug_metadata() const { return at<14>().valid(); } - float jank_debug_metadata() const { return at<14>().as_float(); } - bool has_latched_unsignaled_count() const { return at<15>().valid(); } - int64_t latched_unsignaled_count() const { return at<15>().as_int64(); } - bool has_addressable_unsignaled_latch_count() const { return at<16>().valid(); } - int64_t addressable_unsignaled_latch_count() const { return at<16>().as_int64(); } -}; - -class FrameTimelineEvent_ActualDisplayFrameStart : public ::protozero::Message { - public: - using Decoder = FrameTimelineEvent_ActualDisplayFrameStart_Decoder; - enum : int32_t { - kCookieFieldNumber = 1, - kTokenFieldNumber = 2, - kPidFieldNumber = 3, - kPresentTypeFieldNumber = 4, - kOnTimeFinishFieldNumber = 5, - kGpuCompositionFieldNumber = 6, - kJankTypeFieldNumber = 7, - kPredictionTypeFieldNumber = 8, - kJankSeverityTypeFieldNumber = 9, - kPresentDelayMillisFieldNumber = 10, - kJankSeverityScoreFieldNumber = 11, - kJankTypeExperimentalFieldNumber = 12, - kPresentTypeExperimentalFieldNumber = 13, - kJankDebugMetadataFieldNumber = 14, - kLatchedUnsignaledCountFieldNumber = 15, - kAddressableUnsignaledLatchCountFieldNumber = 16, + AndroidAflags_Flag_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidAflags_Flag_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidAflags_Flag_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_flag_namespace() const { return at<1>().valid(); } + ::protozero::ConstChars flag_namespace() const { return at<1>().as_string(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_pkg() const { return at<3>().valid(); } + ::protozero::ConstChars pkg() const { return at<3>().as_string(); } + bool has_container() const { return at<4>().valid(); } + ::protozero::ConstChars container() const { return at<4>().as_string(); } + bool has_value() const { return at<5>().valid(); } + ::protozero::ConstChars value() const { return at<5>().as_string(); } + bool has_staged_value() const { return at<6>().valid(); } + ::protozero::ConstChars staged_value() const { return at<6>().as_string(); } + bool has_permission() const { return at<7>().valid(); } + int32_t permission() const { return at<7>().as_int32(); } + bool has_value_picked_from() const { return at<8>().valid(); } + int32_t value_picked_from() const { return at<8>().as_int32(); } + bool has_storage_backend() const { return at<9>().valid(); } + int32_t storage_backend() const { return at<9>().as_int32(); } + bool has_type() const { return at<10>().valid(); } + int32_t type() const { return at<10>().as_int32(); } +}; + +class AndroidAflags_Flag : public ::protozero::Message { + public: + using Decoder = AndroidAflags_Flag_Decoder; + enum : int32_t { + kFlagNamespaceFieldNumber = 1, + kNameFieldNumber = 2, + kPkgFieldNumber = 3, + kContainerFieldNumber = 4, + kValueFieldNumber = 5, + kStagedValueFieldNumber = 6, + kPermissionFieldNumber = 7, + kValuePickedFromFieldNumber = 8, + kStorageBackendFieldNumber = 9, + kTypeFieldNumber = 10, }; - static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ActualDisplayFrameStart"; } + static constexpr const char* GetName() { return ".perfetto.protos.AndroidAflags.Flag"; } - using FieldMetadata_Cookie = + using FieldMetadata_FlagNamespace = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidAflags_Flag>; - static constexpr FieldMetadata_Cookie kCookie{}; - void set_cookie(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + static constexpr FieldMetadata_FlagNamespace kFlagNamespace{}; + void set_flag_namespace(const char* data, size_t size) { + AppendBytes(FieldMetadata_FlagNamespace::kFieldId, data, size); + } + void set_flag_namespace(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FlagNamespace::kFieldId, chars.data, chars.size); + } + void set_flag_namespace(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FlagNamespace::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_Token = + using FieldMetadata_Name = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidAflags_Flag>; - static constexpr FieldMetadata_Token kToken{}; - void set_token(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId; + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_Pid = + using FieldMetadata_Pkg = ::protozero::proto_utils::FieldMetadata< 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidAflags_Flag>; - static constexpr FieldMetadata_Pid kPid{}; - void set_pid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + static constexpr FieldMetadata_Pkg kPkg{}; + void set_pkg(const char* data, size_t size) { + AppendBytes(FieldMetadata_Pkg::kFieldId, data, size); + } + void set_pkg(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Pkg::kFieldId, chars.data, chars.size); + } + void set_pkg(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Pkg::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_PresentType = + using FieldMetadata_Container = ::protozero::proto_utils::FieldMetadata< 4, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_PresentType, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidAflags_Flag>; - static constexpr FieldMetadata_PresentType kPresentType{}; - void set_present_type(FrameTimelineEvent_PresentType value) { - static constexpr uint32_t field_id = FieldMetadata_PresentType::kFieldId; + static constexpr FieldMetadata_Container kContainer{}; + void set_container(const char* data, size_t size) { + AppendBytes(FieldMetadata_Container::kFieldId, data, size); + } + void set_container(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Container::kFieldId, chars.data, chars.size); + } + void set_container(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Container::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_OnTimeFinish = + using FieldMetadata_Value = ::protozero::proto_utils::FieldMetadata< 5, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidAflags_Flag>; - static constexpr FieldMetadata_OnTimeFinish kOnTimeFinish{}; - void set_on_time_finish(bool value) { - static constexpr uint32_t field_id = FieldMetadata_OnTimeFinish::kFieldId; + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_GpuComposition = + using FieldMetadata_StagedValue = ::protozero::proto_utils::FieldMetadata< 6, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidAflags_Flag>; - static constexpr FieldMetadata_GpuComposition kGpuComposition{}; - void set_gpu_composition(bool value) { - static constexpr uint32_t field_id = FieldMetadata_GpuComposition::kFieldId; + static constexpr FieldMetadata_StagedValue kStagedValue{}; + void set_staged_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StagedValue::kFieldId, data, size); + } + void set_staged_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StagedValue::kFieldId, chars.data, chars.size); + } + void set_staged_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StagedValue::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_JankType = + using FieldMetadata_Permission = ::protozero::proto_utils::FieldMetadata< 7, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidAflags_FlagPermission, + AndroidAflags_Flag>; - static constexpr FieldMetadata_JankType kJankType{}; - void set_jank_type(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_JankType::kFieldId; + static constexpr FieldMetadata_Permission kPermission{}; + void set_permission(AndroidAflags_FlagPermission value) { + static constexpr uint32_t field_id = FieldMetadata_Permission::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kEnum> ::Append(*this, field_id, value); } - using FieldMetadata_PredictionType = + using FieldMetadata_ValuePickedFrom = ::protozero::proto_utils::FieldMetadata< 8, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_PredictionType, - FrameTimelineEvent_ActualDisplayFrameStart>; + AndroidAflags_ValuePickedFrom, + AndroidAflags_Flag>; - static constexpr FieldMetadata_PredictionType kPredictionType{}; - void set_prediction_type(FrameTimelineEvent_PredictionType value) { - static constexpr uint32_t field_id = FieldMetadata_PredictionType::kFieldId; + static constexpr FieldMetadata_ValuePickedFrom kValuePickedFrom{}; + void set_value_picked_from(AndroidAflags_ValuePickedFrom value) { + static constexpr uint32_t field_id = FieldMetadata_ValuePickedFrom::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -72193,17 +69742,17 @@ class FrameTimelineEvent_ActualDisplayFrameStart : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_JankSeverityType = + using FieldMetadata_StorageBackend = ::protozero::proto_utils::FieldMetadata< 9, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_JankSeverityType, - FrameTimelineEvent_ActualDisplayFrameStart>; + AndroidAflags_FlagStorageBackend, + AndroidAflags_Flag>; - static constexpr FieldMetadata_JankSeverityType kJankSeverityType{}; - void set_jank_severity_type(FrameTimelineEvent_JankSeverityType value) { - static constexpr uint32_t field_id = FieldMetadata_JankSeverityType::kFieldId; + static constexpr FieldMetadata_StorageBackend kStorageBackend{}; + void set_storage_backend(AndroidAflags_FlagStorageBackend value) { + static constexpr uint32_t field_id = FieldMetadata_StorageBackend::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -72211,403 +69760,556 @@ class FrameTimelineEvent_ActualDisplayFrameStart : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_PresentDelayMillis = + using FieldMetadata_Type = ::protozero::proto_utils::FieldMetadata< 10, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidAflags_FlagType, + AndroidAflags_Flag>; - static constexpr FieldMetadata_PresentDelayMillis kPresentDelayMillis{}; - void set_present_delay_millis(float value) { - static constexpr uint32_t field_id = FieldMetadata_PresentDelayMillis::kFieldId; + static constexpr FieldMetadata_Type kType{}; + void set_type(AndroidAflags_FlagType value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::protozero::proto_utils::ProtoSchemaType::kEnum> ::Append(*this, field_id, value); } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_game_intervention_list.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_GAME_INTERVENTION_LIST_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_GAME_INTERVENTION_LIST_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class AndroidGameInterventionList_GameModeInfo; +class AndroidGameInterventionList_GamePackageInfo; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. - using FieldMetadata_JankSeverityScore = +namespace perfetto { +namespace protos { +namespace pbzero { + +class AndroidGameInterventionList_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidGameInterventionList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidGameInterventionList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidGameInterventionList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_game_packages() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_packages() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_parse_error() const { return at<2>().valid(); } + bool parse_error() const { return at<2>().as_bool(); } + bool has_read_error() const { return at<3>().valid(); } + bool read_error() const { return at<3>().as_bool(); } +}; + +class AndroidGameInterventionList : public ::protozero::Message { + public: + using Decoder = AndroidGameInterventionList_Decoder; + enum : int32_t { + kGamePackagesFieldNumber = 1, + kParseErrorFieldNumber = 2, + kReadErrorFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList"; } + + using GameModeInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GameModeInfo; + using GamePackageInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GamePackageInfo; + + using FieldMetadata_GamePackages = ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FrameTimelineEvent_ActualDisplayFrameStart>; + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidGameInterventionList_GamePackageInfo, + AndroidGameInterventionList>; - static constexpr FieldMetadata_JankSeverityScore kJankSeverityScore{}; - void set_jank_severity_score(float value) { - static constexpr uint32_t field_id = FieldMetadata_JankSeverityScore::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_GamePackages kGamePackages{}; + template T* add_game_packages() { + return BeginNestedMessage(1); } - using FieldMetadata_JankTypeExperimental = + + using FieldMetadata_ParseError = ::protozero::proto_utils::FieldMetadata< - 12, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidGameInterventionList>; - static constexpr FieldMetadata_JankTypeExperimental kJankTypeExperimental{}; - void set_jank_type_experimental(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_JankTypeExperimental::kFieldId; + static constexpr FieldMetadata_ParseError kParseError{}; + void set_parse_error(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ParseError::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_PresentTypeExperimental = + using FieldMetadata_ReadError = ::protozero::proto_utils::FieldMetadata< - 13, + 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_PresentType, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidGameInterventionList>; - static constexpr FieldMetadata_PresentTypeExperimental kPresentTypeExperimental{}; - void set_present_type_experimental(FrameTimelineEvent_PresentType value) { - static constexpr uint32_t field_id = FieldMetadata_PresentTypeExperimental::kFieldId; + static constexpr FieldMetadata_ReadError kReadError{}; + void set_read_error(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReadError::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } +}; + +class AndroidGameInterventionList_GamePackageInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidGameInterventionList_GamePackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_uid() const { return at<2>().valid(); } + uint64_t uid() const { return at<2>().as_uint64(); } + bool has_current_mode() const { return at<3>().valid(); } + uint32_t current_mode() const { return at<3>().as_uint32(); } + bool has_game_mode_info() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_mode_info() const { return GetRepeated<::protozero::ConstBytes>(4); } +}; + +class AndroidGameInterventionList_GamePackageInfo : public ::protozero::Message { + public: + using Decoder = AndroidGameInterventionList_GamePackageInfo_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kUidFieldNumber = 2, + kCurrentModeFieldNumber = 3, + kGameModeInfoFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GamePackageInfo"; } + - using FieldMetadata_JankDebugMetadata = + using FieldMetadata_Name = ::protozero::proto_utils::FieldMetadata< - 14, + 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidGameInterventionList_GamePackageInfo>; - static constexpr FieldMetadata_JankDebugMetadata kJankDebugMetadata{}; - void set_jank_debug_metadata(float value) { - static constexpr uint32_t field_id = FieldMetadata_JankDebugMetadata::kFieldId; + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_LatchedUnsignaledCount = + using FieldMetadata_Uid = ::protozero::proto_utils::FieldMetadata< - 15, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidGameInterventionList_GamePackageInfo>; - static constexpr FieldMetadata_LatchedUnsignaledCount kLatchedUnsignaledCount{}; - void set_latched_unsignaled_count(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_LatchedUnsignaledCount::kFieldId; + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } - using FieldMetadata_AddressableUnsignaledLatchCount = + using FieldMetadata_CurrentMode = ::protozero::proto_utils::FieldMetadata< - 16, + 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ActualDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidGameInterventionList_GamePackageInfo>; - static constexpr FieldMetadata_AddressableUnsignaledLatchCount kAddressableUnsignaledLatchCount{}; - void set_addressable_unsignaled_latch_count(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_AddressableUnsignaledLatchCount::kFieldId; + static constexpr FieldMetadata_CurrentMode kCurrentMode{}; + void set_current_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentMode::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } + + using FieldMetadata_GameModeInfo = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidGameInterventionList_GameModeInfo, + AndroidGameInterventionList_GamePackageInfo>; + + static constexpr FieldMetadata_GameModeInfo kGameModeInfo{}; + template T* add_game_mode_info() { + return BeginNestedMessage(4); + } + }; -class FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder : public ::protozero::TypedProtoDecoder { +class AndroidGameInterventionList_GameModeInfo_Decoder : public ::protozero::TypedProtoDecoder { public: - FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_cookie() const { return at<1>().valid(); } - int64_t cookie() const { return at<1>().as_int64(); } - bool has_token() const { return at<2>().valid(); } - int64_t token() const { return at<2>().as_int64(); } - bool has_pid() const { return at<3>().valid(); } - int32_t pid() const { return at<3>().as_int32(); } + AndroidGameInterventionList_GameModeInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidGameInterventionList_GameModeInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidGameInterventionList_GameModeInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + uint32_t mode() const { return at<1>().as_uint32(); } + bool has_use_angle() const { return at<2>().valid(); } + bool use_angle() const { return at<2>().as_bool(); } + bool has_resolution_downscale() const { return at<3>().valid(); } + float resolution_downscale() const { return at<3>().as_float(); } + bool has_fps() const { return at<4>().valid(); } + float fps() const { return at<4>().as_float(); } }; -class FrameTimelineEvent_ExpectedDisplayFrameStart : public ::protozero::Message { +class AndroidGameInterventionList_GameModeInfo : public ::protozero::Message { public: - using Decoder = FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder; + using Decoder = AndroidGameInterventionList_GameModeInfo_Decoder; enum : int32_t { - kCookieFieldNumber = 1, - kTokenFieldNumber = 2, - kPidFieldNumber = 3, + kModeFieldNumber = 1, + kUseAngleFieldNumber = 2, + kResolutionDownscaleFieldNumber = 3, + kFpsFieldNumber = 4, }; - static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ExpectedDisplayFrameStart"; } + static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GameModeInfo"; } - using FieldMetadata_Cookie = + using FieldMetadata_Mode = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ExpectedDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidGameInterventionList_GameModeInfo>; - static constexpr FieldMetadata_Cookie kCookie{}; - void set_cookie(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } - using FieldMetadata_Token = + using FieldMetadata_UseAngle = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ExpectedDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidGameInterventionList_GameModeInfo>; - static constexpr FieldMetadata_Token kToken{}; - void set_token(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId; + static constexpr FieldMetadata_UseAngle kUseAngle{}; + void set_use_angle(bool value) { + static constexpr uint32_t field_id = FieldMetadata_UseAngle::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kBool> ::Append(*this, field_id, value); } - using FieldMetadata_Pid = + using FieldMetadata_ResolutionDownscale = ::protozero::proto_utils::FieldMetadata< 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - FrameTimelineEvent_ExpectedDisplayFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidGameInterventionList_GameModeInfo>; - static constexpr FieldMetadata_Pid kPid{}; - void set_pid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + static constexpr FieldMetadata_ResolutionDownscale kResolutionDownscale{}; + void set_resolution_downscale(float value) { + static constexpr uint32_t field_id = FieldMetadata_ResolutionDownscale::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fps = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidGameInterventionList_GameModeInfo>; + + static constexpr FieldMetadata_Fps kFps{}; + void set_fps(float value) { + static constexpr uint32_t field_id = FieldMetadata_Fps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> ::Append(*this, field_id, value); } }; -class FrameTimelineEvent_ActualSurfaceFrameStart_Decoder : public ::protozero::TypedProtoDecoder { +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_log.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_LOG_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_LOG_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class AndroidLogPacket_LogEvent; +class AndroidLogPacket_LogEvent_Arg; +class AndroidLogPacket_Stats; +enum AndroidLogId : int32_t; +enum AndroidLogPriority : int32_t; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +class AndroidLogPacket_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_events() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> events() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_stats() const { return at<2>().valid(); } + ::protozero::ConstBytes stats() const { return at<2>().as_bytes(); } +}; + +class AndroidLogPacket : public ::protozero::Message { public: - FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_cookie() const { return at<1>().valid(); } - int64_t cookie() const { return at<1>().as_int64(); } - bool has_token() const { return at<2>().valid(); } - int64_t token() const { return at<2>().as_int64(); } - bool has_display_frame_token() const { return at<3>().valid(); } - int64_t display_frame_token() const { return at<3>().as_int64(); } - bool has_pid() const { return at<4>().valid(); } - int32_t pid() const { return at<4>().as_int32(); } - bool has_layer_name() const { return at<5>().valid(); } - ::protozero::ConstChars layer_name() const { return at<5>().as_string(); } - bool has_present_type() const { return at<6>().valid(); } - int32_t present_type() const { return at<6>().as_int32(); } - bool has_on_time_finish() const { return at<7>().valid(); } - bool on_time_finish() const { return at<7>().as_bool(); } - bool has_gpu_composition() const { return at<8>().valid(); } - bool gpu_composition() const { return at<8>().as_bool(); } - bool has_jank_type() const { return at<9>().valid(); } - int32_t jank_type() const { return at<9>().as_int32(); } - bool has_prediction_type() const { return at<10>().valid(); } - int32_t prediction_type() const { return at<10>().as_int32(); } - bool has_is_buffer() const { return at<11>().valid(); } - bool is_buffer() const { return at<11>().as_bool(); } - bool has_jank_severity_type() const { return at<12>().valid(); } - int32_t jank_severity_type() const { return at<12>().as_int32(); } - bool has_present_delay_millis() const { return at<13>().valid(); } - float present_delay_millis() const { return at<13>().as_float(); } - bool has_vsync_resynced_jitter_millis() const { return at<14>().valid(); } - float vsync_resynced_jitter_millis() const { return at<14>().as_float(); } - bool has_jank_severity_score() const { return at<15>().valid(); } - float jank_severity_score() const { return at<15>().as_float(); } - bool has_jank_type_experimental() const { return at<16>().valid(); } - int32_t jank_type_experimental() const { return at<16>().as_int32(); } - bool has_present_type_experimental() const { return at<17>().valid(); } - int32_t present_type_experimental() const { return at<17>().as_int32(); } - bool has_jank_debug_metadata() const { return at<18>().valid(); } - float jank_debug_metadata() const { return at<18>().as_float(); } - bool has_latched_fence_state() const { return at<19>().valid(); } - int32_t latched_fence_state() const { return at<19>().as_int32(); } - bool has_animation_time_millis() const { return at<20>().valid(); } - float animation_time_millis() const { return at<20>().as_float(); } -}; - -class FrameTimelineEvent_ActualSurfaceFrameStart : public ::protozero::Message { - public: - using Decoder = FrameTimelineEvent_ActualSurfaceFrameStart_Decoder; - enum : int32_t { - kCookieFieldNumber = 1, - kTokenFieldNumber = 2, - kDisplayFrameTokenFieldNumber = 3, - kPidFieldNumber = 4, - kLayerNameFieldNumber = 5, - kPresentTypeFieldNumber = 6, - kOnTimeFinishFieldNumber = 7, - kGpuCompositionFieldNumber = 8, - kJankTypeFieldNumber = 9, - kPredictionTypeFieldNumber = 10, - kIsBufferFieldNumber = 11, - kJankSeverityTypeFieldNumber = 12, - kPresentDelayMillisFieldNumber = 13, - kVsyncResyncedJitterMillisFieldNumber = 14, - kJankSeverityScoreFieldNumber = 15, - kJankTypeExperimentalFieldNumber = 16, - kPresentTypeExperimentalFieldNumber = 17, - kJankDebugMetadataFieldNumber = 18, - kLatchedFenceStateFieldNumber = 19, - kAnimationTimeMillisFieldNumber = 20, + using Decoder = AndroidLogPacket_Decoder; + enum : int32_t { + kEventsFieldNumber = 1, + kStatsFieldNumber = 2, }; - static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ActualSurfaceFrameStart"; } - + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket"; } - using LatchedFenceState = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState; - static inline const char* LatchedFenceState_Name(LatchedFenceState value) { - return ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState_Name(value); - } - static inline const LatchedFenceState LATCHED_UNKNOWN = LatchedFenceState::LATCHED_UNKNOWN; - static inline const LatchedFenceState LATCHED_SIGNALED = LatchedFenceState::LATCHED_SIGNALED; - static inline const LatchedFenceState LATCHED_UNSIGNALED = LatchedFenceState::LATCHED_UNSIGNALED; - static inline const LatchedFenceState LATCHED_DELAYED_LATCH_UNSIGNALED = LatchedFenceState::LATCHED_DELAYED_LATCH_UNSIGNALED; + using LogEvent = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent; + using Stats = ::perfetto::protos::pbzero::AndroidLogPacket_Stats; - using FieldMetadata_Cookie = + using FieldMetadata_Events = ::protozero::proto_utils::FieldMetadata< 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidLogPacket_LogEvent, + AndroidLogPacket>; - static constexpr FieldMetadata_Cookie kCookie{}; - void set_cookie(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_Events kEvents{}; + template T* add_events() { + return BeginNestedMessage(1); } - using FieldMetadata_Token = + + using FieldMetadata_Stats = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidLogPacket_Stats, + AndroidLogPacket>; - static constexpr FieldMetadata_Token kToken{}; - void set_token(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_Stats kStats{}; + template T* set_stats() { + return BeginNestedMessage(2); } - using FieldMetadata_DisplayFrameToken = +}; + +class AndroidLogPacket_Stats_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogPacket_Stats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogPacket_Stats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogPacket_Stats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_num_total() const { return at<1>().valid(); } + uint64_t num_total() const { return at<1>().as_uint64(); } + bool has_num_failed() const { return at<2>().valid(); } + uint64_t num_failed() const { return at<2>().as_uint64(); } + bool has_num_skipped() const { return at<3>().valid(); } + uint64_t num_skipped() const { return at<3>().as_uint64(); } +}; + +class AndroidLogPacket_Stats : public ::protozero::Message { + public: + using Decoder = AndroidLogPacket_Stats_Decoder; + enum : int32_t { + kNumTotalFieldNumber = 1, + kNumFailedFieldNumber = 2, + kNumSkippedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.Stats"; } + + + using FieldMetadata_NumTotal = ::protozero::proto_utils::FieldMetadata< - 3, + 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidLogPacket_Stats>; - static constexpr FieldMetadata_DisplayFrameToken kDisplayFrameToken{}; - void set_display_frame_token(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_DisplayFrameToken::kFieldId; + static constexpr FieldMetadata_NumTotal kNumTotal{}; + void set_num_total(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumTotal::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } - using FieldMetadata_Pid = + using FieldMetadata_NumFailed = ::protozero::proto_utils::FieldMetadata< - 4, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidLogPacket_Stats>; - static constexpr FieldMetadata_Pid kPid{}; - void set_pid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + static constexpr FieldMetadata_NumFailed kNumFailed{}; + void set_num_failed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumFailed::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } - using FieldMetadata_LayerName = + using FieldMetadata_NumSkipped = ::protozero::proto_utils::FieldMetadata< - 5, + 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidLogPacket_Stats>; - static constexpr FieldMetadata_LayerName kLayerName{}; - void set_layer_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_LayerName::kFieldId, data, size); - } - void set_layer_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size); - } - void set_layer_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId; + static constexpr FieldMetadata_NumSkipped kNumSkipped{}; + void set_num_skipped(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumSkipped::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> + ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } +}; + +class AndroidLogPacket_LogEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogPacket_LogEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogPacket_LogEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogPacket_LogEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_log_id() const { return at<1>().valid(); } + int32_t log_id() const { return at<1>().as_int32(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_tid() const { return at<3>().valid(); } + int32_t tid() const { return at<3>().as_int32(); } + bool has_uid() const { return at<4>().valid(); } + int32_t uid() const { return at<4>().as_int32(); } + bool has_timestamp() const { return at<5>().valid(); } + uint64_t timestamp() const { return at<5>().as_uint64(); } + bool has_tag() const { return at<6>().valid(); } + ::protozero::ConstChars tag() const { return at<6>().as_string(); } + bool has_prio() const { return at<7>().valid(); } + int32_t prio() const { return at<7>().as_int32(); } + bool has_message() const { return at<8>().valid(); } + ::protozero::ConstChars message() const { return at<8>().as_string(); } + bool has_args() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(9); } +}; + +class AndroidLogPacket_LogEvent : public ::protozero::Message { + public: + using Decoder = AndroidLogPacket_LogEvent_Decoder; + enum : int32_t { + kLogIdFieldNumber = 1, + kPidFieldNumber = 2, + kTidFieldNumber = 3, + kUidFieldNumber = 4, + kTimestampFieldNumber = 5, + kTagFieldNumber = 6, + kPrioFieldNumber = 7, + kMessageFieldNumber = 8, + kArgsFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent"; } + + using Arg = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent_Arg; - using FieldMetadata_PresentType = + using FieldMetadata_LogId = ::protozero::proto_utils::FieldMetadata< - 6, + 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_PresentType, - FrameTimelineEvent_ActualSurfaceFrameStart>; + AndroidLogId, + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_PresentType kPresentType{}; - void set_present_type(FrameTimelineEvent_PresentType value) { - static constexpr uint32_t field_id = FieldMetadata_PresentType::kFieldId; + static constexpr FieldMetadata_LogId kLogId{}; + void set_log_id(AndroidLogId value) { + static constexpr uint32_t field_id = FieldMetadata_LogId::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -72615,53 +70317,53 @@ class FrameTimelineEvent_ActualSurfaceFrameStart : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_OnTimeFinish = + using FieldMetadata_Pid = ::protozero::proto_utils::FieldMetadata< - 7, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_OnTimeFinish kOnTimeFinish{}; - void set_on_time_finish(bool value) { - static constexpr uint32_t field_id = FieldMetadata_OnTimeFinish::kFieldId; + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> + ::protozero::proto_utils::ProtoSchemaType::kInt32> ::Append(*this, field_id, value); } - using FieldMetadata_GpuComposition = + using FieldMetadata_Tid = ::protozero::proto_utils::FieldMetadata< - 8, + 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_GpuComposition kGpuComposition{}; - void set_gpu_composition(bool value) { - static constexpr uint32_t field_id = FieldMetadata_GpuComposition::kFieldId; + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> + ::protozero::proto_utils::ProtoSchemaType::kInt32> ::Append(*this, field_id, value); } - using FieldMetadata_JankType = + using FieldMetadata_Uid = ::protozero::proto_utils::FieldMetadata< - 9, + 4, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kInt32, int32_t, - FrameTimelineEvent_ActualSurfaceFrameStart>; + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_JankType kJankType{}; - void set_jank_type(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_JankType::kFieldId; + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -72669,53 +70371,59 @@ class FrameTimelineEvent_ActualSurfaceFrameStart : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_PredictionType = + using FieldMetadata_Timestamp = ::protozero::proto_utils::FieldMetadata< - 10, + 5, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_PredictionType, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_PredictionType kPredictionType{}; - void set_prediction_type(FrameTimelineEvent_PredictionType value) { - static constexpr uint32_t field_id = FieldMetadata_PredictionType::kFieldId; + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } - using FieldMetadata_IsBuffer = + using FieldMetadata_Tag = ::protozero::proto_utils::FieldMetadata< - 11, + 6, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_IsBuffer kIsBuffer{}; - void set_is_buffer(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsBuffer::kFieldId; + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + } + void set_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + } + void set_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_JankSeverityType = + using FieldMetadata_Prio = ::protozero::proto_utils::FieldMetadata< - 12, + 7, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_JankSeverityType, - FrameTimelineEvent_ActualSurfaceFrameStart>; + AndroidLogPriority, + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_JankSeverityType kJankSeverityType{}; - void set_jank_severity_type(FrameTimelineEvent_JankSeverityType value) { - static constexpr uint32_t field_id = FieldMetadata_JankSeverityType::kFieldId; + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(AndroidLogPriority value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -72723,107 +70431,125 @@ class FrameTimelineEvent_ActualSurfaceFrameStart : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_PresentDelayMillis = + using FieldMetadata_Message = ::protozero::proto_utils::FieldMetadata< - 13, + 8, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_PresentDelayMillis kPresentDelayMillis{}; - void set_present_delay_millis(float value) { - static constexpr uint32_t field_id = FieldMetadata_PresentDelayMillis::kFieldId; + static constexpr FieldMetadata_Message kMessage{}; + void set_message(const char* data, size_t size) { + AppendBytes(FieldMetadata_Message::kFieldId, data, size); + } + void set_message(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size); + } + void set_message(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_VsyncResyncedJitterMillis = + using FieldMetadata_Args = ::protozero::proto_utils::FieldMetadata< - 14, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FrameTimelineEvent_ActualSurfaceFrameStart>; + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidLogPacket_LogEvent_Arg, + AndroidLogPacket_LogEvent>; - static constexpr FieldMetadata_VsyncResyncedJitterMillis kVsyncResyncedJitterMillis{}; - void set_vsync_resynced_jitter_millis(float value) { - static constexpr uint32_t field_id = FieldMetadata_VsyncResyncedJitterMillis::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_Args kArgs{}; + template T* add_args() { + return BeginNestedMessage(9); } - using FieldMetadata_JankSeverityScore = - ::protozero::proto_utils::FieldMetadata< - 15, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FrameTimelineEvent_ActualSurfaceFrameStart>; +}; + +class AndroidLogPacket_LogEvent_Arg_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogPacket_LogEvent_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogPacket_LogEvent_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogPacket_LogEvent_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_int_value() const { return at<2>().valid(); } + int64_t int_value() const { return at<2>().as_int64(); } + bool has_float_value() const { return at<3>().valid(); } + float float_value() const { return at<3>().as_float(); } + bool has_string_value() const { return at<4>().valid(); } + ::protozero::ConstChars string_value() const { return at<4>().as_string(); } +}; + +class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message { + public: + using Decoder = AndroidLogPacket_LogEvent_Arg_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kIntValueFieldNumber = 2, + kFloatValueFieldNumber = 3, + kStringValueFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent.Arg"; } - static constexpr FieldMetadata_JankSeverityScore kJankSeverityScore{}; - void set_jank_severity_score(float value) { - static constexpr uint32_t field_id = FieldMetadata_JankSeverityScore::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - using FieldMetadata_JankTypeExperimental = + using FieldMetadata_Name = ::protozero::proto_utils::FieldMetadata< - 16, + 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogPacket_LogEvent_Arg>; - static constexpr FieldMetadata_JankTypeExperimental kJankTypeExperimental{}; - void set_jank_type_experimental(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_JankTypeExperimental::kFieldId; + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_PresentTypeExperimental = + using FieldMetadata_IntValue = ::protozero::proto_utils::FieldMetadata< - 17, + 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_PresentType, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidLogPacket_LogEvent_Arg>; - static constexpr FieldMetadata_PresentTypeExperimental kPresentTypeExperimental{}; - void set_present_type_experimental(FrameTimelineEvent_PresentType value) { - static constexpr uint32_t field_id = FieldMetadata_PresentTypeExperimental::kFieldId; + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::protozero::proto_utils::ProtoSchemaType::kInt64> ::Append(*this, field_id, value); } - using FieldMetadata_JankDebugMetadata = + using FieldMetadata_FloatValue = ::protozero::proto_utils::FieldMetadata< - 18, + 3, ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kFloat, float, - FrameTimelineEvent_ActualSurfaceFrameStart>; + AndroidLogPacket_LogEvent_Arg>; - static constexpr FieldMetadata_JankDebugMetadata kJankDebugMetadata{}; - void set_jank_debug_metadata(float value) { - static constexpr uint32_t field_id = FieldMetadata_JankDebugMetadata::kFieldId; + static constexpr FieldMetadata_FloatValue kFloatValue{}; + void set_float_value(float value) { + static constexpr uint32_t field_id = FieldMetadata_FloatValue::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< @@ -72831,167 +70557,258 @@ class FrameTimelineEvent_ActualSurfaceFrameStart : public ::protozero::Message { ::Append(*this, field_id, value); } - using FieldMetadata_LatchedFenceState = + using FieldMetadata_StringValue = ::protozero::proto_utils::FieldMetadata< - 19, + 4, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState, - FrameTimelineEvent_ActualSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogPacket_LogEvent_Arg>; - static constexpr FieldMetadata_LatchedFenceState kLatchedFenceState{}; - void set_latched_fence_state(FrameTimelineEvent_ActualSurfaceFrameStart_LatchedFenceState value) { - static constexpr uint32_t field_id = FieldMetadata_LatchedFenceState::kFieldId; + static constexpr FieldMetadata_StringValue kStringValue{}; + void set_string_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); + } + void set_string_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size); + } + void set_string_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_system_property.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_SYSTEM_PROPERTY_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_SYSTEM_PROPERTY_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class AndroidSystemProperty_PropertyValue; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +class AndroidSystemProperty_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidSystemProperty_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidSystemProperty_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidSystemProperty_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_values() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> values() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class AndroidSystemProperty : public ::protozero::Message { + public: + using Decoder = AndroidSystemProperty_Decoder; + enum : int32_t { + kValuesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty"; } + + using PropertyValue = ::perfetto::protos::pbzero::AndroidSystemProperty_PropertyValue; - using FieldMetadata_AnimationTimeMillis = + using FieldMetadata_Values = ::protozero::proto_utils::FieldMetadata< - 20, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FrameTimelineEvent_ActualSurfaceFrameStart>; + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidSystemProperty_PropertyValue, + AndroidSystemProperty>; - static constexpr FieldMetadata_AnimationTimeMillis kAnimationTimeMillis{}; - void set_animation_time_millis(float value) { - static constexpr uint32_t field_id = FieldMetadata_AnimationTimeMillis::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_Values kValues{}; + template T* add_values() { + return BeginNestedMessage(1); } + }; -class FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder : public ::protozero::TypedProtoDecoder { +class AndroidSystemProperty_PropertyValue_Decoder : public ::protozero::TypedProtoDecoder { public: - FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_cookie() const { return at<1>().valid(); } - int64_t cookie() const { return at<1>().as_int64(); } - bool has_token() const { return at<2>().valid(); } - int64_t token() const { return at<2>().as_int64(); } - bool has_display_frame_token() const { return at<3>().valid(); } - int64_t display_frame_token() const { return at<3>().as_int64(); } - bool has_pid() const { return at<4>().valid(); } - int32_t pid() const { return at<4>().as_int32(); } - bool has_layer_name() const { return at<5>().valid(); } - ::protozero::ConstChars layer_name() const { return at<5>().as_string(); } + AndroidSystemProperty_PropertyValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidSystemProperty_PropertyValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidSystemProperty_PropertyValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } }; -class FrameTimelineEvent_ExpectedSurfaceFrameStart : public ::protozero::Message { +class AndroidSystemProperty_PropertyValue : public ::protozero::Message { public: - using Decoder = FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder; + using Decoder = AndroidSystemProperty_PropertyValue_Decoder; enum : int32_t { - kCookieFieldNumber = 1, - kTokenFieldNumber = 2, - kDisplayFrameTokenFieldNumber = 3, - kPidFieldNumber = 4, - kLayerNameFieldNumber = 5, + kNameFieldNumber = 1, + kValueFieldNumber = 2, }; - static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ExpectedSurfaceFrameStart"; } + static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty.PropertyValue"; } - using FieldMetadata_Cookie = + using FieldMetadata_Name = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ExpectedSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidSystemProperty_PropertyValue>; - static constexpr FieldMetadata_Cookie kCookie{}; - void set_cookie(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } - using FieldMetadata_Token = + using FieldMetadata_Value = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ExpectedSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidSystemProperty_PropertyValue>; - static constexpr FieldMetadata_Token kToken{}; - void set_token(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId; + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kString> ::Append(*this, field_id, value); } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/cpu_per_uid_data.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CPU_PER_UID_DATA_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_CPU_PER_UID_DATA_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class CpuPerUidData_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuPerUidData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuPerUidData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuPerUidData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cluster_count() const { return at<1>().valid(); } + uint32_t cluster_count() const { return at<1>().as_uint32(); } + bool has_uid() const { return at<2>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> uid(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(2, parse_error_ptr); } + bool has_total_time_ms() const { return at<3>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> total_time_ms(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(3, parse_error_ptr); } +}; + +class CpuPerUidData : public ::protozero::Message { + public: + using Decoder = CpuPerUidData_Decoder; + enum : int32_t { + kClusterCountFieldNumber = 1, + kUidFieldNumber = 2, + kTotalTimeMsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuPerUidData"; } - using FieldMetadata_DisplayFrameToken = + + using FieldMetadata_ClusterCount = ::protozero::proto_utils::FieldMetadata< - 3, + 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - FrameTimelineEvent_ExpectedSurfaceFrameStart>; + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuPerUidData>; - static constexpr FieldMetadata_DisplayFrameToken kDisplayFrameToken{}; - void set_display_frame_token(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_DisplayFrameToken::kFieldId; + static constexpr FieldMetadata_ClusterCount kClusterCount{}; + void set_cluster_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClusterCount::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } - using FieldMetadata_Pid = + using FieldMetadata_Uid = ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - FrameTimelineEvent_ExpectedSurfaceFrameStart>; + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuPerUidData>; - static constexpr FieldMetadata_Pid kPid{}; - void set_pid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_Uid::kFieldId, packed_buffer.data(), + packed_buffer.size()); } - using FieldMetadata_LayerName = + using FieldMetadata_TotalTimeMs = ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - FrameTimelineEvent_ExpectedSurfaceFrameStart>; + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CpuPerUidData>; - static constexpr FieldMetadata_LayerName kLayerName{}; - void set_layer_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_LayerName::kFieldId, data, size); - } - void set_layer_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size); - } - void set_layer_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); + static constexpr FieldMetadata_TotalTimeMs kTotalTimeMs{}; + void set_total_time_ms(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_TotalTimeMs::kFieldId, packed_buffer.data(), + packed_buffer.size()); } }; @@ -153916,7 +151733,7 @@ class SdeSdePerfCalcCrtcFtraceEvent : public ::protozero::Message { } }; -class SdeSdeEvtlogFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { +class SdeSdeEvtlogFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { public: SdeSdeEvtlogFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit SdeSdeEvtlogFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -153927,6 +151744,36 @@ class SdeSdeEvtlogFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder().as_int32(); } bool has_tag_id() const { return at<3>().valid(); } uint32_t tag_id() const { return at<3>().as_uint32(); } + bool has_d00() const { return at<4>().valid(); } + uint32_t d00() const { return at<4>().as_uint32(); } + bool has_d01() const { return at<5>().valid(); } + uint32_t d01() const { return at<5>().as_uint32(); } + bool has_d02() const { return at<6>().valid(); } + uint32_t d02() const { return at<6>().as_uint32(); } + bool has_d03() const { return at<7>().valid(); } + uint32_t d03() const { return at<7>().as_uint32(); } + bool has_d04() const { return at<8>().valid(); } + uint32_t d04() const { return at<8>().as_uint32(); } + bool has_d05() const { return at<9>().valid(); } + uint32_t d05() const { return at<9>().as_uint32(); } + bool has_d06() const { return at<10>().valid(); } + uint32_t d06() const { return at<10>().as_uint32(); } + bool has_d07() const { return at<11>().valid(); } + uint32_t d07() const { return at<11>().as_uint32(); } + bool has_d08() const { return at<12>().valid(); } + uint32_t d08() const { return at<12>().as_uint32(); } + bool has_d09() const { return at<13>().valid(); } + uint32_t d09() const { return at<13>().as_uint32(); } + bool has_d10() const { return at<14>().valid(); } + uint32_t d10() const { return at<14>().as_uint32(); } + bool has_d11() const { return at<15>().valid(); } + uint32_t d11() const { return at<15>().as_uint32(); } + bool has_d12() const { return at<16>().valid(); } + uint32_t d12() const { return at<16>().as_uint32(); } + bool has_d13() const { return at<17>().valid(); } + uint32_t d13() const { return at<17>().as_uint32(); } + bool has_d14() const { return at<18>().valid(); } + uint32_t d14() const { return at<18>().as_uint32(); } }; class SdeSdeEvtlogFtraceEvent : public ::protozero::Message { @@ -153936,6 +151783,21 @@ class SdeSdeEvtlogFtraceEvent : public ::protozero::Message { kEvtlogTagFieldNumber = 1, kPidFieldNumber = 2, kTagIdFieldNumber = 3, + kD00FieldNumber = 4, + kD01FieldNumber = 5, + kD02FieldNumber = 6, + kD03FieldNumber = 7, + kD04FieldNumber = 8, + kD05FieldNumber = 9, + kD06FieldNumber = 10, + kD07FieldNumber = 11, + kD08FieldNumber = 12, + kD09FieldNumber = 13, + kD10FieldNumber = 14, + kD11FieldNumber = 15, + kD12FieldNumber = 16, + kD13FieldNumber = 17, + kD14FieldNumber = 18, }; static constexpr const char* GetName() { return ".perfetto.protos.SdeSdeEvtlogFtraceEvent"; } @@ -153999,6 +151861,276 @@ class SdeSdeEvtlogFtraceEvent : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } + + using FieldMetadata_D00 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D00 kD00{}; + void set_d00(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D00::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D01 = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D01 kD01{}; + void set_d01(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D01::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D02 = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D02 kD02{}; + void set_d02(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D02::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D03 = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D03 kD03{}; + void set_d03(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D03::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D04 = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D04 kD04{}; + void set_d04(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D04::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D05 = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D05 kD05{}; + void set_d05(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D05::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D06 = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D06 kD06{}; + void set_d06(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D06::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D07 = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D07 kD07{}; + void set_d07(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D07::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D08 = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D08 kD08{}; + void set_d08(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D08::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D09 = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D09 kD09{}; + void set_d09(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D09::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D10 = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D10 kD10{}; + void set_d10(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D10::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D11 = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D11 kD11{}; + void set_d11(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D11::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D12 = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D12 kD12{}; + void set_d12(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D12::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D13 = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D13 kD13{}; + void set_d13(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D13::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_D14 = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_D14 kD14{}; + void set_d14(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_D14::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } }; class SdeTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { @@ -166740,6 +164872,162 @@ class VulkanMemoryEventAnnotation : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/inline_callstack.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_INLINE_CALLSTACK_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_INLINE_CALLSTACK_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class InlineCallstack_Frame; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +class InlineCallstack_Decoder : public ::protozero::TypedProtoDecoder { + public: + InlineCallstack_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InlineCallstack_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InlineCallstack_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_frames() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> frames() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class InlineCallstack : public ::protozero::Message { + public: + using Decoder = InlineCallstack_Decoder; + enum : int32_t { + kFramesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InlineCallstack"; } + + using Frame = ::perfetto::protos::pbzero::InlineCallstack_Frame; + + using FieldMetadata_Frames = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InlineCallstack_Frame, + InlineCallstack>; + + static constexpr FieldMetadata_Frames kFrames{}; + template T* add_frames() { + return BeginNestedMessage(1); + } + +}; + +class InlineCallstack_Frame_Decoder : public ::protozero::TypedProtoDecoder { + public: + InlineCallstack_Frame_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InlineCallstack_Frame_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InlineCallstack_Frame_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_function_name() const { return at<1>().valid(); } + ::protozero::ConstChars function_name() const { return at<1>().as_string(); } + bool has_source_file() const { return at<2>().valid(); } + ::protozero::ConstChars source_file() const { return at<2>().as_string(); } + bool has_line_number() const { return at<3>().valid(); } + uint32_t line_number() const { return at<3>().as_uint32(); } +}; + +class InlineCallstack_Frame : public ::protozero::Message { + public: + using Decoder = InlineCallstack_Frame_Decoder; + enum : int32_t { + kFunctionNameFieldNumber = 1, + kSourceFileFieldNumber = 2, + kLineNumberFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InlineCallstack.Frame"; } + + + using FieldMetadata_FunctionName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InlineCallstack_Frame>; + + static constexpr FieldMetadata_FunctionName kFunctionName{}; + void set_function_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size); + } + void set_function_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size); + } + void set_function_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SourceFile = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InlineCallstack_Frame>; + + static constexpr FieldMetadata_SourceFile kSourceFile{}; + void set_source_file(const char* data, size_t size) { + AppendBytes(FieldMetadata_SourceFile::kFieldId, data, size); + } + void set_source_file(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SourceFile::kFieldId, chars.data, chars.size); + } + void set_source_file(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SourceFile::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LineNumber = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InlineCallstack_Frame>; + + static constexpr FieldMetadata_LineNumber kLineNumber{}; + void set_line_number(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -167510,6 +165798,10 @@ namespace protos { namespace pbzero { class AddressSymbols; class Line; +namespace perfetto_pbzero_enum_Frame { +enum Kind : int32_t; +} // namespace perfetto_pbzero_enum_Frame +using Frame_Kind = perfetto_pbzero_enum_Frame::Kind; } // Namespace pbzero. } // Namespace protos. } // Namespace perfetto. @@ -167518,6 +165810,51 @@ namespace perfetto { namespace protos { namespace pbzero { +namespace perfetto_pbzero_enum_Frame { +enum Kind : int32_t { + KIND_UNKNOWN = 0, + KIND_NATIVE = 1, + KIND_KERNEL = 2, + KIND_INTERPRETED = 3, + KIND_JIT = 4, + KIND_GC = 5, + KIND_RUNTIME = 6, +}; +} // namespace perfetto_pbzero_enum_Frame +using Frame_Kind = perfetto_pbzero_enum_Frame::Kind; + + +constexpr Frame_Kind Frame_Kind_MIN = Frame_Kind::KIND_UNKNOWN; +constexpr Frame_Kind Frame_Kind_MAX = Frame_Kind::KIND_RUNTIME; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* Frame_Kind_Name(::perfetto::protos::pbzero::Frame_Kind value) { + switch (value) { + case ::perfetto::protos::pbzero::Frame_Kind::KIND_UNKNOWN: + return "KIND_UNKNOWN"; + + case ::perfetto::protos::pbzero::Frame_Kind::KIND_NATIVE: + return "KIND_NATIVE"; + + case ::perfetto::protos::pbzero::Frame_Kind::KIND_KERNEL: + return "KIND_KERNEL"; + + case ::perfetto::protos::pbzero::Frame_Kind::KIND_INTERPRETED: + return "KIND_INTERPRETED"; + + case ::perfetto::protos::pbzero::Frame_Kind::KIND_JIT: + return "KIND_JIT"; + + case ::perfetto::protos::pbzero::Frame_Kind::KIND_GC: + return "KIND_GC"; + + case ::perfetto::protos::pbzero::Frame_Kind::KIND_RUNTIME: + return "KIND_RUNTIME"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + class Callstack_Decoder : public ::protozero::TypedProtoDecoder { public: Callstack_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} @@ -167576,7 +165913,7 @@ class Callstack : public ::protozero::Message { } }; -class Frame_Decoder : public ::protozero::TypedProtoDecoder { +class Frame_Decoder : public ::protozero::TypedProtoDecoder { public: Frame_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit Frame_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -167593,6 +165930,10 @@ class Frame_Decoder : public ::protozero::TypedProtoDecoder uint64_t source_path_iid() const { return at<5>().as_uint64(); } bool has_line_number() const { return at<6>().valid(); } uint32_t line_number() const { return at<6>().as_uint32(); } + bool has_kind() const { return at<7>().valid(); } + int32_t kind() const { return at<7>().as_int32(); } + bool has_kind_str() const { return at<8>().valid(); } + ::protozero::ConstChars kind_str() const { return at<8>().as_string(); } }; class Frame : public ::protozero::Message { @@ -167605,10 +165946,24 @@ class Frame : public ::protozero::Message { kRelPcFieldNumber = 4, kSourcePathIidFieldNumber = 5, kLineNumberFieldNumber = 6, + kKindFieldNumber = 7, + kKindStrFieldNumber = 8, }; static constexpr const char* GetName() { return ".perfetto.protos.Frame"; } + using Kind = ::perfetto::protos::pbzero::Frame_Kind; + static inline const char* Kind_Name(Kind value) { + return ::perfetto::protos::pbzero::Frame_Kind_Name(value); + } + static inline const Kind KIND_UNKNOWN = Kind::KIND_UNKNOWN; + static inline const Kind KIND_NATIVE = Kind::KIND_NATIVE; + static inline const Kind KIND_KERNEL = Kind::KIND_KERNEL; + static inline const Kind KIND_INTERPRETED = Kind::KIND_INTERPRETED; + static inline const Kind KIND_JIT = Kind::KIND_JIT; + static inline const Kind KIND_GC = Kind::KIND_GC; + static inline const Kind KIND_RUNTIME = Kind::KIND_RUNTIME; + using FieldMetadata_Iid = ::protozero::proto_utils::FieldMetadata< 1, @@ -167716,6 +166071,48 @@ class Frame : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } + + using FieldMetadata_Kind = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + Frame_Kind, + Frame>; + + static constexpr FieldMetadata_Kind kKind{}; + void set_kind(Frame_Kind value) { + static constexpr uint32_t field_id = FieldMetadata_Kind::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KindStr = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Frame>; + + static constexpr FieldMetadata_KindStr kKindStr{}; + void set_kind_str(const char* data, size_t size) { + AppendBytes(FieldMetadata_KindStr::kFieldId, data, size); + } + void set_kind_str(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_KindStr::kFieldId, chars.data, chars.size); + } + void set_kind_str(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_KindStr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } }; class Mapping_Decoder : public ::protozero::TypedProtoDecoder { @@ -169356,7 +167753,7 @@ class ProfilePacket : public ::protozero::Message { } }; -class ProfilePacket_ProcessHeapSamples_Decoder : public ::protozero::TypedProtoDecoder { +class ProfilePacket_ProcessHeapSamples_Decoder : public ::protozero::TypedProtoDecoder { public: ProfilePacket_ProcessHeapSamples_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit ProfilePacket_ProcessHeapSamples_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -169385,6 +167782,8 @@ class ProfilePacket_ProcessHeapSamples_Decoder : public ::protozero::TypedProtoD uint64_t orig_sampling_interval_bytes() const { return at<13>().as_uint64(); } bool has_timestamp() const { return at<9>().valid(); } uint64_t timestamp() const { return at<9>().as_uint64(); } + bool has_start_timestamp() const { return at<15>().valid(); } + uint64_t start_timestamp() const { return at<15>().as_uint64(); } bool has_stats() const { return at<5>().valid(); } ::protozero::ConstBytes stats() const { return at<5>().as_bytes(); } bool has_samples() const { return at<2>().valid(); } @@ -169407,6 +167806,7 @@ class ProfilePacket_ProcessHeapSamples : public ::protozero::Message { kSamplingIntervalBytesFieldNumber = 12, kOrigSamplingIntervalBytesFieldNumber = 13, kTimestampFieldNumber = 9, + kStartTimestampFieldNumber = 15, kStatsFieldNumber = 5, kSamplesFieldNumber = 2, }; @@ -169643,6 +168043,24 @@ class ProfilePacket_ProcessHeapSamples : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_StartTimestamp = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_StartTimestamp kStartTimestamp{}; + void set_start_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + using FieldMetadata_Stats = ::protozero::proto_utils::FieldMetadata< 5, @@ -170913,6 +169331,1055 @@ class SmapsEntry : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/profiling/stack_sample.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_STACK_SAMPLE_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROFILING_STACK_SAMPLE_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class InlineCallstack; +class StackSample_AsyncContextDescriptor; +class StackSample_CounterDescriptor; +class StackSample_ExecutionContext; +class StackSample_TaskContext; +namespace perfetto_pbzero_enum_StackSample_CounterDescriptor { +enum Scope : int32_t; +} // namespace perfetto_pbzero_enum_StackSample_CounterDescriptor +using StackSample_CounterDescriptor_Scope = perfetto_pbzero_enum_StackSample_CounterDescriptor::Scope; +namespace perfetto_pbzero_enum_StackSample { +enum Mode : int32_t; +} // namespace perfetto_pbzero_enum_StackSample +using StackSample_Mode = perfetto_pbzero_enum_StackSample::Mode; +namespace perfetto_pbzero_enum_StackSample { +enum Unit : int32_t; +} // namespace perfetto_pbzero_enum_StackSample +using StackSample_Unit = perfetto_pbzero_enum_StackSample::Unit; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +namespace perfetto_pbzero_enum_StackSample { +enum Mode : int32_t { + MODE_UNKNOWN = 0, + MODE_USER = 1, + MODE_KERNEL = 2, + MODE_HYPERVISOR = 3, + MODE_GUEST_USER = 4, + MODE_GUEST_KERNEL = 5, +}; +} // namespace perfetto_pbzero_enum_StackSample +using StackSample_Mode = perfetto_pbzero_enum_StackSample::Mode; + + +constexpr StackSample_Mode StackSample_Mode_MIN = StackSample_Mode::MODE_UNKNOWN; +constexpr StackSample_Mode StackSample_Mode_MAX = StackSample_Mode::MODE_GUEST_KERNEL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* StackSample_Mode_Name(::perfetto::protos::pbzero::StackSample_Mode value) { + switch (value) { + case ::perfetto::protos::pbzero::StackSample_Mode::MODE_UNKNOWN: + return "MODE_UNKNOWN"; + + case ::perfetto::protos::pbzero::StackSample_Mode::MODE_USER: + return "MODE_USER"; + + case ::perfetto::protos::pbzero::StackSample_Mode::MODE_KERNEL: + return "MODE_KERNEL"; + + case ::perfetto::protos::pbzero::StackSample_Mode::MODE_HYPERVISOR: + return "MODE_HYPERVISOR"; + + case ::perfetto::protos::pbzero::StackSample_Mode::MODE_GUEST_USER: + return "MODE_GUEST_USER"; + + case ::perfetto::protos::pbzero::StackSample_Mode::MODE_GUEST_KERNEL: + return "MODE_GUEST_KERNEL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_StackSample { +enum Unit : int32_t { + UNIT_UNSPECIFIED = 0, + UNIT_NANOSECONDS = 1, + UNIT_CPU_CYCLES = 2, + UNIT_INSTRUCTIONS = 3, + UNIT_BYTES = 4, + UNIT_PAGE_FAULTS = 5, + UNIT_CACHE_MISSES = 6, + UNIT_CACHE_REFERENCES = 7, + UNIT_BRANCH_MISSES = 8, + UNIT_COUNT = 9, +}; +} // namespace perfetto_pbzero_enum_StackSample +using StackSample_Unit = perfetto_pbzero_enum_StackSample::Unit; + + +constexpr StackSample_Unit StackSample_Unit_MIN = StackSample_Unit::UNIT_UNSPECIFIED; +constexpr StackSample_Unit StackSample_Unit_MAX = StackSample_Unit::UNIT_COUNT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* StackSample_Unit_Name(::perfetto::protos::pbzero::StackSample_Unit value) { + switch (value) { + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_UNSPECIFIED: + return "UNIT_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_NANOSECONDS: + return "UNIT_NANOSECONDS"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_CPU_CYCLES: + return "UNIT_CPU_CYCLES"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_INSTRUCTIONS: + return "UNIT_INSTRUCTIONS"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_BYTES: + return "UNIT_BYTES"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_PAGE_FAULTS: + return "UNIT_PAGE_FAULTS"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_CACHE_MISSES: + return "UNIT_CACHE_MISSES"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_CACHE_REFERENCES: + return "UNIT_CACHE_REFERENCES"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_BRANCH_MISSES: + return "UNIT_BRANCH_MISSES"; + + case ::perfetto::protos::pbzero::StackSample_Unit::UNIT_COUNT: + return "UNIT_COUNT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_StackSample_CounterDescriptor { +enum Scope : int32_t { + SCOPE_UNSPECIFIED = 0, + SCOPE_GLOBAL = 1, + SCOPE_CPU = 2, +}; +} // namespace perfetto_pbzero_enum_StackSample_CounterDescriptor +using StackSample_CounterDescriptor_Scope = perfetto_pbzero_enum_StackSample_CounterDescriptor::Scope; + + +constexpr StackSample_CounterDescriptor_Scope StackSample_CounterDescriptor_Scope_MIN = StackSample_CounterDescriptor_Scope::SCOPE_UNSPECIFIED; +constexpr StackSample_CounterDescriptor_Scope StackSample_CounterDescriptor_Scope_MAX = StackSample_CounterDescriptor_Scope::SCOPE_CPU; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* StackSample_CounterDescriptor_Scope_Name(::perfetto::protos::pbzero::StackSample_CounterDescriptor_Scope value) { + switch (value) { + case ::perfetto::protos::pbzero::StackSample_CounterDescriptor_Scope::SCOPE_UNSPECIFIED: + return "SCOPE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::StackSample_CounterDescriptor_Scope::SCOPE_GLOBAL: + return "SCOPE_GLOBAL"; + + case ::perfetto::protos::pbzero::StackSample_CounterDescriptor_Scope::SCOPE_CPU: + return "SCOPE_CPU"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class StackSampleDefaults_Decoder : public ::protozero::TypedProtoDecoder { + public: + StackSampleDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StackSampleDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StackSampleDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_source() const { return at<1>().valid(); } + ::protozero::ConstChars source() const { return at<1>().as_string(); } + bool has_primary_descriptor() const { return at<2>().valid(); } + ::protozero::ConstBytes primary_descriptor() const { return at<2>().as_bytes(); } + bool has_follower_descriptors() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> follower_descriptors() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class StackSampleDefaults : public ::protozero::Message { + public: + using Decoder = StackSampleDefaults_Decoder; + enum : int32_t { + kSourceFieldNumber = 1, + kPrimaryDescriptorFieldNumber = 2, + kFollowerDescriptorsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StackSampleDefaults"; } + + + using FieldMetadata_Source = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + StackSampleDefaults>; + + static constexpr FieldMetadata_Source kSource{}; + void set_source(const char* data, size_t size) { + AppendBytes(FieldMetadata_Source::kFieldId, data, size); + } + void set_source(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Source::kFieldId, chars.data, chars.size); + } + void set_source(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Source::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrimaryDescriptor = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StackSample_CounterDescriptor, + StackSampleDefaults>; + + static constexpr FieldMetadata_PrimaryDescriptor kPrimaryDescriptor{}; + template T* set_primary_descriptor() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_FollowerDescriptors = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StackSample_CounterDescriptor, + StackSampleDefaults>; + + static constexpr FieldMetadata_FollowerDescriptors kFollowerDescriptors{}; + template T* add_follower_descriptors() { + return BeginNestedMessage(3); + } + +}; + +class StackSample_Decoder : public ::protozero::TypedProtoDecoder { + public: + StackSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StackSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StackSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_task_context() const { return at<1>().valid(); } + ::protozero::ConstBytes task_context() const { return at<1>().as_bytes(); } + bool has_task_context_iid() const { return at<2>().valid(); } + uint64_t task_context_iid() const { return at<2>().as_uint64(); } + bool has_execution_context() const { return at<3>().valid(); } + ::protozero::ConstBytes execution_context() const { return at<3>().as_bytes(); } + bool has_execution_context_iid() const { return at<4>().valid(); } + uint64_t execution_context_iid() const { return at<4>().as_uint64(); } + bool has_callstack() const { return at<5>().valid(); } + ::protozero::ConstBytes callstack() const { return at<5>().as_bytes(); } + bool has_callstack_iid() const { return at<6>().valid(); } + uint64_t callstack_iid() const { return at<6>().as_uint64(); } + bool has_unwind_error() const { return at<7>().valid(); } + ::protozero::ConstChars unwind_error() const { return at<7>().as_string(); } + bool has_unwind_error_iid() const { return at<8>().valid(); } + uint64_t unwind_error_iid() const { return at<8>().as_uint64(); } + bool has_primary_descriptor() const { return at<9>().valid(); } + ::protozero::ConstBytes primary_descriptor() const { return at<9>().as_bytes(); } + bool has_primary_descriptor_iid() const { return at<10>().valid(); } + uint64_t primary_descriptor_iid() const { return at<10>().as_uint64(); } + bool has_primary_weight() const { return at<11>().valid(); } + uint64_t primary_weight() const { return at<11>().as_uint64(); } + bool has_follower_descriptors() const { return at<12>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> follower_descriptors() const { return GetRepeated<::protozero::ConstBytes>(12); } + bool has_follower_descriptor_iids() const { return at<13>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> follower_descriptor_iids(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(13, parse_error_ptr); } + bool has_follower_weights() const { return at<14>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> follower_weights(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(14, parse_error_ptr); } +}; + +class StackSample : public ::protozero::Message { + public: + using Decoder = StackSample_Decoder; + enum : int32_t { + kTaskContextFieldNumber = 1, + kTaskContextIidFieldNumber = 2, + kExecutionContextFieldNumber = 3, + kExecutionContextIidFieldNumber = 4, + kCallstackFieldNumber = 5, + kCallstackIidFieldNumber = 6, + kUnwindErrorFieldNumber = 7, + kUnwindErrorIidFieldNumber = 8, + kPrimaryDescriptorFieldNumber = 9, + kPrimaryDescriptorIidFieldNumber = 10, + kPrimaryWeightFieldNumber = 11, + kFollowerDescriptorsFieldNumber = 12, + kFollowerDescriptorIidsFieldNumber = 13, + kFollowerWeightsFieldNumber = 14, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StackSample"; } + + using TaskContext = ::perfetto::protos::pbzero::StackSample_TaskContext; + using AsyncContextDescriptor = ::perfetto::protos::pbzero::StackSample_AsyncContextDescriptor; + using ExecutionContext = ::perfetto::protos::pbzero::StackSample_ExecutionContext; + using CounterDescriptor = ::perfetto::protos::pbzero::StackSample_CounterDescriptor; + + using Mode = ::perfetto::protos::pbzero::StackSample_Mode; + static inline const char* Mode_Name(Mode value) { + return ::perfetto::protos::pbzero::StackSample_Mode_Name(value); + } + + using Unit = ::perfetto::protos::pbzero::StackSample_Unit; + static inline const char* Unit_Name(Unit value) { + return ::perfetto::protos::pbzero::StackSample_Unit_Name(value); + } + static inline const Mode MODE_UNKNOWN = Mode::MODE_UNKNOWN; + static inline const Mode MODE_USER = Mode::MODE_USER; + static inline const Mode MODE_KERNEL = Mode::MODE_KERNEL; + static inline const Mode MODE_HYPERVISOR = Mode::MODE_HYPERVISOR; + static inline const Mode MODE_GUEST_USER = Mode::MODE_GUEST_USER; + static inline const Mode MODE_GUEST_KERNEL = Mode::MODE_GUEST_KERNEL; + static inline const Unit UNIT_UNSPECIFIED = Unit::UNIT_UNSPECIFIED; + static inline const Unit UNIT_NANOSECONDS = Unit::UNIT_NANOSECONDS; + static inline const Unit UNIT_CPU_CYCLES = Unit::UNIT_CPU_CYCLES; + static inline const Unit UNIT_INSTRUCTIONS = Unit::UNIT_INSTRUCTIONS; + static inline const Unit UNIT_BYTES = Unit::UNIT_BYTES; + static inline const Unit UNIT_PAGE_FAULTS = Unit::UNIT_PAGE_FAULTS; + static inline const Unit UNIT_CACHE_MISSES = Unit::UNIT_CACHE_MISSES; + static inline const Unit UNIT_CACHE_REFERENCES = Unit::UNIT_CACHE_REFERENCES; + static inline const Unit UNIT_BRANCH_MISSES = Unit::UNIT_BRANCH_MISSES; + static inline const Unit UNIT_COUNT = Unit::UNIT_COUNT; + + using FieldMetadata_TaskContext = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StackSample_TaskContext, + StackSample>; + + static constexpr FieldMetadata_TaskContext kTaskContext{}; + template T* set_task_context() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_TaskContextIid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample>; + + static constexpr FieldMetadata_TaskContextIid kTaskContextIid{}; + void set_task_context_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TaskContextIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExecutionContext = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StackSample_ExecutionContext, + StackSample>; + + static constexpr FieldMetadata_ExecutionContext kExecutionContext{}; + template T* set_execution_context() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_ExecutionContextIid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample>; + + static constexpr FieldMetadata_ExecutionContextIid kExecutionContextIid{}; + void set_execution_context_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExecutionContextIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Callstack = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InlineCallstack, + StackSample>; + + static constexpr FieldMetadata_Callstack kCallstack{}; + template T* set_callstack() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_CallstackIid = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample>; + + static constexpr FieldMetadata_CallstackIid kCallstackIid{}; + void set_callstack_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallstackIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnwindError = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + StackSample>; + + static constexpr FieldMetadata_UnwindError kUnwindError{}; + void set_unwind_error(const char* data, size_t size) { + AppendBytes(FieldMetadata_UnwindError::kFieldId, data, size); + } + void set_unwind_error(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_UnwindError::kFieldId, chars.data, chars.size); + } + void set_unwind_error(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_UnwindError::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnwindErrorIid = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample>; + + static constexpr FieldMetadata_UnwindErrorIid kUnwindErrorIid{}; + void set_unwind_error_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnwindErrorIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrimaryDescriptor = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StackSample_CounterDescriptor, + StackSample>; + + static constexpr FieldMetadata_PrimaryDescriptor kPrimaryDescriptor{}; + template T* set_primary_descriptor() { + return BeginNestedMessage(9); + } + + + using FieldMetadata_PrimaryDescriptorIid = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample>; + + static constexpr FieldMetadata_PrimaryDescriptorIid kPrimaryDescriptorIid{}; + void set_primary_descriptor_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrimaryDescriptorIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrimaryWeight = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample>; + + static constexpr FieldMetadata_PrimaryWeight kPrimaryWeight{}; + void set_primary_weight(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrimaryWeight::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FollowerDescriptors = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StackSample_CounterDescriptor, + StackSample>; + + static constexpr FieldMetadata_FollowerDescriptors kFollowerDescriptors{}; + template T* add_follower_descriptors() { + return BeginNestedMessage(12); + } + + + using FieldMetadata_FollowerDescriptorIids = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample>; + + static constexpr FieldMetadata_FollowerDescriptorIids kFollowerDescriptorIids{}; + void set_follower_descriptor_iids(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_FollowerDescriptorIids::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_FollowerWeights = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample>; + + static constexpr FieldMetadata_FollowerWeights kFollowerWeights{}; + void set_follower_weights(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_FollowerWeights::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } +}; + +class StackSample_CounterDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + StackSample_CounterDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StackSample_CounterDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StackSample_CounterDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_unit() const { return at<3>().valid(); } + int32_t unit() const { return at<3>().as_int32(); } + bool has_unit_str() const { return at<4>().valid(); } + ::protozero::ConstChars unit_str() const { return at<4>().as_string(); } + bool has_unit_multiplier() const { return at<5>().valid(); } + uint64_t unit_multiplier() const { return at<5>().as_uint64(); } + bool has_description() const { return at<6>().valid(); } + ::protozero::ConstChars description() const { return at<6>().as_string(); } + bool has_scope() const { return at<7>().valid(); } + int32_t scope() const { return at<7>().as_int32(); } +}; + +class StackSample_CounterDescriptor : public ::protozero::Message { + public: + using Decoder = StackSample_CounterDescriptor_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kNameFieldNumber = 2, + kUnitFieldNumber = 3, + kUnitStrFieldNumber = 4, + kUnitMultiplierFieldNumber = 5, + kDescriptionFieldNumber = 6, + kScopeFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StackSample.CounterDescriptor"; } + + + using Scope = ::perfetto::protos::pbzero::StackSample_CounterDescriptor_Scope; + static inline const char* Scope_Name(Scope value) { + return ::perfetto::protos::pbzero::StackSample_CounterDescriptor_Scope_Name(value); + } + static inline const Scope SCOPE_UNSPECIFIED = Scope::SCOPE_UNSPECIFIED; + static inline const Scope SCOPE_GLOBAL = Scope::SCOPE_GLOBAL; + static inline const Scope SCOPE_CPU = Scope::SCOPE_CPU; + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample_CounterDescriptor>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + StackSample_CounterDescriptor>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Unit = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + StackSample_Unit, + StackSample_CounterDescriptor>; + + static constexpr FieldMetadata_Unit kUnit{}; + void set_unit(StackSample_Unit value) { + static constexpr uint32_t field_id = FieldMetadata_Unit::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnitStr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + StackSample_CounterDescriptor>; + + static constexpr FieldMetadata_UnitStr kUnitStr{}; + void set_unit_str(const char* data, size_t size) { + AppendBytes(FieldMetadata_UnitStr::kFieldId, data, size); + } + void set_unit_str(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_UnitStr::kFieldId, chars.data, chars.size); + } + void set_unit_str(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_UnitStr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnitMultiplier = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample_CounterDescriptor>; + + static constexpr FieldMetadata_UnitMultiplier kUnitMultiplier{}; + void set_unit_multiplier(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnitMultiplier::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Description = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + StackSample_CounterDescriptor>; + + static constexpr FieldMetadata_Description kDescription{}; + void set_description(const char* data, size_t size) { + AppendBytes(FieldMetadata_Description::kFieldId, data, size); + } + void set_description(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size); + } + void set_description(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Scope = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + StackSample_CounterDescriptor_Scope, + StackSample_CounterDescriptor>; + + static constexpr FieldMetadata_Scope kScope{}; + void set_scope(StackSample_CounterDescriptor_Scope value) { + static constexpr uint32_t field_id = FieldMetadata_Scope::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class StackSample_ExecutionContext_Decoder : public ::protozero::TypedProtoDecoder { + public: + StackSample_ExecutionContext_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StackSample_ExecutionContext_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StackSample_ExecutionContext_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_cpu() const { return at<2>().valid(); } + uint32_t cpu() const { return at<2>().as_uint32(); } + bool has_mode() const { return at<3>().valid(); } + int32_t mode() const { return at<3>().as_int32(); } +}; + +class StackSample_ExecutionContext : public ::protozero::Message { + public: + using Decoder = StackSample_ExecutionContext_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kCpuFieldNumber = 2, + kModeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StackSample.ExecutionContext"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample_ExecutionContext>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + StackSample_ExecutionContext>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + StackSample_Mode, + StackSample_ExecutionContext>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(StackSample_Mode value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class StackSample_AsyncContextDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + StackSample_AsyncContextDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StackSample_AsyncContextDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StackSample_AsyncContextDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_kind() const { return at<3>().valid(); } + ::protozero::ConstChars kind() const { return at<3>().as_string(); } + bool has_parent_iid() const { return at<4>().valid(); } + uint64_t parent_iid() const { return at<4>().as_uint64(); } +}; + +class StackSample_AsyncContextDescriptor : public ::protozero::Message { + public: + using Decoder = StackSample_AsyncContextDescriptor_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kNameFieldNumber = 2, + kKindFieldNumber = 3, + kParentIidFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StackSample.AsyncContextDescriptor"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample_AsyncContextDescriptor>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + StackSample_AsyncContextDescriptor>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Kind = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + StackSample_AsyncContextDescriptor>; + + static constexpr FieldMetadata_Kind kKind{}; + void set_kind(const char* data, size_t size) { + AppendBytes(FieldMetadata_Kind::kFieldId, data, size); + } + void set_kind(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Kind::kFieldId, chars.data, chars.size); + } + void set_kind(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Kind::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ParentIid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample_AsyncContextDescriptor>; + + static constexpr FieldMetadata_ParentIid kParentIid{}; + void set_parent_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ParentIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class StackSample_TaskContext_Decoder : public ::protozero::TypedProtoDecoder { + public: + StackSample_TaskContext_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StackSample_TaskContext_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StackSample_TaskContext_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_pid() const { return at<2>().valid(); } + uint32_t pid() const { return at<2>().as_uint32(); } + bool has_tid() const { return at<3>().valid(); } + uint32_t tid() const { return at<3>().as_uint32(); } + bool has_async_id() const { return at<4>().valid(); } + uint64_t async_id() const { return at<4>().as_uint64(); } +}; + +class StackSample_TaskContext : public ::protozero::Message { + public: + using Decoder = StackSample_TaskContext_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kPidFieldNumber = 2, + kTidFieldNumber = 3, + kAsyncIdFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StackSample.TaskContext"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample_TaskContext>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + StackSample_TaskContext>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + StackSample_TaskContext>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AsyncId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StackSample_TaskContext>; + + static constexpr FieldMetadata_AsyncId kAsyncId{}; + void set_async_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AsyncId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -177675,6 +177142,219 @@ class SystemdJournaldEvent : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/perfetto/concurrent_session_event.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_CONCURRENT_SESSION_EVENT_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_CONCURRENT_SESSION_EVENT_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +namespace perfetto_pbzero_enum_ConcurrentSessionEvent { +enum State : int32_t; +} // namespace perfetto_pbzero_enum_ConcurrentSessionEvent +using ConcurrentSessionEvent_State = perfetto_pbzero_enum_ConcurrentSessionEvent::State; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +namespace perfetto_pbzero_enum_ConcurrentSessionEvent { +enum State : int32_t { + STATE_UNSPECIFIED = 0, + STATE_DISABLED = 1, + STATE_CONFIGURED = 2, + STATE_STARTED = 3, + STATE_DISABLING_WAITING_STOP_ACKS = 4, + STATE_CLONED_READ_ONLY = 5, +}; +} // namespace perfetto_pbzero_enum_ConcurrentSessionEvent +using ConcurrentSessionEvent_State = perfetto_pbzero_enum_ConcurrentSessionEvent::State; + + +constexpr ConcurrentSessionEvent_State ConcurrentSessionEvent_State_MIN = ConcurrentSessionEvent_State::STATE_UNSPECIFIED; +constexpr ConcurrentSessionEvent_State ConcurrentSessionEvent_State_MAX = ConcurrentSessionEvent_State::STATE_CLONED_READ_ONLY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ConcurrentSessionEvent_State_Name(::perfetto::protos::pbzero::ConcurrentSessionEvent_State value) { + switch (value) { + case ::perfetto::protos::pbzero::ConcurrentSessionEvent_State::STATE_UNSPECIFIED: + return "STATE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ConcurrentSessionEvent_State::STATE_DISABLED: + return "STATE_DISABLED"; + + case ::perfetto::protos::pbzero::ConcurrentSessionEvent_State::STATE_CONFIGURED: + return "STATE_CONFIGURED"; + + case ::perfetto::protos::pbzero::ConcurrentSessionEvent_State::STATE_STARTED: + return "STATE_STARTED"; + + case ::perfetto::protos::pbzero::ConcurrentSessionEvent_State::STATE_DISABLING_WAITING_STOP_ACKS: + return "STATE_DISABLING_WAITING_STOP_ACKS"; + + case ::perfetto::protos::pbzero::ConcurrentSessionEvent_State::STATE_CLONED_READ_ONLY: + return "STATE_CLONED_READ_ONLY"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class ConcurrentSessionEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ConcurrentSessionEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ConcurrentSessionEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ConcurrentSessionEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_state() const { return at<1>().valid(); } + int32_t state() const { return at<1>().as_int32(); } + bool has_session_name() const { return at<2>().valid(); } + ::protozero::ConstChars session_name() const { return at<2>().as_string(); } + bool has_session_id() const { return at<3>().valid(); } + uint64_t session_id() const { return at<3>().as_uint64(); } + bool has_consumer_uid() const { return at<4>().valid(); } + int32_t consumer_uid() const { return at<4>().as_int32(); } + bool has_num_data_sources() const { return at<5>().valid(); } + uint32_t num_data_sources() const { return at<5>().as_uint32(); } +}; + +class ConcurrentSessionEvent : public ::protozero::Message { + public: + using Decoder = ConcurrentSessionEvent_Decoder; + enum : int32_t { + kStateFieldNumber = 1, + kSessionNameFieldNumber = 2, + kSessionIdFieldNumber = 3, + kConsumerUidFieldNumber = 4, + kNumDataSourcesFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ConcurrentSessionEvent"; } + + + using State = ::perfetto::protos::pbzero::ConcurrentSessionEvent_State; + static inline const char* State_Name(State value) { + return ::perfetto::protos::pbzero::ConcurrentSessionEvent_State_Name(value); + } + static inline const State STATE_UNSPECIFIED = State::STATE_UNSPECIFIED; + static inline const State STATE_DISABLED = State::STATE_DISABLED; + static inline const State STATE_CONFIGURED = State::STATE_CONFIGURED; + static inline const State STATE_STARTED = State::STATE_STARTED; + static inline const State STATE_DISABLING_WAITING_STOP_ACKS = State::STATE_DISABLING_WAITING_STOP_ACKS; + static inline const State STATE_CLONED_READ_ONLY = State::STATE_CLONED_READ_ONLY; + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ConcurrentSessionEvent_State, + ConcurrentSessionEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(ConcurrentSessionEvent_State value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SessionName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ConcurrentSessionEvent>; + + static constexpr FieldMetadata_SessionName kSessionName{}; + void set_session_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SessionName::kFieldId, data, size); + } + void set_session_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SessionName::kFieldId, chars.data, chars.size); + } + void set_session_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SessionName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SessionId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ConcurrentSessionEvent>; + + static constexpr FieldMetadata_SessionId kSessionId{}; + void set_session_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ConsumerUid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ConcurrentSessionEvent>; + + static constexpr FieldMetadata_ConsumerUid kConsumerUid{}; + void set_consumer_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ConsumerUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumDataSources = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ConcurrentSessionEvent>; + + static constexpr FieldMetadata_NumDataSources kNumDataSources{}; + void set_num_data_sources(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumDataSources::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -184176,6 +183856,7 @@ namespace perfetto { namespace protos { namespace pbzero { class PerfSampleDefaults; +class StackSampleDefaults; class TrackEventDefaults; class V8CodeDefaults; } // Namespace pbzero. @@ -184186,7 +183867,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class TracePacketDefaults_Decoder : public ::protozero::TypedProtoDecoder { +class TracePacketDefaults_Decoder : public ::protozero::TypedProtoDecoder { public: TracePacketDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TracePacketDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -184197,6 +183878,8 @@ class TracePacketDefaults_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_perf_sample_defaults() const { return at<12>().valid(); } ::protozero::ConstBytes perf_sample_defaults() const { return at<12>().as_bytes(); } + bool has_stack_sample_defaults() const { return at<100>().valid(); } + ::protozero::ConstBytes stack_sample_defaults() const { return at<100>().as_bytes(); } bool has_v8_code_defaults() const { return at<99>().valid(); } ::protozero::ConstBytes v8_code_defaults() const { return at<99>().as_bytes(); } }; @@ -184208,6 +183891,7 @@ class TracePacketDefaults : public ::protozero::Message { kTimestampClockIdFieldNumber = 58, kTrackEventDefaultsFieldNumber = 11, kPerfSampleDefaultsFieldNumber = 12, + kStackSampleDefaultsFieldNumber = 100, kV8CodeDefaultsFieldNumber = 99, }; static constexpr const char* GetName() { return ".perfetto.protos.TracePacketDefaults"; } @@ -184259,6 +183943,20 @@ class TracePacketDefaults : public ::protozero::Message { } + using FieldMetadata_StackSampleDefaults = + ::protozero::proto_utils::FieldMetadata< + 100, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StackSampleDefaults, + TracePacketDefaults>; + + static constexpr FieldMetadata_StackSampleDefaults kStackSampleDefaults{}; + template T* set_stack_sample_defaults() { + return BeginNestedMessage(100); + } + + using FieldMetadata_V8CodeDefaults = ::protozero::proto_utils::FieldMetadata< 99, @@ -189882,8 +189580,8 @@ class LogMessage; class TaskExecution; class DebugAnnotation; class DebugAnnotation_NestedValue; -class TrackEvent_Callstack; -class TrackEvent_Callstack_Frame; +class TrackEvent_InlineCallstack; +class TrackEvent_InlineCallstack_Frame; enum TrackEvent_Type : int; enum TrackEvent_LegacyEvent_FlowDirection : int; enum TrackEvent_LegacyEvent_InstantEventScope : int; @@ -190078,7 +189776,7 @@ class PERFETTO_EXPORT_COMPONENT TrackEventDefaults : public ::protozero::CppMess class PERFETTO_EXPORT_COMPONENT TrackEvent : public ::protozero::CppMessageObj { public: - using Callstack = TrackEvent_Callstack; + using InlineCallstack = TrackEvent_InlineCallstack; using LegacyEvent = TrackEvent_LegacyEvent; using Type = TrackEvent_Type; static constexpr auto TYPE_UNSPECIFIED = TrackEvent_Type_TYPE_UNSPECIFIED; @@ -190111,6 +189809,7 @@ class PERFETTO_EXPORT_COMPONENT TrackEvent : public ::protozero::CppMessageObj { kCorrelationIdStrIidFieldNumber = 54, kCallstackFieldNumber = 55, kCallstackIidFieldNumber = 56, + kCallstackWeightFieldNumber = 57, kDebugAnnotationsFieldNumber = 4, kTaskExecutionFieldNumber = 5, kLogMessageFieldNumber = 21, @@ -190261,13 +189960,17 @@ class PERFETTO_EXPORT_COMPONENT TrackEvent : public ::protozero::CppMessageObj { void set_correlation_id_str_iid(uint64_t value) { correlation_id_str_iid_ = value; _has_field_.set(54); } bool has_callstack() const { return _has_field_[55]; } - const TrackEvent_Callstack& callstack() const { return *callstack_; } - TrackEvent_Callstack* mutable_callstack() { _has_field_.set(55); return callstack_.get(); } + const TrackEvent_InlineCallstack& callstack() const { return *callstack_; } + TrackEvent_InlineCallstack* mutable_callstack() { _has_field_.set(55); return callstack_.get(); } bool has_callstack_iid() const { return _has_field_[56]; } uint64_t callstack_iid() const { return callstack_iid_; } void set_callstack_iid(uint64_t value) { callstack_iid_ = value; _has_field_.set(56); } + bool has_callstack_weight() const { return _has_field_[57]; } + double callstack_weight() const { return callstack_weight_; } + void set_callstack_weight(double value) { callstack_weight_ = value; _has_field_.set(57); } + const std::vector& debug_annotations() const { return debug_annotations_; } std::vector* mutable_debug_annotations() { return &debug_annotations_; } int debug_annotations_size() const; @@ -190398,8 +190101,9 @@ class PERFETTO_EXPORT_COMPONENT TrackEvent : public ::protozero::CppMessageObj { uint64_t correlation_id_{}; std::string correlation_id_str_{}; uint64_t correlation_id_str_iid_{}; - ::protozero::CopyablePtr callstack_; + ::protozero::CopyablePtr callstack_; uint64_t callstack_iid_{}; + double callstack_weight_{}; std::vector debug_annotations_; ::protozero::CopyablePtr task_execution_; ::protozero::CopyablePtr log_message_; @@ -190432,7 +190136,7 @@ class PERFETTO_EXPORT_COMPONENT TrackEvent : public ::protozero::CppMessageObj { // with future versions of .proto files. std::string unknown_fields_; - std::bitset<57> _has_field_{}; + std::bitset<58> _has_field_{}; }; @@ -190575,35 +190279,35 @@ class PERFETTO_EXPORT_COMPONENT TrackEvent_LegacyEvent : public ::protozero::Cpp }; -class PERFETTO_EXPORT_COMPONENT TrackEvent_Callstack : public ::protozero::CppMessageObj { +class PERFETTO_EXPORT_COMPONENT TrackEvent_InlineCallstack : public ::protozero::CppMessageObj { public: - using Frame = TrackEvent_Callstack_Frame; + using Frame = TrackEvent_InlineCallstack_Frame; enum FieldNumbers { kFramesFieldNumber = 1, }; - TrackEvent_Callstack(); - ~TrackEvent_Callstack() override; - TrackEvent_Callstack(TrackEvent_Callstack&&) noexcept; - TrackEvent_Callstack& operator=(TrackEvent_Callstack&&); - TrackEvent_Callstack(const TrackEvent_Callstack&); - TrackEvent_Callstack& operator=(const TrackEvent_Callstack&); - bool operator==(const TrackEvent_Callstack&) const; - bool operator!=(const TrackEvent_Callstack& other) const { return !(*this == other); } + TrackEvent_InlineCallstack(); + ~TrackEvent_InlineCallstack() override; + TrackEvent_InlineCallstack(TrackEvent_InlineCallstack&&) noexcept; + TrackEvent_InlineCallstack& operator=(TrackEvent_InlineCallstack&&); + TrackEvent_InlineCallstack(const TrackEvent_InlineCallstack&); + TrackEvent_InlineCallstack& operator=(const TrackEvent_InlineCallstack&); + bool operator==(const TrackEvent_InlineCallstack&) const; + bool operator!=(const TrackEvent_InlineCallstack& other) const { return !(*this == other); } bool ParseFromArray(const void*, size_t) override; std::string SerializeAsString() const override; std::vector SerializeAsArray() const override; void Serialize(::protozero::Message*) const; - const std::vector& frames() const { return frames_; } - std::vector* mutable_frames() { return &frames_; } + const std::vector& frames() const { return frames_; } + std::vector* mutable_frames() { return &frames_; } int frames_size() const; void clear_frames(); - TrackEvent_Callstack_Frame* add_frames(); + TrackEvent_InlineCallstack_Frame* add_frames(); private: - std::vector frames_; + std::vector frames_; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. @@ -190613,7 +190317,7 @@ class PERFETTO_EXPORT_COMPONENT TrackEvent_Callstack : public ::protozero::CppMe }; -class PERFETTO_EXPORT_COMPONENT TrackEvent_Callstack_Frame : public ::protozero::CppMessageObj { +class PERFETTO_EXPORT_COMPONENT TrackEvent_InlineCallstack_Frame : public ::protozero::CppMessageObj { public: enum FieldNumbers { kFunctionNameFieldNumber = 1, @@ -190621,14 +190325,14 @@ class PERFETTO_EXPORT_COMPONENT TrackEvent_Callstack_Frame : public ::protozero: kLineNumberFieldNumber = 3, }; - TrackEvent_Callstack_Frame(); - ~TrackEvent_Callstack_Frame() override; - TrackEvent_Callstack_Frame(TrackEvent_Callstack_Frame&&) noexcept; - TrackEvent_Callstack_Frame& operator=(TrackEvent_Callstack_Frame&&); - TrackEvent_Callstack_Frame(const TrackEvent_Callstack_Frame&); - TrackEvent_Callstack_Frame& operator=(const TrackEvent_Callstack_Frame&); - bool operator==(const TrackEvent_Callstack_Frame&) const; - bool operator!=(const TrackEvent_Callstack_Frame& other) const { return !(*this == other); } + TrackEvent_InlineCallstack_Frame(); + ~TrackEvent_InlineCallstack_Frame() override; + TrackEvent_InlineCallstack_Frame(TrackEvent_InlineCallstack_Frame&&) noexcept; + TrackEvent_InlineCallstack_Frame& operator=(TrackEvent_InlineCallstack_Frame&&); + TrackEvent_InlineCallstack_Frame(const TrackEvent_InlineCallstack_Frame&); + TrackEvent_InlineCallstack_Frame& operator=(const TrackEvent_InlineCallstack_Frame&); + bool operator==(const TrackEvent_InlineCallstack_Frame&) const; + bool operator!=(const TrackEvent_InlineCallstack_Frame& other) const { return !(*this == other); } bool ParseFromArray(const void*, size_t) override; std::string SerializeAsString() const override; @@ -190714,11 +190418,11 @@ class TraceStats; class TraceStats_FilterStats; class TraceStats_WriterStats; class TraceStats_BufferStats; -class TraceStats_BufferStats_ShadowBufferStats; class GetTraceStatsRequest; class AttachResponse; class TraceConfig; -class TraceConfig_Note; +class TraceAttributes; +class TraceAttributes_Attribute; class PriorityBoostConfig; class TraceConfig_SessionSemaphore; class TraceConfig_CmdTraceStartDelay; @@ -190727,6 +190431,9 @@ class TraceConfig_TraceFilter; class TraceConfig_TraceFilter_StringFilterChain; class TraceConfig_TraceFilter_StringFilterRule; class TraceConfig_IncidentReportConfig; +class TraceConfig_CompressionConfig; +class TraceConfig_CompressionConfig_Zstd; +class TraceConfig_CompressionConfig_Deflate; class TraceConfig_IncrementalStateConfig; class TraceConfig_TriggerConfig; class TraceConfig_TriggerConfig_Trigger;