mainline/platform/sdk/include_gen/external/perfetto/perfetto_protos_perfetto_trace_track_event_lite_gen_headers/gen/external/perfetto/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3009001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
#include "protos/perfetto/trace/track_event/source_location.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[10]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
namespace perfetto {
namespace protos {
class BeginFrameArgs;
class BeginFrameArgsDefaultTypeInternal;
extern BeginFrameArgsDefaultTypeInternal _BeginFrameArgs_default_instance_;
class BeginFrameObserverState;
class BeginFrameObserverStateDefaultTypeInternal;
extern BeginFrameObserverStateDefaultTypeInternal _BeginFrameObserverState_default_instance_;
class BeginFrameSourceState;
class BeginFrameSourceStateDefaultTypeInternal;
extern BeginFrameSourceStateDefaultTypeInternal _BeginFrameSourceState_default_instance_;
class BeginImplFrameArgs;
class BeginImplFrameArgsDefaultTypeInternal;
extern BeginImplFrameArgsDefaultTypeInternal _BeginImplFrameArgs_default_instance_;
class BeginImplFrameArgs_TimestampsInUs;
class BeginImplFrameArgs_TimestampsInUsDefaultTypeInternal;
extern BeginImplFrameArgs_TimestampsInUsDefaultTypeInternal _BeginImplFrameArgs_TimestampsInUs_default_instance_;
class ChromeCompositorSchedulerState;
class ChromeCompositorSchedulerStateDefaultTypeInternal;
extern ChromeCompositorSchedulerStateDefaultTypeInternal _ChromeCompositorSchedulerState_default_instance_;
class ChromeCompositorStateMachine;
class ChromeCompositorStateMachineDefaultTypeInternal;
extern ChromeCompositorStateMachineDefaultTypeInternal _ChromeCompositorStateMachine_default_instance_;
class ChromeCompositorStateMachine_MajorState;
class ChromeCompositorStateMachine_MajorStateDefaultTypeInternal;
extern ChromeCompositorStateMachine_MajorStateDefaultTypeInternal _ChromeCompositorStateMachine_MajorState_default_instance_;
class ChromeCompositorStateMachine_MinorState;
class ChromeCompositorStateMachine_MinorStateDefaultTypeInternal;
extern ChromeCompositorStateMachine_MinorStateDefaultTypeInternal _ChromeCompositorStateMachine_MinorState_default_instance_;
class CompositorTimingHistory;
class CompositorTimingHistoryDefaultTypeInternal;
extern CompositorTimingHistoryDefaultTypeInternal _CompositorTimingHistory_default_instance_;
}  // namespace protos
}  // namespace perfetto
PROTOBUF_NAMESPACE_OPEN
template<> ::perfetto::protos::BeginFrameArgs* Arena::CreateMaybeMessage<::perfetto::protos::BeginFrameArgs>(Arena*);
template<> ::perfetto::protos::BeginFrameObserverState* Arena::CreateMaybeMessage<::perfetto::protos::BeginFrameObserverState>(Arena*);
template<> ::perfetto::protos::BeginFrameSourceState* Arena::CreateMaybeMessage<::perfetto::protos::BeginFrameSourceState>(Arena*);
template<> ::perfetto::protos::BeginImplFrameArgs* Arena::CreateMaybeMessage<::perfetto::protos::BeginImplFrameArgs>(Arena*);
template<> ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* Arena::CreateMaybeMessage<::perfetto::protos::BeginImplFrameArgs_TimestampsInUs>(Arena*);
template<> ::perfetto::protos::ChromeCompositorSchedulerState* Arena::CreateMaybeMessage<::perfetto::protos::ChromeCompositorSchedulerState>(Arena*);
template<> ::perfetto::protos::ChromeCompositorStateMachine* Arena::CreateMaybeMessage<::perfetto::protos::ChromeCompositorStateMachine>(Arena*);
template<> ::perfetto::protos::ChromeCompositorStateMachine_MajorState* Arena::CreateMaybeMessage<::perfetto::protos::ChromeCompositorStateMachine_MajorState>(Arena*);
template<> ::perfetto::protos::ChromeCompositorStateMachine_MinorState* Arena::CreateMaybeMessage<::perfetto::protos::ChromeCompositorStateMachine_MinorState>(Arena*);
template<> ::perfetto::protos::CompositorTimingHistory* Arena::CreateMaybeMessage<::perfetto::protos::CompositorTimingHistory>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace perfetto {
namespace protos {

enum ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode : int {
  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED = 0,
  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_NONE = 1,
  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_IMMEDIATE = 2,
  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_REGULAR = 3,
  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_LATE = 4,
  ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED = 5
};
bool ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_IsValid(int value);
constexpr ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_BeginImplFrameDeadlineMode_MIN = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED;
constexpr ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_BeginImplFrameDeadlineMode_MAX = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED;
constexpr int ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_BeginImplFrameDeadlineMode_ARRAYSIZE = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_BeginImplFrameDeadlineMode_MAX + 1;

const std::string& ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value);
template<typename T>
inline const std::string& ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name.");
  return ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(static_cast<ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode>(enum_t_value));
}
bool ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Parse(
    const std::string& name, ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode* value);
enum ChromeCompositorStateMachine_MajorState_BeginImplFrameState : int {
  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED = 0,
  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_IDLE = 1,
  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = 2,
  ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE = 3
};
bool ChromeCompositorStateMachine_MajorState_BeginImplFrameState_IsValid(int value);
constexpr ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BeginImplFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED;
constexpr ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BeginImplFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
constexpr int ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BeginImplFrameState_ARRAYSIZE = ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BeginImplFrameState_MAX + 1;

const std::string& ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(ChromeCompositorStateMachine_MajorState_BeginImplFrameState value);
template<typename T>
inline const std::string& ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ChromeCompositorStateMachine_MajorState_BeginImplFrameState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name.");
  return ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(static_cast<ChromeCompositorStateMachine_MajorState_BeginImplFrameState>(enum_t_value));
}
bool ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Parse(
    const std::string& name, ChromeCompositorStateMachine_MajorState_BeginImplFrameState* value);
enum ChromeCompositorStateMachine_MajorState_BeginMainFrameState : int {
  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED = 0,
  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_IDLE = 1,
  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_SENT = 2,
  ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT = 3
};
bool ChromeCompositorStateMachine_MajorState_BeginMainFrameState_IsValid(int value);
constexpr ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BeginMainFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED;
constexpr ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BeginMainFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT;
constexpr int ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BeginMainFrameState_ARRAYSIZE = ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BeginMainFrameState_MAX + 1;

const std::string& ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(ChromeCompositorStateMachine_MajorState_BeginMainFrameState value);
template<typename T>
inline const std::string& ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ChromeCompositorStateMachine_MajorState_BeginMainFrameState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name.");
  return ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(static_cast<ChromeCompositorStateMachine_MajorState_BeginMainFrameState>(enum_t_value));
}
bool ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Parse(
    const std::string& name, ChromeCompositorStateMachine_MajorState_BeginMainFrameState* value);
enum ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState : int {
  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED = 0,
  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_NONE = 1,
  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_ACTIVE = 2,
  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_CREATING = 3,
  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = 4,
  ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = 5
};
bool ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_IsValid(int value);
constexpr ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LayerTreeFrameSinkState_MIN = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED;
constexpr ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LayerTreeFrameSinkState_MAX = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
constexpr int ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LayerTreeFrameSinkState_ARRAYSIZE = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LayerTreeFrameSinkState_MAX + 1;

const std::string& ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value);
template<typename T>
inline const std::string& ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name.");
  return ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(static_cast<ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState>(enum_t_value));
}
bool ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Parse(
    const std::string& name, ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState* value);
enum ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState : int {
  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED = 0,
  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_IDLE = 1,
  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_COMMIT = 2,
  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_ACTIVATION = 3,
  ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW = 4
};
bool ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_IsValid(int value);
constexpr ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_ForcedRedrawOnTimeoutState_MIN = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED;
constexpr ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_ForcedRedrawOnTimeoutState_MAX = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW;
constexpr int ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_ForcedRedrawOnTimeoutState_ARRAYSIZE = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_ForcedRedrawOnTimeoutState_MAX + 1;

const std::string& ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value);
template<typename T>
inline const std::string& ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name.");
  return ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(static_cast<ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState>(enum_t_value));
}
bool ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Parse(
    const std::string& name, ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState* value);
enum ChromeCompositorStateMachine_MinorState_TreePriority : int {
  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED = 0,
  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = 1,
  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = 2,
  ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = 3
};
bool ChromeCompositorStateMachine_MinorState_TreePriority_IsValid(int value);
constexpr ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState_TreePriority_TreePriority_MIN = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED;
constexpr ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState_TreePriority_TreePriority_MAX = ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
constexpr int ChromeCompositorStateMachine_MinorState_TreePriority_TreePriority_ARRAYSIZE = ChromeCompositorStateMachine_MinorState_TreePriority_TreePriority_MAX + 1;

const std::string& ChromeCompositorStateMachine_MinorState_TreePriority_Name(ChromeCompositorStateMachine_MinorState_TreePriority value);
template<typename T>
inline const std::string& ChromeCompositorStateMachine_MinorState_TreePriority_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ChromeCompositorStateMachine_MinorState_TreePriority>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ChromeCompositorStateMachine_MinorState_TreePriority_Name.");
  return ChromeCompositorStateMachine_MinorState_TreePriority_Name(static_cast<ChromeCompositorStateMachine_MinorState_TreePriority>(enum_t_value));
}
bool ChromeCompositorStateMachine_MinorState_TreePriority_Parse(
    const std::string& name, ChromeCompositorStateMachine_MinorState_TreePriority* value);
enum ChromeCompositorStateMachine_MinorState_ScrollHandlerState : int {
  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED = 0,
  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_AFFECTS_SCROLL_HANDLER = 1,
  ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = 2
};
bool ChromeCompositorStateMachine_MinorState_ScrollHandlerState_IsValid(int value);
constexpr ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState_ScrollHandlerState_ScrollHandlerState_MIN = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED;
constexpr ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState_ScrollHandlerState_ScrollHandlerState_MAX = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
constexpr int ChromeCompositorStateMachine_MinorState_ScrollHandlerState_ScrollHandlerState_ARRAYSIZE = ChromeCompositorStateMachine_MinorState_ScrollHandlerState_ScrollHandlerState_MAX + 1;

const std::string& ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(ChromeCompositorStateMachine_MinorState_ScrollHandlerState value);
template<typename T>
inline const std::string& ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ChromeCompositorStateMachine_MinorState_ScrollHandlerState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name.");
  return ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(static_cast<ChromeCompositorStateMachine_MinorState_ScrollHandlerState>(enum_t_value));
}
bool ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Parse(
    const std::string& name, ChromeCompositorStateMachine_MinorState_ScrollHandlerState* value);
enum BeginFrameArgs_BeginFrameArgsType : int {
  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = 0,
  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_INVALID = 1,
  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_NORMAL = 2,
  BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED = 3
};
bool BeginFrameArgs_BeginFrameArgsType_IsValid(int value);
constexpr BeginFrameArgs_BeginFrameArgsType BeginFrameArgs_BeginFrameArgsType_BeginFrameArgsType_MIN = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
constexpr BeginFrameArgs_BeginFrameArgsType BeginFrameArgs_BeginFrameArgsType_BeginFrameArgsType_MAX = BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED;
constexpr int BeginFrameArgs_BeginFrameArgsType_BeginFrameArgsType_ARRAYSIZE = BeginFrameArgs_BeginFrameArgsType_BeginFrameArgsType_MAX + 1;

const std::string& BeginFrameArgs_BeginFrameArgsType_Name(BeginFrameArgs_BeginFrameArgsType value);
template<typename T>
inline const std::string& BeginFrameArgs_BeginFrameArgsType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BeginFrameArgs_BeginFrameArgsType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BeginFrameArgs_BeginFrameArgsType_Name.");
  return BeginFrameArgs_BeginFrameArgsType_Name(static_cast<BeginFrameArgs_BeginFrameArgsType>(enum_t_value));
}
bool BeginFrameArgs_BeginFrameArgsType_Parse(
    const std::string& name, BeginFrameArgs_BeginFrameArgsType* value);
enum BeginImplFrameArgs_State : int {
  BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED = 0,
  BeginImplFrameArgs_State_BEGIN_FRAME_USING = 1
};
bool BeginImplFrameArgs_State_IsValid(int value);
constexpr BeginImplFrameArgs_State BeginImplFrameArgs_State_State_MIN = BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED;
constexpr BeginImplFrameArgs_State BeginImplFrameArgs_State_State_MAX = BeginImplFrameArgs_State_BEGIN_FRAME_USING;
constexpr int BeginImplFrameArgs_State_State_ARRAYSIZE = BeginImplFrameArgs_State_State_MAX + 1;

const std::string& BeginImplFrameArgs_State_Name(BeginImplFrameArgs_State value);
template<typename T>
inline const std::string& BeginImplFrameArgs_State_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BeginImplFrameArgs_State>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BeginImplFrameArgs_State_Name.");
  return BeginImplFrameArgs_State_Name(static_cast<BeginImplFrameArgs_State>(enum_t_value));
}
bool BeginImplFrameArgs_State_Parse(
    const std::string& name, BeginImplFrameArgs_State* value);
enum ChromeCompositorSchedulerAction : int {
  CC_SCHEDULER_ACTION_UNSPECIFIED = 0,
  CC_SCHEDULER_ACTION_NONE = 1,
  CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME = 2,
  CC_SCHEDULER_ACTION_COMMIT = 3,
  CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE = 4,
  CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE = 5,
  CC_SCHEDULER_ACTION_DRAW_FORCED = 6,
  CC_SCHEDULER_ACTION_DRAW_ABORT = 7,
  CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION = 8,
  CC_SCHEDULER_ACTION_PREPARE_TILES = 9,
  CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK = 10,
  CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION = 11,
  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL = 12,
  CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON = 13
};
bool ChromeCompositorSchedulerAction_IsValid(int value);
constexpr ChromeCompositorSchedulerAction ChromeCompositorSchedulerAction_MIN = CC_SCHEDULER_ACTION_UNSPECIFIED;
constexpr ChromeCompositorSchedulerAction ChromeCompositorSchedulerAction_MAX = CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON;
constexpr int ChromeCompositorSchedulerAction_ARRAYSIZE = ChromeCompositorSchedulerAction_MAX + 1;

const std::string& ChromeCompositorSchedulerAction_Name(ChromeCompositorSchedulerAction value);
template<typename T>
inline const std::string& ChromeCompositorSchedulerAction_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ChromeCompositorSchedulerAction>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ChromeCompositorSchedulerAction_Name.");
  return ChromeCompositorSchedulerAction_Name(static_cast<ChromeCompositorSchedulerAction>(enum_t_value));
}
bool ChromeCompositorSchedulerAction_Parse(
    const std::string& name, ChromeCompositorSchedulerAction* value);
// ===================================================================

class ChromeCompositorSchedulerState :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeCompositorSchedulerState) */ {
 public:
  ChromeCompositorSchedulerState();
  virtual ~ChromeCompositorSchedulerState();

  ChromeCompositorSchedulerState(const ChromeCompositorSchedulerState& from);
  ChromeCompositorSchedulerState(ChromeCompositorSchedulerState&& from) noexcept
    : ChromeCompositorSchedulerState() {
    *this = ::std::move(from);
  }

  inline ChromeCompositorSchedulerState& operator=(const ChromeCompositorSchedulerState& from) {
    CopyFrom(from);
    return *this;
  }
  inline ChromeCompositorSchedulerState& operator=(ChromeCompositorSchedulerState&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ChromeCompositorSchedulerState& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ChromeCompositorSchedulerState* internal_default_instance() {
    return reinterpret_cast<const ChromeCompositorSchedulerState*>(
               &_ChromeCompositorSchedulerState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(ChromeCompositorSchedulerState& a, ChromeCompositorSchedulerState& b) {
    a.Swap(&b);
  }
  inline void Swap(ChromeCompositorSchedulerState* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ChromeCompositorSchedulerState* New() const final {
    return CreateMaybeMessage<ChromeCompositorSchedulerState>(nullptr);
  }

  ChromeCompositorSchedulerState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ChromeCompositorSchedulerState>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const ChromeCompositorSchedulerState& from);
  void MergeFrom(const ChromeCompositorSchedulerState& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ChromeCompositorSchedulerState* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.ChromeCompositorSchedulerState";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode BeginImplFrameDeadlineMode;
  static constexpr BeginImplFrameDeadlineMode DEADLINE_MODE_UNSPECIFIED =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_UNSPECIFIED;
  static constexpr BeginImplFrameDeadlineMode DEADLINE_MODE_NONE =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_NONE;
  static constexpr BeginImplFrameDeadlineMode DEADLINE_MODE_IMMEDIATE =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_IMMEDIATE;
  static constexpr BeginImplFrameDeadlineMode DEADLINE_MODE_REGULAR =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_REGULAR;
  static constexpr BeginImplFrameDeadlineMode DEADLINE_MODE_LATE =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_LATE;
  static constexpr BeginImplFrameDeadlineMode DEADLINE_MODE_BLOCKED =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_DEADLINE_MODE_BLOCKED;
  static inline bool BeginImplFrameDeadlineMode_IsValid(int value) {
    return ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_IsValid(value);
  }
  static constexpr BeginImplFrameDeadlineMode BeginImplFrameDeadlineMode_MIN =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_BeginImplFrameDeadlineMode_MIN;
  static constexpr BeginImplFrameDeadlineMode BeginImplFrameDeadlineMode_MAX =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_BeginImplFrameDeadlineMode_MAX;
  static constexpr int BeginImplFrameDeadlineMode_ARRAYSIZE =
    ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_BeginImplFrameDeadlineMode_ARRAYSIZE;
  template<typename T>
  static inline const std::string& BeginImplFrameDeadlineMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BeginImplFrameDeadlineMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BeginImplFrameDeadlineMode_Name.");
    return ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(enum_t_value);
  }
  static inline bool BeginImplFrameDeadlineMode_Parse(const std::string& name,
      BeginImplFrameDeadlineMode* value) {
    return ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kStateMachineFieldNumber = 1,
    kBeginImplFrameArgsFieldNumber = 14,
    kBeginFrameObserverStateFieldNumber = 15,
    kBeginFrameSourceStateFieldNumber = 16,
    kCompositorTimingHistoryFieldNumber = 17,
    kObservingBeginFrameSourceFieldNumber = 2,
    kBeginImplFrameDeadlineTaskFieldNumber = 3,
    kPendingBeginFrameTaskFieldNumber = 4,
    kSkippedLastFrameMissedExceededDeadlineFieldNumber = 5,
    kInsideActionFieldNumber = 7,
    kDeadlineUsFieldNumber = 9,
    kDeadlineScheduledAtUsFieldNumber = 10,
    kNowUsFieldNumber = 11,
    kNowToDeadlineDeltaUsFieldNumber = 12,
    kNowToDeadlineScheduledAtDeltaUsFieldNumber = 13,
    kDeadlineModeFieldNumber = 8,
  };
  // optional .perfetto.protos.ChromeCompositorStateMachine state_machine = 1;
  bool has_state_machine() const;
  void clear_state_machine();
  const ::perfetto::protos::ChromeCompositorStateMachine& state_machine() const;
  ::perfetto::protos::ChromeCompositorStateMachine* release_state_machine();
  ::perfetto::protos::ChromeCompositorStateMachine* mutable_state_machine();
  void set_allocated_state_machine(::perfetto::protos::ChromeCompositorStateMachine* state_machine);

  // optional .perfetto.protos.BeginImplFrameArgs begin_impl_frame_args = 14;
  bool has_begin_impl_frame_args() const;
  void clear_begin_impl_frame_args();
  const ::perfetto::protos::BeginImplFrameArgs& begin_impl_frame_args() const;
  ::perfetto::protos::BeginImplFrameArgs* release_begin_impl_frame_args();
  ::perfetto::protos::BeginImplFrameArgs* mutable_begin_impl_frame_args();
  void set_allocated_begin_impl_frame_args(::perfetto::protos::BeginImplFrameArgs* begin_impl_frame_args);

  // optional .perfetto.protos.BeginFrameObserverState begin_frame_observer_state = 15;
  bool has_begin_frame_observer_state() const;
  void clear_begin_frame_observer_state();
  const ::perfetto::protos::BeginFrameObserverState& begin_frame_observer_state() const;
  ::perfetto::protos::BeginFrameObserverState* release_begin_frame_observer_state();
  ::perfetto::protos::BeginFrameObserverState* mutable_begin_frame_observer_state();
  void set_allocated_begin_frame_observer_state(::perfetto::protos::BeginFrameObserverState* begin_frame_observer_state);

  // optional .perfetto.protos.BeginFrameSourceState begin_frame_source_state = 16;
  bool has_begin_frame_source_state() const;
  void clear_begin_frame_source_state();
  const ::perfetto::protos::BeginFrameSourceState& begin_frame_source_state() const;
  ::perfetto::protos::BeginFrameSourceState* release_begin_frame_source_state();
  ::perfetto::protos::BeginFrameSourceState* mutable_begin_frame_source_state();
  void set_allocated_begin_frame_source_state(::perfetto::protos::BeginFrameSourceState* begin_frame_source_state);

  // optional .perfetto.protos.CompositorTimingHistory compositor_timing_history = 17;
  bool has_compositor_timing_history() const;
  void clear_compositor_timing_history();
  const ::perfetto::protos::CompositorTimingHistory& compositor_timing_history() const;
  ::perfetto::protos::CompositorTimingHistory* release_compositor_timing_history();
  ::perfetto::protos::CompositorTimingHistory* mutable_compositor_timing_history();
  void set_allocated_compositor_timing_history(::perfetto::protos::CompositorTimingHistory* compositor_timing_history);

  // optional bool observing_begin_frame_source = 2;
  bool has_observing_begin_frame_source() const;
  void clear_observing_begin_frame_source();
  bool observing_begin_frame_source() const;
  void set_observing_begin_frame_source(bool value);

  // optional bool begin_impl_frame_deadline_task = 3;
  bool has_begin_impl_frame_deadline_task() const;
  void clear_begin_impl_frame_deadline_task();
  bool begin_impl_frame_deadline_task() const;
  void set_begin_impl_frame_deadline_task(bool value);

  // optional bool pending_begin_frame_task = 4;
  bool has_pending_begin_frame_task() const;
  void clear_pending_begin_frame_task();
  bool pending_begin_frame_task() const;
  void set_pending_begin_frame_task(bool value);

  // optional bool skipped_last_frame_missed_exceeded_deadline = 5;
  bool has_skipped_last_frame_missed_exceeded_deadline() const;
  void clear_skipped_last_frame_missed_exceeded_deadline();
  bool skipped_last_frame_missed_exceeded_deadline() const;
  void set_skipped_last_frame_missed_exceeded_deadline(bool value);

  // optional .perfetto.protos.ChromeCompositorSchedulerAction inside_action = 7;
  bool has_inside_action() const;
  void clear_inside_action();
  ::perfetto::protos::ChromeCompositorSchedulerAction inside_action() const;
  void set_inside_action(::perfetto::protos::ChromeCompositorSchedulerAction value);

  // optional int64 deadline_us = 9;
  bool has_deadline_us() const;
  void clear_deadline_us();
  ::PROTOBUF_NAMESPACE_ID::int64 deadline_us() const;
  void set_deadline_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 deadline_scheduled_at_us = 10;
  bool has_deadline_scheduled_at_us() const;
  void clear_deadline_scheduled_at_us();
  ::PROTOBUF_NAMESPACE_ID::int64 deadline_scheduled_at_us() const;
  void set_deadline_scheduled_at_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 now_us = 11;
  bool has_now_us() const;
  void clear_now_us();
  ::PROTOBUF_NAMESPACE_ID::int64 now_us() const;
  void set_now_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 now_to_deadline_delta_us = 12;
  bool has_now_to_deadline_delta_us() const;
  void clear_now_to_deadline_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 now_to_deadline_delta_us() const;
  void set_now_to_deadline_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 now_to_deadline_scheduled_at_delta_us = 13;
  bool has_now_to_deadline_scheduled_at_delta_us() const;
  void clear_now_to_deadline_scheduled_at_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 now_to_deadline_scheduled_at_delta_us() const;
  void set_now_to_deadline_scheduled_at_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional .perfetto.protos.ChromeCompositorSchedulerState.BeginImplFrameDeadlineMode deadline_mode = 8;
  bool has_deadline_mode() const;
  void clear_deadline_mode();
  ::perfetto::protos::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode deadline_mode() const;
  void set_deadline_mode(::perfetto::protos::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeCompositorSchedulerState)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::perfetto::protos::ChromeCompositorStateMachine* state_machine_;
  ::perfetto::protos::BeginImplFrameArgs* begin_impl_frame_args_;
  ::perfetto::protos::BeginFrameObserverState* begin_frame_observer_state_;
  ::perfetto::protos::BeginFrameSourceState* begin_frame_source_state_;
  ::perfetto::protos::CompositorTimingHistory* compositor_timing_history_;
  bool observing_begin_frame_source_;
  bool begin_impl_frame_deadline_task_;
  bool pending_begin_frame_task_;
  bool skipped_last_frame_missed_exceeded_deadline_;
  int inside_action_;
  ::PROTOBUF_NAMESPACE_ID::int64 deadline_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 deadline_scheduled_at_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 now_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 now_to_deadline_delta_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 now_to_deadline_scheduled_at_delta_us_;
  int deadline_mode_;
  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class ChromeCompositorStateMachine_MajorState :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeCompositorStateMachine.MajorState) */ {
 public:
  ChromeCompositorStateMachine_MajorState();
  virtual ~ChromeCompositorStateMachine_MajorState();

  ChromeCompositorStateMachine_MajorState(const ChromeCompositorStateMachine_MajorState& from);
  ChromeCompositorStateMachine_MajorState(ChromeCompositorStateMachine_MajorState&& from) noexcept
    : ChromeCompositorStateMachine_MajorState() {
    *this = ::std::move(from);
  }

  inline ChromeCompositorStateMachine_MajorState& operator=(const ChromeCompositorStateMachine_MajorState& from) {
    CopyFrom(from);
    return *this;
  }
  inline ChromeCompositorStateMachine_MajorState& operator=(ChromeCompositorStateMachine_MajorState&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ChromeCompositorStateMachine_MajorState& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ChromeCompositorStateMachine_MajorState* internal_default_instance() {
    return reinterpret_cast<const ChromeCompositorStateMachine_MajorState*>(
               &_ChromeCompositorStateMachine_MajorState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(ChromeCompositorStateMachine_MajorState& a, ChromeCompositorStateMachine_MajorState& b) {
    a.Swap(&b);
  }
  inline void Swap(ChromeCompositorStateMachine_MajorState* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ChromeCompositorStateMachine_MajorState* New() const final {
    return CreateMaybeMessage<ChromeCompositorStateMachine_MajorState>(nullptr);
  }

  ChromeCompositorStateMachine_MajorState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ChromeCompositorStateMachine_MajorState>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const ChromeCompositorStateMachine_MajorState& from);
  void MergeFrom(const ChromeCompositorStateMachine_MajorState& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ChromeCompositorStateMachine_MajorState* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.ChromeCompositorStateMachine.MajorState";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef ChromeCompositorStateMachine_MajorState_BeginImplFrameState BeginImplFrameState;
  static constexpr BeginImplFrameState BEGIN_IMPL_FRAME_UNSPECIFIED =
    ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_UNSPECIFIED;
  static constexpr BeginImplFrameState BEGIN_IMPL_FRAME_IDLE =
    ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_IDLE;
  static constexpr BeginImplFrameState BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME =
    ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME;
  static constexpr BeginImplFrameState BEGIN_IMPL_FRAME_INSIDE_DEADLINE =
    ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BEGIN_IMPL_FRAME_INSIDE_DEADLINE;
  static inline bool BeginImplFrameState_IsValid(int value) {
    return ChromeCompositorStateMachine_MajorState_BeginImplFrameState_IsValid(value);
  }
  static constexpr BeginImplFrameState BeginImplFrameState_MIN =
    ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BeginImplFrameState_MIN;
  static constexpr BeginImplFrameState BeginImplFrameState_MAX =
    ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BeginImplFrameState_MAX;
  static constexpr int BeginImplFrameState_ARRAYSIZE =
    ChromeCompositorStateMachine_MajorState_BeginImplFrameState_BeginImplFrameState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& BeginImplFrameState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BeginImplFrameState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BeginImplFrameState_Name.");
    return ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(enum_t_value);
  }
  static inline bool BeginImplFrameState_Parse(const std::string& name,
      BeginImplFrameState* value) {
    return ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Parse(name, value);
  }

  typedef ChromeCompositorStateMachine_MajorState_BeginMainFrameState BeginMainFrameState;
  static constexpr BeginMainFrameState BEGIN_MAIN_FRAME_UNSPECIFIED =
    ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_UNSPECIFIED;
  static constexpr BeginMainFrameState BEGIN_MAIN_FRAME_IDLE =
    ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_IDLE;
  static constexpr BeginMainFrameState BEGIN_MAIN_FRAME_SENT =
    ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_SENT;
  static constexpr BeginMainFrameState BEGIN_MAIN_FRAME_READY_TO_COMMIT =
    ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BEGIN_MAIN_FRAME_READY_TO_COMMIT;
  static inline bool BeginMainFrameState_IsValid(int value) {
    return ChromeCompositorStateMachine_MajorState_BeginMainFrameState_IsValid(value);
  }
  static constexpr BeginMainFrameState BeginMainFrameState_MIN =
    ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BeginMainFrameState_MIN;
  static constexpr BeginMainFrameState BeginMainFrameState_MAX =
    ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BeginMainFrameState_MAX;
  static constexpr int BeginMainFrameState_ARRAYSIZE =
    ChromeCompositorStateMachine_MajorState_BeginMainFrameState_BeginMainFrameState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& BeginMainFrameState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BeginMainFrameState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BeginMainFrameState_Name.");
    return ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(enum_t_value);
  }
  static inline bool BeginMainFrameState_Parse(const std::string& name,
      BeginMainFrameState* value) {
    return ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Parse(name, value);
  }

  typedef ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState LayerTreeFrameSinkState;
  static constexpr LayerTreeFrameSinkState LAYER_TREE_FRAME_UNSPECIFIED =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_UNSPECIFIED;
  static constexpr LayerTreeFrameSinkState LAYER_TREE_FRAME_NONE =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_NONE;
  static constexpr LayerTreeFrameSinkState LAYER_TREE_FRAME_ACTIVE =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_ACTIVE;
  static constexpr LayerTreeFrameSinkState LAYER_TREE_FRAME_CREATING =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_CREATING;
  static constexpr LayerTreeFrameSinkState LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT;
  static constexpr LayerTreeFrameSinkState LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION;
  static inline bool LayerTreeFrameSinkState_IsValid(int value) {
    return ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_IsValid(value);
  }
  static constexpr LayerTreeFrameSinkState LayerTreeFrameSinkState_MIN =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LayerTreeFrameSinkState_MIN;
  static constexpr LayerTreeFrameSinkState LayerTreeFrameSinkState_MAX =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LayerTreeFrameSinkState_MAX;
  static constexpr int LayerTreeFrameSinkState_ARRAYSIZE =
    ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_LayerTreeFrameSinkState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& LayerTreeFrameSinkState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LayerTreeFrameSinkState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LayerTreeFrameSinkState_Name.");
    return ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(enum_t_value);
  }
  static inline bool LayerTreeFrameSinkState_Parse(const std::string& name,
      LayerTreeFrameSinkState* value) {
    return ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Parse(name, value);
  }

  typedef ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ForcedRedrawOnTimeoutState;
  static constexpr ForcedRedrawOnTimeoutState FORCED_REDRAW_UNSPECIFIED =
    ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_UNSPECIFIED;
  static constexpr ForcedRedrawOnTimeoutState FORCED_REDRAW_IDLE =
    ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_IDLE;
  static constexpr ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_COMMIT =
    ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_COMMIT;
  static constexpr ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_ACTIVATION =
    ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_ACTIVATION;
  static constexpr ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_DRAW =
    ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_FORCED_REDRAW_WAITING_FOR_DRAW;
  static inline bool ForcedRedrawOnTimeoutState_IsValid(int value) {
    return ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_IsValid(value);
  }
  static constexpr ForcedRedrawOnTimeoutState ForcedRedrawOnTimeoutState_MIN =
    ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_ForcedRedrawOnTimeoutState_MIN;
  static constexpr ForcedRedrawOnTimeoutState ForcedRedrawOnTimeoutState_MAX =
    ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_ForcedRedrawOnTimeoutState_MAX;
  static constexpr int ForcedRedrawOnTimeoutState_ARRAYSIZE =
    ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_ForcedRedrawOnTimeoutState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ForcedRedrawOnTimeoutState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ForcedRedrawOnTimeoutState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ForcedRedrawOnTimeoutState_Name.");
    return ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(enum_t_value);
  }
  static inline bool ForcedRedrawOnTimeoutState_Parse(const std::string& name,
      ForcedRedrawOnTimeoutState* value) {
    return ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kNextActionFieldNumber = 1,
    kBeginImplFrameStateFieldNumber = 2,
    kBeginMainFrameStateFieldNumber = 3,
    kLayerTreeFrameSinkStateFieldNumber = 4,
    kForcedRedrawStateFieldNumber = 5,
  };
  // optional .perfetto.protos.ChromeCompositorSchedulerAction next_action = 1;
  bool has_next_action() const;
  void clear_next_action();
  ::perfetto::protos::ChromeCompositorSchedulerAction next_action() const;
  void set_next_action(::perfetto::protos::ChromeCompositorSchedulerAction value);

  // optional .perfetto.protos.ChromeCompositorStateMachine.MajorState.BeginImplFrameState begin_impl_frame_state = 2;
  bool has_begin_impl_frame_state() const;
  void clear_begin_impl_frame_state();
  ::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginImplFrameState begin_impl_frame_state() const;
  void set_begin_impl_frame_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginImplFrameState value);

  // optional .perfetto.protos.ChromeCompositorStateMachine.MajorState.BeginMainFrameState begin_main_frame_state = 3;
  bool has_begin_main_frame_state() const;
  void clear_begin_main_frame_state();
  ::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginMainFrameState begin_main_frame_state() const;
  void set_begin_main_frame_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginMainFrameState value);

  // optional .perfetto.protos.ChromeCompositorStateMachine.MajorState.LayerTreeFrameSinkState layer_tree_frame_sink_state = 4;
  bool has_layer_tree_frame_sink_state() const;
  void clear_layer_tree_frame_sink_state();
  ::perfetto::protos::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState layer_tree_frame_sink_state() const;
  void set_layer_tree_frame_sink_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value);

  // optional .perfetto.protos.ChromeCompositorStateMachine.MajorState.ForcedRedrawOnTimeoutState forced_redraw_state = 5;
  bool has_forced_redraw_state() const;
  void clear_forced_redraw_state();
  ::perfetto::protos::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState forced_redraw_state() const;
  void set_forced_redraw_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeCompositorStateMachine.MajorState)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int next_action_;
  int begin_impl_frame_state_;
  int begin_main_frame_state_;
  int layer_tree_frame_sink_state_;
  int forced_redraw_state_;
  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class ChromeCompositorStateMachine_MinorState :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeCompositorStateMachine.MinorState) */ {
 public:
  ChromeCompositorStateMachine_MinorState();
  virtual ~ChromeCompositorStateMachine_MinorState();

  ChromeCompositorStateMachine_MinorState(const ChromeCompositorStateMachine_MinorState& from);
  ChromeCompositorStateMachine_MinorState(ChromeCompositorStateMachine_MinorState&& from) noexcept
    : ChromeCompositorStateMachine_MinorState() {
    *this = ::std::move(from);
  }

  inline ChromeCompositorStateMachine_MinorState& operator=(const ChromeCompositorStateMachine_MinorState& from) {
    CopyFrom(from);
    return *this;
  }
  inline ChromeCompositorStateMachine_MinorState& operator=(ChromeCompositorStateMachine_MinorState&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ChromeCompositorStateMachine_MinorState& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ChromeCompositorStateMachine_MinorState* internal_default_instance() {
    return reinterpret_cast<const ChromeCompositorStateMachine_MinorState*>(
               &_ChromeCompositorStateMachine_MinorState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(ChromeCompositorStateMachine_MinorState& a, ChromeCompositorStateMachine_MinorState& b) {
    a.Swap(&b);
  }
  inline void Swap(ChromeCompositorStateMachine_MinorState* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ChromeCompositorStateMachine_MinorState* New() const final {
    return CreateMaybeMessage<ChromeCompositorStateMachine_MinorState>(nullptr);
  }

  ChromeCompositorStateMachine_MinorState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ChromeCompositorStateMachine_MinorState>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const ChromeCompositorStateMachine_MinorState& from);
  void MergeFrom(const ChromeCompositorStateMachine_MinorState& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ChromeCompositorStateMachine_MinorState* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.ChromeCompositorStateMachine.MinorState";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef ChromeCompositorStateMachine_MinorState_TreePriority TreePriority;
  static constexpr TreePriority TREE_PRIORITY_UNSPECIFIED =
    ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_UNSPECIFIED;
  static constexpr TreePriority TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES =
    ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES;
  static constexpr TreePriority TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY =
    ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY;
  static constexpr TreePriority TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY =
    ChromeCompositorStateMachine_MinorState_TreePriority_TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY;
  static inline bool TreePriority_IsValid(int value) {
    return ChromeCompositorStateMachine_MinorState_TreePriority_IsValid(value);
  }
  static constexpr TreePriority TreePriority_MIN =
    ChromeCompositorStateMachine_MinorState_TreePriority_TreePriority_MIN;
  static constexpr TreePriority TreePriority_MAX =
    ChromeCompositorStateMachine_MinorState_TreePriority_TreePriority_MAX;
  static constexpr int TreePriority_ARRAYSIZE =
    ChromeCompositorStateMachine_MinorState_TreePriority_TreePriority_ARRAYSIZE;
  template<typename T>
  static inline const std::string& TreePriority_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TreePriority>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TreePriority_Name.");
    return ChromeCompositorStateMachine_MinorState_TreePriority_Name(enum_t_value);
  }
  static inline bool TreePriority_Parse(const std::string& name,
      TreePriority* value) {
    return ChromeCompositorStateMachine_MinorState_TreePriority_Parse(name, value);
  }

  typedef ChromeCompositorStateMachine_MinorState_ScrollHandlerState ScrollHandlerState;
  static constexpr ScrollHandlerState SCROLL_HANDLER_UNSPECIFIED =
    ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_HANDLER_UNSPECIFIED;
  static constexpr ScrollHandlerState SCROLL_AFFECTS_SCROLL_HANDLER =
    ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_AFFECTS_SCROLL_HANDLER;
  static constexpr ScrollHandlerState SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER =
    ChromeCompositorStateMachine_MinorState_ScrollHandlerState_SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER;
  static inline bool ScrollHandlerState_IsValid(int value) {
    return ChromeCompositorStateMachine_MinorState_ScrollHandlerState_IsValid(value);
  }
  static constexpr ScrollHandlerState ScrollHandlerState_MIN =
    ChromeCompositorStateMachine_MinorState_ScrollHandlerState_ScrollHandlerState_MIN;
  static constexpr ScrollHandlerState ScrollHandlerState_MAX =
    ChromeCompositorStateMachine_MinorState_ScrollHandlerState_ScrollHandlerState_MAX;
  static constexpr int ScrollHandlerState_ARRAYSIZE =
    ChromeCompositorStateMachine_MinorState_ScrollHandlerState_ScrollHandlerState_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ScrollHandlerState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ScrollHandlerState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ScrollHandlerState_Name.");
    return ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(enum_t_value);
  }
  static inline bool ScrollHandlerState_Parse(const std::string& name,
      ScrollHandlerState* value) {
    return ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kCommitCountFieldNumber = 1,
    kCurrentFrameNumberFieldNumber = 2,
    kLastFrameNumberSubmitPerformedFieldNumber = 3,
    kLastFrameNumberDrawPerformedFieldNumber = 4,
    kLastFrameNumberBeginMainFrameSentFieldNumber = 5,
    kDidDrawFieldNumber = 6,
    kDidSendBeginMainFrameForCurrentFrameFieldNumber = 7,
    kDidNotifyBeginMainFrameNotExpectedUntilFieldNumber = 8,
    kDidNotifyBeginMainFrameNotExpectedSoonFieldNumber = 9,
    kWantsBeginMainFrameNotExpectedFieldNumber = 10,
    kDidCommitDuringFrameFieldNumber = 11,
    kDidInvalidateLayerTreeFrameSinkFieldNumber = 12,
    kDidPerformImplSideInvalidaionFieldNumber = 13,
    kConsecutiveCheckerboardAnimationsFieldNumber = 15,
    kPendingSubmitFramesFieldNumber = 16,
    kSubmitFramesWithCurrentLayerTreeFrameSinkFieldNumber = 17,
    kDidPrepareTilesFieldNumber = 14,
    kNeedsRedrawFieldNumber = 18,
    kNeedsPrepareTilesFieldNumber = 19,
    kNeedsBeginMainFrameFieldNumber = 20,
    kNeedsOneBeginImplFrameFieldNumber = 21,
    kVisibleFieldNumber = 22,
    kBeginFrameSourcePausedFieldNumber = 23,
    kCanDrawFieldNumber = 24,
    kResourcelessDrawFieldNumber = 25,
    kHasPendingTreeFieldNumber = 26,
    kPendingTreeIsReadyForActivationFieldNumber = 27,
    kActiveTreeNeedsFirstDrawFieldNumber = 28,
    kTreePriorityFieldNumber = 31,
    kActiveTreeIsReadyToDrawFieldNumber = 29,
    kDidCreateAndInitializeFirstLayerTreeFrameSinkFieldNumber = 30,
    kCriticalBeginMainFrameToActivateIsFastFieldNumber = 33,
    kMainThreadMissedLastDeadlineFieldNumber = 34,
    kScrollHandlerStateFieldNumber = 32,
    kVideoNeedsBeginFramesFieldNumber = 36,
    kDeferBeginMainFrameFieldNumber = 37,
    kLastCommitHadNoUpdatesFieldNumber = 38,
    kDidDrawInLastFrameFieldNumber = 39,
    kDidSubmitInLastFrameFieldNumber = 40,
    kNeedsImplSideInvalidationFieldNumber = 41,
    kCurrentPendingTreeIsImplSideFieldNumber = 42,
    kPreviousPendingTreeWasImplSideFieldNumber = 43,
    kProcessingAnimationWorkletsForActiveTreeFieldNumber = 44,
    kProcessingAnimationWorkletsForPendingTreeFieldNumber = 45,
    kProcessingPaintWorkletsForPendingTreeFieldNumber = 46,
  };
  // optional int32 commit_count = 1;
  bool has_commit_count() const;
  void clear_commit_count();
  ::PROTOBUF_NAMESPACE_ID::int32 commit_count() const;
  void set_commit_count(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 current_frame_number = 2;
  bool has_current_frame_number() const;
  void clear_current_frame_number();
  ::PROTOBUF_NAMESPACE_ID::int32 current_frame_number() const;
  void set_current_frame_number(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 last_frame_number_submit_performed = 3;
  bool has_last_frame_number_submit_performed() const;
  void clear_last_frame_number_submit_performed();
  ::PROTOBUF_NAMESPACE_ID::int32 last_frame_number_submit_performed() const;
  void set_last_frame_number_submit_performed(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 last_frame_number_draw_performed = 4;
  bool has_last_frame_number_draw_performed() const;
  void clear_last_frame_number_draw_performed();
  ::PROTOBUF_NAMESPACE_ID::int32 last_frame_number_draw_performed() const;
  void set_last_frame_number_draw_performed(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 last_frame_number_begin_main_frame_sent = 5;
  bool has_last_frame_number_begin_main_frame_sent() const;
  void clear_last_frame_number_begin_main_frame_sent();
  ::PROTOBUF_NAMESPACE_ID::int32 last_frame_number_begin_main_frame_sent() const;
  void set_last_frame_number_begin_main_frame_sent(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool did_draw = 6;
  bool has_did_draw() const;
  void clear_did_draw();
  bool did_draw() const;
  void set_did_draw(bool value);

  // optional bool did_send_begin_main_frame_for_current_frame = 7;
  bool has_did_send_begin_main_frame_for_current_frame() const;
  void clear_did_send_begin_main_frame_for_current_frame();
  bool did_send_begin_main_frame_for_current_frame() const;
  void set_did_send_begin_main_frame_for_current_frame(bool value);

  // optional bool did_notify_begin_main_frame_not_expected_until = 8;
  bool has_did_notify_begin_main_frame_not_expected_until() const;
  void clear_did_notify_begin_main_frame_not_expected_until();
  bool did_notify_begin_main_frame_not_expected_until() const;
  void set_did_notify_begin_main_frame_not_expected_until(bool value);

  // optional bool did_notify_begin_main_frame_not_expected_soon = 9;
  bool has_did_notify_begin_main_frame_not_expected_soon() const;
  void clear_did_notify_begin_main_frame_not_expected_soon();
  bool did_notify_begin_main_frame_not_expected_soon() const;
  void set_did_notify_begin_main_frame_not_expected_soon(bool value);

  // optional bool wants_begin_main_frame_not_expected = 10;
  bool has_wants_begin_main_frame_not_expected() const;
  void clear_wants_begin_main_frame_not_expected();
  bool wants_begin_main_frame_not_expected() const;
  void set_wants_begin_main_frame_not_expected(bool value);

  // optional bool did_commit_during_frame = 11;
  bool has_did_commit_during_frame() const;
  void clear_did_commit_during_frame();
  bool did_commit_during_frame() const;
  void set_did_commit_during_frame(bool value);

  // optional bool did_invalidate_layer_tree_frame_sink = 12;
  bool has_did_invalidate_layer_tree_frame_sink() const;
  void clear_did_invalidate_layer_tree_frame_sink();
  bool did_invalidate_layer_tree_frame_sink() const;
  void set_did_invalidate_layer_tree_frame_sink(bool value);

  // optional bool did_perform_impl_side_invalidaion = 13;
  bool has_did_perform_impl_side_invalidaion() const;
  void clear_did_perform_impl_side_invalidaion();
  bool did_perform_impl_side_invalidaion() const;
  void set_did_perform_impl_side_invalidaion(bool value);

  // optional int32 consecutive_checkerboard_animations = 15;
  bool has_consecutive_checkerboard_animations() const;
  void clear_consecutive_checkerboard_animations();
  ::PROTOBUF_NAMESPACE_ID::int32 consecutive_checkerboard_animations() const;
  void set_consecutive_checkerboard_animations(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 pending_submit_frames = 16;
  bool has_pending_submit_frames() const;
  void clear_pending_submit_frames();
  ::PROTOBUF_NAMESPACE_ID::int32 pending_submit_frames() const;
  void set_pending_submit_frames(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 submit_frames_with_current_layer_tree_frame_sink = 17;
  bool has_submit_frames_with_current_layer_tree_frame_sink() const;
  void clear_submit_frames_with_current_layer_tree_frame_sink();
  ::PROTOBUF_NAMESPACE_ID::int32 submit_frames_with_current_layer_tree_frame_sink() const;
  void set_submit_frames_with_current_layer_tree_frame_sink(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool did_prepare_tiles = 14;
  bool has_did_prepare_tiles() const;
  void clear_did_prepare_tiles();
  bool did_prepare_tiles() const;
  void set_did_prepare_tiles(bool value);

  // optional bool needs_redraw = 18;
  bool has_needs_redraw() const;
  void clear_needs_redraw();
  bool needs_redraw() const;
  void set_needs_redraw(bool value);

  // optional bool needs_prepare_tiles = 19;
  bool has_needs_prepare_tiles() const;
  void clear_needs_prepare_tiles();
  bool needs_prepare_tiles() const;
  void set_needs_prepare_tiles(bool value);

  // optional bool needs_begin_main_frame = 20;
  bool has_needs_begin_main_frame() const;
  void clear_needs_begin_main_frame();
  bool needs_begin_main_frame() const;
  void set_needs_begin_main_frame(bool value);

  // optional bool needs_one_begin_impl_frame = 21;
  bool has_needs_one_begin_impl_frame() const;
  void clear_needs_one_begin_impl_frame();
  bool needs_one_begin_impl_frame() const;
  void set_needs_one_begin_impl_frame(bool value);

  // optional bool visible = 22;
  bool has_visible() const;
  void clear_visible();
  bool visible() const;
  void set_visible(bool value);

  // optional bool begin_frame_source_paused = 23;
  bool has_begin_frame_source_paused() const;
  void clear_begin_frame_source_paused();
  bool begin_frame_source_paused() const;
  void set_begin_frame_source_paused(bool value);

  // optional bool can_draw = 24;
  bool has_can_draw() const;
  void clear_can_draw();
  bool can_draw() const;
  void set_can_draw(bool value);

  // optional bool resourceless_draw = 25;
  bool has_resourceless_draw() const;
  void clear_resourceless_draw();
  bool resourceless_draw() const;
  void set_resourceless_draw(bool value);

  // optional bool has_pending_tree = 26;
  bool has_has_pending_tree() const;
  void clear_has_pending_tree();
  bool has_pending_tree() const;
  void set_has_pending_tree(bool value);

  // optional bool pending_tree_is_ready_for_activation = 27;
  bool has_pending_tree_is_ready_for_activation() const;
  void clear_pending_tree_is_ready_for_activation();
  bool pending_tree_is_ready_for_activation() const;
  void set_pending_tree_is_ready_for_activation(bool value);

  // optional bool active_tree_needs_first_draw = 28;
  bool has_active_tree_needs_first_draw() const;
  void clear_active_tree_needs_first_draw();
  bool active_tree_needs_first_draw() const;
  void set_active_tree_needs_first_draw(bool value);

  // optional .perfetto.protos.ChromeCompositorStateMachine.MinorState.TreePriority tree_priority = 31;
  bool has_tree_priority() const;
  void clear_tree_priority();
  ::perfetto::protos::ChromeCompositorStateMachine_MinorState_TreePriority tree_priority() const;
  void set_tree_priority(::perfetto::protos::ChromeCompositorStateMachine_MinorState_TreePriority value);

  // optional bool active_tree_is_ready_to_draw = 29;
  bool has_active_tree_is_ready_to_draw() const;
  void clear_active_tree_is_ready_to_draw();
  bool active_tree_is_ready_to_draw() const;
  void set_active_tree_is_ready_to_draw(bool value);

  // optional bool did_create_and_initialize_first_layer_tree_frame_sink = 30;
  bool has_did_create_and_initialize_first_layer_tree_frame_sink() const;
  void clear_did_create_and_initialize_first_layer_tree_frame_sink();
  bool did_create_and_initialize_first_layer_tree_frame_sink() const;
  void set_did_create_and_initialize_first_layer_tree_frame_sink(bool value);

  // optional bool critical_begin_main_frame_to_activate_is_fast = 33;
  bool has_critical_begin_main_frame_to_activate_is_fast() const;
  void clear_critical_begin_main_frame_to_activate_is_fast();
  bool critical_begin_main_frame_to_activate_is_fast() const;
  void set_critical_begin_main_frame_to_activate_is_fast(bool value);

  // optional bool main_thread_missed_last_deadline = 34;
  bool has_main_thread_missed_last_deadline() const;
  void clear_main_thread_missed_last_deadline();
  bool main_thread_missed_last_deadline() const;
  void set_main_thread_missed_last_deadline(bool value);

  // optional .perfetto.protos.ChromeCompositorStateMachine.MinorState.ScrollHandlerState scroll_handler_state = 32;
  bool has_scroll_handler_state() const;
  void clear_scroll_handler_state();
  ::perfetto::protos::ChromeCompositorStateMachine_MinorState_ScrollHandlerState scroll_handler_state() const;
  void set_scroll_handler_state(::perfetto::protos::ChromeCompositorStateMachine_MinorState_ScrollHandlerState value);

  // optional bool video_needs_begin_frames = 36;
  bool has_video_needs_begin_frames() const;
  void clear_video_needs_begin_frames();
  bool video_needs_begin_frames() const;
  void set_video_needs_begin_frames(bool value);

  // optional bool defer_begin_main_frame = 37;
  bool has_defer_begin_main_frame() const;
  void clear_defer_begin_main_frame();
  bool defer_begin_main_frame() const;
  void set_defer_begin_main_frame(bool value);

  // optional bool last_commit_had_no_updates = 38;
  bool has_last_commit_had_no_updates() const;
  void clear_last_commit_had_no_updates();
  bool last_commit_had_no_updates() const;
  void set_last_commit_had_no_updates(bool value);

  // optional bool did_draw_in_last_frame = 39;
  bool has_did_draw_in_last_frame() const;
  void clear_did_draw_in_last_frame();
  bool did_draw_in_last_frame() const;
  void set_did_draw_in_last_frame(bool value);

  // optional bool did_submit_in_last_frame = 40;
  bool has_did_submit_in_last_frame() const;
  void clear_did_submit_in_last_frame();
  bool did_submit_in_last_frame() const;
  void set_did_submit_in_last_frame(bool value);

  // optional bool needs_impl_side_invalidation = 41;
  bool has_needs_impl_side_invalidation() const;
  void clear_needs_impl_side_invalidation();
  bool needs_impl_side_invalidation() const;
  void set_needs_impl_side_invalidation(bool value);

  // optional bool current_pending_tree_is_impl_side = 42;
  bool has_current_pending_tree_is_impl_side() const;
  void clear_current_pending_tree_is_impl_side();
  bool current_pending_tree_is_impl_side() const;
  void set_current_pending_tree_is_impl_side(bool value);

  // optional bool previous_pending_tree_was_impl_side = 43;
  bool has_previous_pending_tree_was_impl_side() const;
  void clear_previous_pending_tree_was_impl_side();
  bool previous_pending_tree_was_impl_side() const;
  void set_previous_pending_tree_was_impl_side(bool value);

  // optional bool processing_animation_worklets_for_active_tree = 44;
  bool has_processing_animation_worklets_for_active_tree() const;
  void clear_processing_animation_worklets_for_active_tree();
  bool processing_animation_worklets_for_active_tree() const;
  void set_processing_animation_worklets_for_active_tree(bool value);

  // optional bool processing_animation_worklets_for_pending_tree = 45;
  bool has_processing_animation_worklets_for_pending_tree() const;
  void clear_processing_animation_worklets_for_pending_tree();
  bool processing_animation_worklets_for_pending_tree() const;
  void set_processing_animation_worklets_for_pending_tree(bool value);

  // optional bool processing_paint_worklets_for_pending_tree = 46;
  bool has_processing_paint_worklets_for_pending_tree() const;
  void clear_processing_paint_worklets_for_pending_tree();
  bool processing_paint_worklets_for_pending_tree() const;
  void set_processing_paint_worklets_for_pending_tree(bool value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeCompositorStateMachine.MinorState)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 commit_count_;
  ::PROTOBUF_NAMESPACE_ID::int32 current_frame_number_;
  ::PROTOBUF_NAMESPACE_ID::int32 last_frame_number_submit_performed_;
  ::PROTOBUF_NAMESPACE_ID::int32 last_frame_number_draw_performed_;
  ::PROTOBUF_NAMESPACE_ID::int32 last_frame_number_begin_main_frame_sent_;
  bool did_draw_;
  bool did_send_begin_main_frame_for_current_frame_;
  bool did_notify_begin_main_frame_not_expected_until_;
  bool did_notify_begin_main_frame_not_expected_soon_;
  bool wants_begin_main_frame_not_expected_;
  bool did_commit_during_frame_;
  bool did_invalidate_layer_tree_frame_sink_;
  bool did_perform_impl_side_invalidaion_;
  ::PROTOBUF_NAMESPACE_ID::int32 consecutive_checkerboard_animations_;
  ::PROTOBUF_NAMESPACE_ID::int32 pending_submit_frames_;
  ::PROTOBUF_NAMESPACE_ID::int32 submit_frames_with_current_layer_tree_frame_sink_;
  bool did_prepare_tiles_;
  bool needs_redraw_;
  bool needs_prepare_tiles_;
  bool needs_begin_main_frame_;
  bool needs_one_begin_impl_frame_;
  bool visible_;
  bool begin_frame_source_paused_;
  bool can_draw_;
  bool resourceless_draw_;
  bool has_pending_tree_;
  bool pending_tree_is_ready_for_activation_;
  bool active_tree_needs_first_draw_;
  int tree_priority_;
  bool active_tree_is_ready_to_draw_;
  bool did_create_and_initialize_first_layer_tree_frame_sink_;
  bool critical_begin_main_frame_to_activate_is_fast_;
  bool main_thread_missed_last_deadline_;
  int scroll_handler_state_;
  bool video_needs_begin_frames_;
  bool defer_begin_main_frame_;
  bool last_commit_had_no_updates_;
  bool did_draw_in_last_frame_;
  bool did_submit_in_last_frame_;
  bool needs_impl_side_invalidation_;
  bool current_pending_tree_is_impl_side_;
  bool previous_pending_tree_was_impl_side_;
  bool processing_animation_worklets_for_active_tree_;
  bool processing_animation_worklets_for_pending_tree_;
  bool processing_paint_worklets_for_pending_tree_;
  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class ChromeCompositorStateMachine :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeCompositorStateMachine) */ {
 public:
  ChromeCompositorStateMachine();
  virtual ~ChromeCompositorStateMachine();

  ChromeCompositorStateMachine(const ChromeCompositorStateMachine& from);
  ChromeCompositorStateMachine(ChromeCompositorStateMachine&& from) noexcept
    : ChromeCompositorStateMachine() {
    *this = ::std::move(from);
  }

  inline ChromeCompositorStateMachine& operator=(const ChromeCompositorStateMachine& from) {
    CopyFrom(from);
    return *this;
  }
  inline ChromeCompositorStateMachine& operator=(ChromeCompositorStateMachine&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ChromeCompositorStateMachine& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ChromeCompositorStateMachine* internal_default_instance() {
    return reinterpret_cast<const ChromeCompositorStateMachine*>(
               &_ChromeCompositorStateMachine_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ChromeCompositorStateMachine& a, ChromeCompositorStateMachine& b) {
    a.Swap(&b);
  }
  inline void Swap(ChromeCompositorStateMachine* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ChromeCompositorStateMachine* New() const final {
    return CreateMaybeMessage<ChromeCompositorStateMachine>(nullptr);
  }

  ChromeCompositorStateMachine* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ChromeCompositorStateMachine>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const ChromeCompositorStateMachine& from);
  void MergeFrom(const ChromeCompositorStateMachine& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ChromeCompositorStateMachine* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.ChromeCompositorStateMachine";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef ChromeCompositorStateMachine_MajorState MajorState;
  typedef ChromeCompositorStateMachine_MinorState MinorState;

  // accessors -------------------------------------------------------

  enum : int {
    kMajorStateFieldNumber = 1,
    kMinorStateFieldNumber = 2,
  };
  // optional .perfetto.protos.ChromeCompositorStateMachine.MajorState major_state = 1;
  bool has_major_state() const;
  void clear_major_state();
  const ::perfetto::protos::ChromeCompositorStateMachine_MajorState& major_state() const;
  ::perfetto::protos::ChromeCompositorStateMachine_MajorState* release_major_state();
  ::perfetto::protos::ChromeCompositorStateMachine_MajorState* mutable_major_state();
  void set_allocated_major_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState* major_state);

  // optional .perfetto.protos.ChromeCompositorStateMachine.MinorState minor_state = 2;
  bool has_minor_state() const;
  void clear_minor_state();
  const ::perfetto::protos::ChromeCompositorStateMachine_MinorState& minor_state() const;
  ::perfetto::protos::ChromeCompositorStateMachine_MinorState* release_minor_state();
  ::perfetto::protos::ChromeCompositorStateMachine_MinorState* mutable_minor_state();
  void set_allocated_minor_state(::perfetto::protos::ChromeCompositorStateMachine_MinorState* minor_state);

  // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeCompositorStateMachine)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::perfetto::protos::ChromeCompositorStateMachine_MajorState* major_state_;
  ::perfetto::protos::ChromeCompositorStateMachine_MinorState* minor_state_;
  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class BeginFrameArgs :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BeginFrameArgs) */ {
 public:
  BeginFrameArgs();
  virtual ~BeginFrameArgs();

  BeginFrameArgs(const BeginFrameArgs& from);
  BeginFrameArgs(BeginFrameArgs&& from) noexcept
    : BeginFrameArgs() {
    *this = ::std::move(from);
  }

  inline BeginFrameArgs& operator=(const BeginFrameArgs& from) {
    CopyFrom(from);
    return *this;
  }
  inline BeginFrameArgs& operator=(BeginFrameArgs&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const BeginFrameArgs& default_instance();

  enum CreatedFromCase {
    kSourceLocationIid = 9,
    kSourceLocation = 10,
    CREATED_FROM_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BeginFrameArgs* internal_default_instance() {
    return reinterpret_cast<const BeginFrameArgs*>(
               &_BeginFrameArgs_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(BeginFrameArgs& a, BeginFrameArgs& b) {
    a.Swap(&b);
  }
  inline void Swap(BeginFrameArgs* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BeginFrameArgs* New() const final {
    return CreateMaybeMessage<BeginFrameArgs>(nullptr);
  }

  BeginFrameArgs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BeginFrameArgs>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const BeginFrameArgs& from);
  void MergeFrom(const BeginFrameArgs& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BeginFrameArgs* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.BeginFrameArgs";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef BeginFrameArgs_BeginFrameArgsType BeginFrameArgsType;
  static constexpr BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED =
    BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED;
  static constexpr BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_INVALID =
    BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_INVALID;
  static constexpr BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_NORMAL =
    BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_NORMAL;
  static constexpr BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_MISSED =
    BeginFrameArgs_BeginFrameArgsType_BEGIN_FRAME_ARGS_TYPE_MISSED;
  static inline bool BeginFrameArgsType_IsValid(int value) {
    return BeginFrameArgs_BeginFrameArgsType_IsValid(value);
  }
  static constexpr BeginFrameArgsType BeginFrameArgsType_MIN =
    BeginFrameArgs_BeginFrameArgsType_BeginFrameArgsType_MIN;
  static constexpr BeginFrameArgsType BeginFrameArgsType_MAX =
    BeginFrameArgs_BeginFrameArgsType_BeginFrameArgsType_MAX;
  static constexpr int BeginFrameArgsType_ARRAYSIZE =
    BeginFrameArgs_BeginFrameArgsType_BeginFrameArgsType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& BeginFrameArgsType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BeginFrameArgsType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BeginFrameArgsType_Name.");
    return BeginFrameArgs_BeginFrameArgsType_Name(enum_t_value);
  }
  static inline bool BeginFrameArgsType_Parse(const std::string& name,
      BeginFrameArgsType* value) {
    return BeginFrameArgs_BeginFrameArgsType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kSourceIdFieldNumber = 2,
    kSequenceNumberFieldNumber = 3,
    kFrameTimeUsFieldNumber = 4,
    kDeadlineUsFieldNumber = 5,
    kTypeFieldNumber = 1,
    kOnCriticalPathFieldNumber = 7,
    kAnimateOnlyFieldNumber = 8,
    kIntervalDeltaUsFieldNumber = 6,
    kFramesThrottledSinceLastFieldNumber = 12,
    kSourceLocationIidFieldNumber = 9,
    kSourceLocationFieldNumber = 10,
  };
  // optional uint64 source_id = 2;
  bool has_source_id() const;
  void clear_source_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 source_id() const;
  void set_source_id(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint64 sequence_number = 3;
  bool has_sequence_number() const;
  void clear_sequence_number();
  ::PROTOBUF_NAMESPACE_ID::uint64 sequence_number() const;
  void set_sequence_number(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional int64 frame_time_us = 4;
  bool has_frame_time_us() const;
  void clear_frame_time_us();
  ::PROTOBUF_NAMESPACE_ID::int64 frame_time_us() const;
  void set_frame_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 deadline_us = 5;
  bool has_deadline_us() const;
  void clear_deadline_us();
  ::PROTOBUF_NAMESPACE_ID::int64 deadline_us() const;
  void set_deadline_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional .perfetto.protos.BeginFrameArgs.BeginFrameArgsType type = 1;
  bool has_type() const;
  void clear_type();
  ::perfetto::protos::BeginFrameArgs_BeginFrameArgsType type() const;
  void set_type(::perfetto::protos::BeginFrameArgs_BeginFrameArgsType value);

  // optional bool on_critical_path = 7;
  bool has_on_critical_path() const;
  void clear_on_critical_path();
  bool on_critical_path() const;
  void set_on_critical_path(bool value);

  // optional bool animate_only = 8;
  bool has_animate_only() const;
  void clear_animate_only();
  bool animate_only() const;
  void set_animate_only(bool value);

  // optional int64 interval_delta_us = 6;
  bool has_interval_delta_us() const;
  void clear_interval_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 interval_delta_us() const;
  void set_interval_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 frames_throttled_since_last = 12;
  bool has_frames_throttled_since_last() const;
  void clear_frames_throttled_since_last();
  ::PROTOBUF_NAMESPACE_ID::int64 frames_throttled_since_last() const;
  void set_frames_throttled_since_last(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional uint64 source_location_iid = 9;
  bool has_source_location_iid() const;
  void clear_source_location_iid();
  ::PROTOBUF_NAMESPACE_ID::uint64 source_location_iid() const;
  void set_source_location_iid(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional .perfetto.protos.SourceLocation source_location = 10;
  bool has_source_location() const;
  void clear_source_location();
  const ::perfetto::protos::SourceLocation& source_location() const;
  ::perfetto::protos::SourceLocation* release_source_location();
  ::perfetto::protos::SourceLocation* mutable_source_location();
  void set_allocated_source_location(::perfetto::protos::SourceLocation* source_location);

  void clear_created_from();
  CreatedFromCase created_from_case() const;
  // @@protoc_insertion_point(class_scope:perfetto.protos.BeginFrameArgs)
 private:
  class _Internal;
  void set_has_source_location_iid();
  void set_has_source_location();

  inline bool has_created_from() const;
  inline void clear_has_created_from();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 source_id_;
  ::PROTOBUF_NAMESPACE_ID::uint64 sequence_number_;
  ::PROTOBUF_NAMESPACE_ID::int64 frame_time_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 deadline_us_;
  int type_;
  bool on_critical_path_;
  bool animate_only_;
  ::PROTOBUF_NAMESPACE_ID::int64 interval_delta_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 frames_throttled_since_last_;
  union CreatedFromUnion {
    CreatedFromUnion() {}
    ::PROTOBUF_NAMESPACE_ID::uint64 source_location_iid_;
    ::perfetto::protos::SourceLocation* source_location_;
  } created_from_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class BeginImplFrameArgs_TimestampsInUs :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BeginImplFrameArgs.TimestampsInUs) */ {
 public:
  BeginImplFrameArgs_TimestampsInUs();
  virtual ~BeginImplFrameArgs_TimestampsInUs();

  BeginImplFrameArgs_TimestampsInUs(const BeginImplFrameArgs_TimestampsInUs& from);
  BeginImplFrameArgs_TimestampsInUs(BeginImplFrameArgs_TimestampsInUs&& from) noexcept
    : BeginImplFrameArgs_TimestampsInUs() {
    *this = ::std::move(from);
  }

  inline BeginImplFrameArgs_TimestampsInUs& operator=(const BeginImplFrameArgs_TimestampsInUs& from) {
    CopyFrom(from);
    return *this;
  }
  inline BeginImplFrameArgs_TimestampsInUs& operator=(BeginImplFrameArgs_TimestampsInUs&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const BeginImplFrameArgs_TimestampsInUs& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BeginImplFrameArgs_TimestampsInUs* internal_default_instance() {
    return reinterpret_cast<const BeginImplFrameArgs_TimestampsInUs*>(
               &_BeginImplFrameArgs_TimestampsInUs_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(BeginImplFrameArgs_TimestampsInUs& a, BeginImplFrameArgs_TimestampsInUs& b) {
    a.Swap(&b);
  }
  inline void Swap(BeginImplFrameArgs_TimestampsInUs* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BeginImplFrameArgs_TimestampsInUs* New() const final {
    return CreateMaybeMessage<BeginImplFrameArgs_TimestampsInUs>(nullptr);
  }

  BeginImplFrameArgs_TimestampsInUs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BeginImplFrameArgs_TimestampsInUs>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const BeginImplFrameArgs_TimestampsInUs& from);
  void MergeFrom(const BeginImplFrameArgs_TimestampsInUs& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BeginImplFrameArgs_TimestampsInUs* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.BeginImplFrameArgs.TimestampsInUs";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIntervalDeltaFieldNumber = 1,
    kNowToDeadlineDeltaFieldNumber = 2,
    kFrameTimeToNowDeltaFieldNumber = 3,
    kFrameTimeToDeadlineDeltaFieldNumber = 4,
    kNowFieldNumber = 5,
    kFrameTimeFieldNumber = 6,
    kDeadlineFieldNumber = 7,
  };
  // optional int64 interval_delta = 1;
  bool has_interval_delta() const;
  void clear_interval_delta();
  ::PROTOBUF_NAMESPACE_ID::int64 interval_delta() const;
  void set_interval_delta(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 now_to_deadline_delta = 2;
  bool has_now_to_deadline_delta() const;
  void clear_now_to_deadline_delta();
  ::PROTOBUF_NAMESPACE_ID::int64 now_to_deadline_delta() const;
  void set_now_to_deadline_delta(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 frame_time_to_now_delta = 3;
  bool has_frame_time_to_now_delta() const;
  void clear_frame_time_to_now_delta();
  ::PROTOBUF_NAMESPACE_ID::int64 frame_time_to_now_delta() const;
  void set_frame_time_to_now_delta(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 frame_time_to_deadline_delta = 4;
  bool has_frame_time_to_deadline_delta() const;
  void clear_frame_time_to_deadline_delta();
  ::PROTOBUF_NAMESPACE_ID::int64 frame_time_to_deadline_delta() const;
  void set_frame_time_to_deadline_delta(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 now = 5;
  bool has_now() const;
  void clear_now();
  ::PROTOBUF_NAMESPACE_ID::int64 now() const;
  void set_now(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 frame_time = 6;
  bool has_frame_time() const;
  void clear_frame_time();
  ::PROTOBUF_NAMESPACE_ID::int64 frame_time() const;
  void set_frame_time(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 deadline = 7;
  bool has_deadline() const;
  void clear_deadline();
  ::PROTOBUF_NAMESPACE_ID::int64 deadline() const;
  void set_deadline(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.BeginImplFrameArgs.TimestampsInUs)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::int64 interval_delta_;
  ::PROTOBUF_NAMESPACE_ID::int64 now_to_deadline_delta_;
  ::PROTOBUF_NAMESPACE_ID::int64 frame_time_to_now_delta_;
  ::PROTOBUF_NAMESPACE_ID::int64 frame_time_to_deadline_delta_;
  ::PROTOBUF_NAMESPACE_ID::int64 now_;
  ::PROTOBUF_NAMESPACE_ID::int64 frame_time_;
  ::PROTOBUF_NAMESPACE_ID::int64 deadline_;
  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class BeginImplFrameArgs :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BeginImplFrameArgs) */ {
 public:
  BeginImplFrameArgs();
  virtual ~BeginImplFrameArgs();

  BeginImplFrameArgs(const BeginImplFrameArgs& from);
  BeginImplFrameArgs(BeginImplFrameArgs&& from) noexcept
    : BeginImplFrameArgs() {
    *this = ::std::move(from);
  }

  inline BeginImplFrameArgs& operator=(const BeginImplFrameArgs& from) {
    CopyFrom(from);
    return *this;
  }
  inline BeginImplFrameArgs& operator=(BeginImplFrameArgs&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const BeginImplFrameArgs& default_instance();

  enum ArgsCase {
    kCurrentArgs = 4,
    kLastArgs = 5,
    ARGS_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BeginImplFrameArgs* internal_default_instance() {
    return reinterpret_cast<const BeginImplFrameArgs*>(
               &_BeginImplFrameArgs_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(BeginImplFrameArgs& a, BeginImplFrameArgs& b) {
    a.Swap(&b);
  }
  inline void Swap(BeginImplFrameArgs* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BeginImplFrameArgs* New() const final {
    return CreateMaybeMessage<BeginImplFrameArgs>(nullptr);
  }

  BeginImplFrameArgs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BeginImplFrameArgs>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const BeginImplFrameArgs& from);
  void MergeFrom(const BeginImplFrameArgs& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BeginImplFrameArgs* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.BeginImplFrameArgs";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef BeginImplFrameArgs_TimestampsInUs TimestampsInUs;

  typedef BeginImplFrameArgs_State State;
  static constexpr State BEGIN_FRAME_FINISHED =
    BeginImplFrameArgs_State_BEGIN_FRAME_FINISHED;
  static constexpr State BEGIN_FRAME_USING =
    BeginImplFrameArgs_State_BEGIN_FRAME_USING;
  static inline bool State_IsValid(int value) {
    return BeginImplFrameArgs_State_IsValid(value);
  }
  static constexpr State State_MIN =
    BeginImplFrameArgs_State_State_MIN;
  static constexpr State State_MAX =
    BeginImplFrameArgs_State_State_MAX;
  static constexpr int State_ARRAYSIZE =
    BeginImplFrameArgs_State_State_ARRAYSIZE;
  template<typename T>
  static inline const std::string& State_Name(T enum_t_value) {
    static_assert(::std::is_same<T, State>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function State_Name.");
    return BeginImplFrameArgs_State_Name(enum_t_value);
  }
  static inline bool State_Parse(const std::string& name,
      State* value) {
    return BeginImplFrameArgs_State_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTimestampsInUsFieldNumber = 6,
    kUpdatedAtUsFieldNumber = 1,
    kFinishedAtUsFieldNumber = 2,
    kStateFieldNumber = 3,
    kCurrentArgsFieldNumber = 4,
    kLastArgsFieldNumber = 5,
  };
  // optional .perfetto.protos.BeginImplFrameArgs.TimestampsInUs timestamps_in_us = 6;
  bool has_timestamps_in_us() const;
  void clear_timestamps_in_us();
  const ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs& timestamps_in_us() const;
  ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* release_timestamps_in_us();
  ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* mutable_timestamps_in_us();
  void set_allocated_timestamps_in_us(::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* timestamps_in_us);

  // optional int64 updated_at_us = 1;
  bool has_updated_at_us() const;
  void clear_updated_at_us();
  ::PROTOBUF_NAMESPACE_ID::int64 updated_at_us() const;
  void set_updated_at_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 finished_at_us = 2;
  bool has_finished_at_us() const;
  void clear_finished_at_us();
  ::PROTOBUF_NAMESPACE_ID::int64 finished_at_us() const;
  void set_finished_at_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional .perfetto.protos.BeginImplFrameArgs.State state = 3;
  bool has_state() const;
  void clear_state();
  ::perfetto::protos::BeginImplFrameArgs_State state() const;
  void set_state(::perfetto::protos::BeginImplFrameArgs_State value);

  // optional .perfetto.protos.BeginFrameArgs current_args = 4;
  bool has_current_args() const;
  void clear_current_args();
  const ::perfetto::protos::BeginFrameArgs& current_args() const;
  ::perfetto::protos::BeginFrameArgs* release_current_args();
  ::perfetto::protos::BeginFrameArgs* mutable_current_args();
  void set_allocated_current_args(::perfetto::protos::BeginFrameArgs* current_args);

  // optional .perfetto.protos.BeginFrameArgs last_args = 5;
  bool has_last_args() const;
  void clear_last_args();
  const ::perfetto::protos::BeginFrameArgs& last_args() const;
  ::perfetto::protos::BeginFrameArgs* release_last_args();
  ::perfetto::protos::BeginFrameArgs* mutable_last_args();
  void set_allocated_last_args(::perfetto::protos::BeginFrameArgs* last_args);

  void clear_args();
  ArgsCase args_case() const;
  // @@protoc_insertion_point(class_scope:perfetto.protos.BeginImplFrameArgs)
 private:
  class _Internal;
  void set_has_current_args();
  void set_has_last_args();

  inline bool has_args() const;
  inline void clear_has_args();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* timestamps_in_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 updated_at_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 finished_at_us_;
  int state_;
  union ArgsUnion {
    ArgsUnion() {}
    ::perfetto::protos::BeginFrameArgs* current_args_;
    ::perfetto::protos::BeginFrameArgs* last_args_;
  } args_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class BeginFrameObserverState :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BeginFrameObserverState) */ {
 public:
  BeginFrameObserverState();
  virtual ~BeginFrameObserverState();

  BeginFrameObserverState(const BeginFrameObserverState& from);
  BeginFrameObserverState(BeginFrameObserverState&& from) noexcept
    : BeginFrameObserverState() {
    *this = ::std::move(from);
  }

  inline BeginFrameObserverState& operator=(const BeginFrameObserverState& from) {
    CopyFrom(from);
    return *this;
  }
  inline BeginFrameObserverState& operator=(BeginFrameObserverState&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const BeginFrameObserverState& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BeginFrameObserverState* internal_default_instance() {
    return reinterpret_cast<const BeginFrameObserverState*>(
               &_BeginFrameObserverState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(BeginFrameObserverState& a, BeginFrameObserverState& b) {
    a.Swap(&b);
  }
  inline void Swap(BeginFrameObserverState* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BeginFrameObserverState* New() const final {
    return CreateMaybeMessage<BeginFrameObserverState>(nullptr);
  }

  BeginFrameObserverState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BeginFrameObserverState>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const BeginFrameObserverState& from);
  void MergeFrom(const BeginFrameObserverState& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BeginFrameObserverState* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.BeginFrameObserverState";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLastBeginFrameArgsFieldNumber = 2,
    kDroppedBeginFrameArgsFieldNumber = 1,
  };
  // optional .perfetto.protos.BeginFrameArgs last_begin_frame_args = 2;
  bool has_last_begin_frame_args() const;
  void clear_last_begin_frame_args();
  const ::perfetto::protos::BeginFrameArgs& last_begin_frame_args() const;
  ::perfetto::protos::BeginFrameArgs* release_last_begin_frame_args();
  ::perfetto::protos::BeginFrameArgs* mutable_last_begin_frame_args();
  void set_allocated_last_begin_frame_args(::perfetto::protos::BeginFrameArgs* last_begin_frame_args);

  // optional int64 dropped_begin_frame_args = 1;
  bool has_dropped_begin_frame_args() const;
  void clear_dropped_begin_frame_args();
  ::PROTOBUF_NAMESPACE_ID::int64 dropped_begin_frame_args() const;
  void set_dropped_begin_frame_args(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.BeginFrameObserverState)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::perfetto::protos::BeginFrameArgs* last_begin_frame_args_;
  ::PROTOBUF_NAMESPACE_ID::int64 dropped_begin_frame_args_;
  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class BeginFrameSourceState :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BeginFrameSourceState) */ {
 public:
  BeginFrameSourceState();
  virtual ~BeginFrameSourceState();

  BeginFrameSourceState(const BeginFrameSourceState& from);
  BeginFrameSourceState(BeginFrameSourceState&& from) noexcept
    : BeginFrameSourceState() {
    *this = ::std::move(from);
  }

  inline BeginFrameSourceState& operator=(const BeginFrameSourceState& from) {
    CopyFrom(from);
    return *this;
  }
  inline BeginFrameSourceState& operator=(BeginFrameSourceState&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const BeginFrameSourceState& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BeginFrameSourceState* internal_default_instance() {
    return reinterpret_cast<const BeginFrameSourceState*>(
               &_BeginFrameSourceState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(BeginFrameSourceState& a, BeginFrameSourceState& b) {
    a.Swap(&b);
  }
  inline void Swap(BeginFrameSourceState* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BeginFrameSourceState* New() const final {
    return CreateMaybeMessage<BeginFrameSourceState>(nullptr);
  }

  BeginFrameSourceState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BeginFrameSourceState>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const BeginFrameSourceState& from);
  void MergeFrom(const BeginFrameSourceState& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BeginFrameSourceState* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.BeginFrameSourceState";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLastBeginFrameArgsFieldNumber = 4,
    kSourceIdFieldNumber = 1,
    kPausedFieldNumber = 2,
    kNumObserversFieldNumber = 3,
  };
  // optional .perfetto.protos.BeginFrameArgs last_begin_frame_args = 4;
  bool has_last_begin_frame_args() const;
  void clear_last_begin_frame_args();
  const ::perfetto::protos::BeginFrameArgs& last_begin_frame_args() const;
  ::perfetto::protos::BeginFrameArgs* release_last_begin_frame_args();
  ::perfetto::protos::BeginFrameArgs* mutable_last_begin_frame_args();
  void set_allocated_last_begin_frame_args(::perfetto::protos::BeginFrameArgs* last_begin_frame_args);

  // optional uint32 source_id = 1;
  bool has_source_id() const;
  void clear_source_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 source_id() const;
  void set_source_id(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional bool paused = 2;
  bool has_paused() const;
  void clear_paused();
  bool paused() const;
  void set_paused(bool value);

  // optional uint32 num_observers = 3;
  bool has_num_observers() const;
  void clear_num_observers();
  ::PROTOBUF_NAMESPACE_ID::uint32 num_observers() const;
  void set_num_observers(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.BeginFrameSourceState)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::perfetto::protos::BeginFrameArgs* last_begin_frame_args_;
  ::PROTOBUF_NAMESPACE_ID::uint32 source_id_;
  bool paused_;
  ::PROTOBUF_NAMESPACE_ID::uint32 num_observers_;
  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// -------------------------------------------------------------------

class CompositorTimingHistory :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.CompositorTimingHistory) */ {
 public:
  CompositorTimingHistory();
  virtual ~CompositorTimingHistory();

  CompositorTimingHistory(const CompositorTimingHistory& from);
  CompositorTimingHistory(CompositorTimingHistory&& from) noexcept
    : CompositorTimingHistory() {
    *this = ::std::move(from);
  }

  inline CompositorTimingHistory& operator=(const CompositorTimingHistory& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompositorTimingHistory& operator=(CompositorTimingHistory&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const CompositorTimingHistory& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CompositorTimingHistory* internal_default_instance() {
    return reinterpret_cast<const CompositorTimingHistory*>(
               &_CompositorTimingHistory_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(CompositorTimingHistory& a, CompositorTimingHistory& b) {
    a.Swap(&b);
  }
  inline void Swap(CompositorTimingHistory* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CompositorTimingHistory* New() const final {
    return CreateMaybeMessage<CompositorTimingHistory>(nullptr);
  }

  CompositorTimingHistory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CompositorTimingHistory>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const CompositorTimingHistory& from);
  void MergeFrom(const CompositorTimingHistory& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CompositorTimingHistory* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.CompositorTimingHistory";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBeginMainFrameQueueCriticalEstimateDeltaUsFieldNumber = 1,
    kBeginMainFrameQueueNotCriticalEstimateDeltaUsFieldNumber = 2,
    kBeginMainFrameStartToReadyToCommitEstimateDeltaUsFieldNumber = 3,
    kCommitToReadyToActivateEstimateDeltaUsFieldNumber = 4,
    kPrepareTilesEstimateDeltaUsFieldNumber = 5,
    kActivateEstimateDeltaUsFieldNumber = 6,
    kDrawEstimateDeltaUsFieldNumber = 7,
  };
  // optional int64 begin_main_frame_queue_critical_estimate_delta_us = 1;
  bool has_begin_main_frame_queue_critical_estimate_delta_us() const;
  void clear_begin_main_frame_queue_critical_estimate_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 begin_main_frame_queue_critical_estimate_delta_us() const;
  void set_begin_main_frame_queue_critical_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 begin_main_frame_queue_not_critical_estimate_delta_us = 2;
  bool has_begin_main_frame_queue_not_critical_estimate_delta_us() const;
  void clear_begin_main_frame_queue_not_critical_estimate_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 begin_main_frame_queue_not_critical_estimate_delta_us() const;
  void set_begin_main_frame_queue_not_critical_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 begin_main_frame_start_to_ready_to_commit_estimate_delta_us = 3;
  bool has_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const;
  void clear_begin_main_frame_start_to_ready_to_commit_estimate_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const;
  void set_begin_main_frame_start_to_ready_to_commit_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 commit_to_ready_to_activate_estimate_delta_us = 4;
  bool has_commit_to_ready_to_activate_estimate_delta_us() const;
  void clear_commit_to_ready_to_activate_estimate_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 commit_to_ready_to_activate_estimate_delta_us() const;
  void set_commit_to_ready_to_activate_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 prepare_tiles_estimate_delta_us = 5;
  bool has_prepare_tiles_estimate_delta_us() const;
  void clear_prepare_tiles_estimate_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 prepare_tiles_estimate_delta_us() const;
  void set_prepare_tiles_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 activate_estimate_delta_us = 6;
  bool has_activate_estimate_delta_us() const;
  void clear_activate_estimate_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 activate_estimate_delta_us() const;
  void set_activate_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 draw_estimate_delta_us = 7;
  bool has_draw_estimate_delta_us() const;
  void clear_draw_estimate_delta_us();
  ::PROTOBUF_NAMESPACE_ID::int64 draw_estimate_delta_us() const;
  void set_draw_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.CompositorTimingHistory)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::int64 begin_main_frame_queue_critical_estimate_delta_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 begin_main_frame_queue_not_critical_estimate_delta_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 begin_main_frame_start_to_ready_to_commit_estimate_delta_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 commit_to_ready_to_activate_estimate_delta_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 prepare_tiles_estimate_delta_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 activate_estimate_delta_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 draw_estimate_delta_us_;
  friend struct ::TableStruct_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// ChromeCompositorSchedulerState

// optional .perfetto.protos.ChromeCompositorStateMachine state_machine = 1;
inline bool ChromeCompositorSchedulerState::has_state_machine() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_state_machine() {
  if (state_machine_ != nullptr) state_machine_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::perfetto::protos::ChromeCompositorStateMachine& ChromeCompositorSchedulerState::state_machine() const {
  const ::perfetto::protos::ChromeCompositorStateMachine* p = state_machine_;
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.state_machine)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::ChromeCompositorStateMachine*>(
      &::perfetto::protos::_ChromeCompositorStateMachine_default_instance_);
}
inline ::perfetto::protos::ChromeCompositorStateMachine* ChromeCompositorSchedulerState::release_state_machine() {
  // @@protoc_insertion_point(field_release:perfetto.protos.ChromeCompositorSchedulerState.state_machine)
  _has_bits_[0] &= ~0x00000001u;
  ::perfetto::protos::ChromeCompositorStateMachine* temp = state_machine_;
  state_machine_ = nullptr;
  return temp;
}
inline ::perfetto::protos::ChromeCompositorStateMachine* ChromeCompositorSchedulerState::mutable_state_machine() {
  _has_bits_[0] |= 0x00000001u;
  if (state_machine_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::ChromeCompositorStateMachine>(GetArenaNoVirtual());
    state_machine_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeCompositorSchedulerState.state_machine)
  return state_machine_;
}
inline void ChromeCompositorSchedulerState::set_allocated_state_machine(::perfetto::protos::ChromeCompositorStateMachine* state_machine) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete state_machine_;
  }
  if (state_machine) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      state_machine = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, state_machine, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  state_machine_ = state_machine;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeCompositorSchedulerState.state_machine)
}

// optional bool observing_begin_frame_source = 2;
inline bool ChromeCompositorSchedulerState::has_observing_begin_frame_source() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_observing_begin_frame_source() {
  observing_begin_frame_source_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool ChromeCompositorSchedulerState::observing_begin_frame_source() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.observing_begin_frame_source)
  return observing_begin_frame_source_;
}
inline void ChromeCompositorSchedulerState::set_observing_begin_frame_source(bool value) {
  _has_bits_[0] |= 0x00000020u;
  observing_begin_frame_source_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.observing_begin_frame_source)
}

// optional bool begin_impl_frame_deadline_task = 3;
inline bool ChromeCompositorSchedulerState::has_begin_impl_frame_deadline_task() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_begin_impl_frame_deadline_task() {
  begin_impl_frame_deadline_task_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool ChromeCompositorSchedulerState::begin_impl_frame_deadline_task() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.begin_impl_frame_deadline_task)
  return begin_impl_frame_deadline_task_;
}
inline void ChromeCompositorSchedulerState::set_begin_impl_frame_deadline_task(bool value) {
  _has_bits_[0] |= 0x00000040u;
  begin_impl_frame_deadline_task_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.begin_impl_frame_deadline_task)
}

// optional bool pending_begin_frame_task = 4;
inline bool ChromeCompositorSchedulerState::has_pending_begin_frame_task() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_pending_begin_frame_task() {
  pending_begin_frame_task_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool ChromeCompositorSchedulerState::pending_begin_frame_task() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.pending_begin_frame_task)
  return pending_begin_frame_task_;
}
inline void ChromeCompositorSchedulerState::set_pending_begin_frame_task(bool value) {
  _has_bits_[0] |= 0x00000080u;
  pending_begin_frame_task_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.pending_begin_frame_task)
}

// optional bool skipped_last_frame_missed_exceeded_deadline = 5;
inline bool ChromeCompositorSchedulerState::has_skipped_last_frame_missed_exceeded_deadline() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_skipped_last_frame_missed_exceeded_deadline() {
  skipped_last_frame_missed_exceeded_deadline_ = false;
  _has_bits_[0] &= ~0x00000100u;
}
inline bool ChromeCompositorSchedulerState::skipped_last_frame_missed_exceeded_deadline() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.skipped_last_frame_missed_exceeded_deadline)
  return skipped_last_frame_missed_exceeded_deadline_;
}
inline void ChromeCompositorSchedulerState::set_skipped_last_frame_missed_exceeded_deadline(bool value) {
  _has_bits_[0] |= 0x00000100u;
  skipped_last_frame_missed_exceeded_deadline_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.skipped_last_frame_missed_exceeded_deadline)
}

// optional .perfetto.protos.ChromeCompositorSchedulerAction inside_action = 7;
inline bool ChromeCompositorSchedulerState::has_inside_action() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_inside_action() {
  inside_action_ = 0;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::perfetto::protos::ChromeCompositorSchedulerAction ChromeCompositorSchedulerState::inside_action() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.inside_action)
  return static_cast< ::perfetto::protos::ChromeCompositorSchedulerAction >(inside_action_);
}
inline void ChromeCompositorSchedulerState::set_inside_action(::perfetto::protos::ChromeCompositorSchedulerAction value) {
  assert(::perfetto::protos::ChromeCompositorSchedulerAction_IsValid(value));
  _has_bits_[0] |= 0x00000200u;
  inside_action_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.inside_action)
}

// optional .perfetto.protos.ChromeCompositorSchedulerState.BeginImplFrameDeadlineMode deadline_mode = 8;
inline bool ChromeCompositorSchedulerState::has_deadline_mode() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_deadline_mode() {
  deadline_mode_ = 0;
  _has_bits_[0] &= ~0x00008000u;
}
inline ::perfetto::protos::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState::deadline_mode() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.deadline_mode)
  return static_cast< ::perfetto::protos::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode >(deadline_mode_);
}
inline void ChromeCompositorSchedulerState::set_deadline_mode(::perfetto::protos::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) {
  assert(::perfetto::protos::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_IsValid(value));
  _has_bits_[0] |= 0x00008000u;
  deadline_mode_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.deadline_mode)
}

// optional int64 deadline_us = 9;
inline bool ChromeCompositorSchedulerState::has_deadline_us() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_deadline_us() {
  deadline_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ChromeCompositorSchedulerState::deadline_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.deadline_us)
  return deadline_us_;
}
inline void ChromeCompositorSchedulerState::set_deadline_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000400u;
  deadline_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.deadline_us)
}

// optional int64 deadline_scheduled_at_us = 10;
inline bool ChromeCompositorSchedulerState::has_deadline_scheduled_at_us() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_deadline_scheduled_at_us() {
  deadline_scheduled_at_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ChromeCompositorSchedulerState::deadline_scheduled_at_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.deadline_scheduled_at_us)
  return deadline_scheduled_at_us_;
}
inline void ChromeCompositorSchedulerState::set_deadline_scheduled_at_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000800u;
  deadline_scheduled_at_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.deadline_scheduled_at_us)
}

// optional int64 now_us = 11;
inline bool ChromeCompositorSchedulerState::has_now_us() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_now_us() {
  now_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ChromeCompositorSchedulerState::now_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.now_us)
  return now_us_;
}
inline void ChromeCompositorSchedulerState::set_now_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00001000u;
  now_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.now_us)
}

// optional int64 now_to_deadline_delta_us = 12;
inline bool ChromeCompositorSchedulerState::has_now_to_deadline_delta_us() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_now_to_deadline_delta_us() {
  now_to_deadline_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00002000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ChromeCompositorSchedulerState::now_to_deadline_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.now_to_deadline_delta_us)
  return now_to_deadline_delta_us_;
}
inline void ChromeCompositorSchedulerState::set_now_to_deadline_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00002000u;
  now_to_deadline_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.now_to_deadline_delta_us)
}

// optional int64 now_to_deadline_scheduled_at_delta_us = 13;
inline bool ChromeCompositorSchedulerState::has_now_to_deadline_scheduled_at_delta_us() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_now_to_deadline_scheduled_at_delta_us() {
  now_to_deadline_scheduled_at_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00004000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ChromeCompositorSchedulerState::now_to_deadline_scheduled_at_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.now_to_deadline_scheduled_at_delta_us)
  return now_to_deadline_scheduled_at_delta_us_;
}
inline void ChromeCompositorSchedulerState::set_now_to_deadline_scheduled_at_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00004000u;
  now_to_deadline_scheduled_at_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorSchedulerState.now_to_deadline_scheduled_at_delta_us)
}

// optional .perfetto.protos.BeginImplFrameArgs begin_impl_frame_args = 14;
inline bool ChromeCompositorSchedulerState::has_begin_impl_frame_args() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_begin_impl_frame_args() {
  if (begin_impl_frame_args_ != nullptr) begin_impl_frame_args_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::perfetto::protos::BeginImplFrameArgs& ChromeCompositorSchedulerState::begin_impl_frame_args() const {
  const ::perfetto::protos::BeginImplFrameArgs* p = begin_impl_frame_args_;
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.begin_impl_frame_args)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::BeginImplFrameArgs*>(
      &::perfetto::protos::_BeginImplFrameArgs_default_instance_);
}
inline ::perfetto::protos::BeginImplFrameArgs* ChromeCompositorSchedulerState::release_begin_impl_frame_args() {
  // @@protoc_insertion_point(field_release:perfetto.protos.ChromeCompositorSchedulerState.begin_impl_frame_args)
  _has_bits_[0] &= ~0x00000002u;
  ::perfetto::protos::BeginImplFrameArgs* temp = begin_impl_frame_args_;
  begin_impl_frame_args_ = nullptr;
  return temp;
}
inline ::perfetto::protos::BeginImplFrameArgs* ChromeCompositorSchedulerState::mutable_begin_impl_frame_args() {
  _has_bits_[0] |= 0x00000002u;
  if (begin_impl_frame_args_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::BeginImplFrameArgs>(GetArenaNoVirtual());
    begin_impl_frame_args_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeCompositorSchedulerState.begin_impl_frame_args)
  return begin_impl_frame_args_;
}
inline void ChromeCompositorSchedulerState::set_allocated_begin_impl_frame_args(::perfetto::protos::BeginImplFrameArgs* begin_impl_frame_args) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete begin_impl_frame_args_;
  }
  if (begin_impl_frame_args) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      begin_impl_frame_args = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, begin_impl_frame_args, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  begin_impl_frame_args_ = begin_impl_frame_args;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeCompositorSchedulerState.begin_impl_frame_args)
}

// optional .perfetto.protos.BeginFrameObserverState begin_frame_observer_state = 15;
inline bool ChromeCompositorSchedulerState::has_begin_frame_observer_state() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_begin_frame_observer_state() {
  if (begin_frame_observer_state_ != nullptr) begin_frame_observer_state_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::perfetto::protos::BeginFrameObserverState& ChromeCompositorSchedulerState::begin_frame_observer_state() const {
  const ::perfetto::protos::BeginFrameObserverState* p = begin_frame_observer_state_;
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.begin_frame_observer_state)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::BeginFrameObserverState*>(
      &::perfetto::protos::_BeginFrameObserverState_default_instance_);
}
inline ::perfetto::protos::BeginFrameObserverState* ChromeCompositorSchedulerState::release_begin_frame_observer_state() {
  // @@protoc_insertion_point(field_release:perfetto.protos.ChromeCompositorSchedulerState.begin_frame_observer_state)
  _has_bits_[0] &= ~0x00000004u;
  ::perfetto::protos::BeginFrameObserverState* temp = begin_frame_observer_state_;
  begin_frame_observer_state_ = nullptr;
  return temp;
}
inline ::perfetto::protos::BeginFrameObserverState* ChromeCompositorSchedulerState::mutable_begin_frame_observer_state() {
  _has_bits_[0] |= 0x00000004u;
  if (begin_frame_observer_state_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::BeginFrameObserverState>(GetArenaNoVirtual());
    begin_frame_observer_state_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeCompositorSchedulerState.begin_frame_observer_state)
  return begin_frame_observer_state_;
}
inline void ChromeCompositorSchedulerState::set_allocated_begin_frame_observer_state(::perfetto::protos::BeginFrameObserverState* begin_frame_observer_state) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete begin_frame_observer_state_;
  }
  if (begin_frame_observer_state) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      begin_frame_observer_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, begin_frame_observer_state, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  begin_frame_observer_state_ = begin_frame_observer_state;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeCompositorSchedulerState.begin_frame_observer_state)
}

// optional .perfetto.protos.BeginFrameSourceState begin_frame_source_state = 16;
inline bool ChromeCompositorSchedulerState::has_begin_frame_source_state() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_begin_frame_source_state() {
  if (begin_frame_source_state_ != nullptr) begin_frame_source_state_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::perfetto::protos::BeginFrameSourceState& ChromeCompositorSchedulerState::begin_frame_source_state() const {
  const ::perfetto::protos::BeginFrameSourceState* p = begin_frame_source_state_;
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.begin_frame_source_state)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::BeginFrameSourceState*>(
      &::perfetto::protos::_BeginFrameSourceState_default_instance_);
}
inline ::perfetto::protos::BeginFrameSourceState* ChromeCompositorSchedulerState::release_begin_frame_source_state() {
  // @@protoc_insertion_point(field_release:perfetto.protos.ChromeCompositorSchedulerState.begin_frame_source_state)
  _has_bits_[0] &= ~0x00000008u;
  ::perfetto::protos::BeginFrameSourceState* temp = begin_frame_source_state_;
  begin_frame_source_state_ = nullptr;
  return temp;
}
inline ::perfetto::protos::BeginFrameSourceState* ChromeCompositorSchedulerState::mutable_begin_frame_source_state() {
  _has_bits_[0] |= 0x00000008u;
  if (begin_frame_source_state_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::BeginFrameSourceState>(GetArenaNoVirtual());
    begin_frame_source_state_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeCompositorSchedulerState.begin_frame_source_state)
  return begin_frame_source_state_;
}
inline void ChromeCompositorSchedulerState::set_allocated_begin_frame_source_state(::perfetto::protos::BeginFrameSourceState* begin_frame_source_state) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete begin_frame_source_state_;
  }
  if (begin_frame_source_state) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      begin_frame_source_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, begin_frame_source_state, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  begin_frame_source_state_ = begin_frame_source_state;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeCompositorSchedulerState.begin_frame_source_state)
}

// optional .perfetto.protos.CompositorTimingHistory compositor_timing_history = 17;
inline bool ChromeCompositorSchedulerState::has_compositor_timing_history() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ChromeCompositorSchedulerState::clear_compositor_timing_history() {
  if (compositor_timing_history_ != nullptr) compositor_timing_history_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
inline const ::perfetto::protos::CompositorTimingHistory& ChromeCompositorSchedulerState::compositor_timing_history() const {
  const ::perfetto::protos::CompositorTimingHistory* p = compositor_timing_history_;
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorSchedulerState.compositor_timing_history)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::CompositorTimingHistory*>(
      &::perfetto::protos::_CompositorTimingHistory_default_instance_);
}
inline ::perfetto::protos::CompositorTimingHistory* ChromeCompositorSchedulerState::release_compositor_timing_history() {
  // @@protoc_insertion_point(field_release:perfetto.protos.ChromeCompositorSchedulerState.compositor_timing_history)
  _has_bits_[0] &= ~0x00000010u;
  ::perfetto::protos::CompositorTimingHistory* temp = compositor_timing_history_;
  compositor_timing_history_ = nullptr;
  return temp;
}
inline ::perfetto::protos::CompositorTimingHistory* ChromeCompositorSchedulerState::mutable_compositor_timing_history() {
  _has_bits_[0] |= 0x00000010u;
  if (compositor_timing_history_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::CompositorTimingHistory>(GetArenaNoVirtual());
    compositor_timing_history_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeCompositorSchedulerState.compositor_timing_history)
  return compositor_timing_history_;
}
inline void ChromeCompositorSchedulerState::set_allocated_compositor_timing_history(::perfetto::protos::CompositorTimingHistory* compositor_timing_history) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete compositor_timing_history_;
  }
  if (compositor_timing_history) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      compositor_timing_history = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, compositor_timing_history, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  compositor_timing_history_ = compositor_timing_history;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeCompositorSchedulerState.compositor_timing_history)
}

// -------------------------------------------------------------------

// ChromeCompositorStateMachine_MajorState

// optional .perfetto.protos.ChromeCompositorSchedulerAction next_action = 1;
inline bool ChromeCompositorStateMachine_MajorState::has_next_action() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChromeCompositorStateMachine_MajorState::clear_next_action() {
  next_action_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::perfetto::protos::ChromeCompositorSchedulerAction ChromeCompositorStateMachine_MajorState::next_action() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MajorState.next_action)
  return static_cast< ::perfetto::protos::ChromeCompositorSchedulerAction >(next_action_);
}
inline void ChromeCompositorStateMachine_MajorState::set_next_action(::perfetto::protos::ChromeCompositorSchedulerAction value) {
  assert(::perfetto::protos::ChromeCompositorSchedulerAction_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  next_action_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MajorState.next_action)
}

// optional .perfetto.protos.ChromeCompositorStateMachine.MajorState.BeginImplFrameState begin_impl_frame_state = 2;
inline bool ChromeCompositorStateMachine_MajorState::has_begin_impl_frame_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChromeCompositorStateMachine_MajorState::clear_begin_impl_frame_state() {
  begin_impl_frame_state_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState::begin_impl_frame_state() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MajorState.begin_impl_frame_state)
  return static_cast< ::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginImplFrameState >(begin_impl_frame_state_);
}
inline void ChromeCompositorStateMachine_MajorState::set_begin_impl_frame_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) {
  assert(::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginImplFrameState_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  begin_impl_frame_state_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MajorState.begin_impl_frame_state)
}

// optional .perfetto.protos.ChromeCompositorStateMachine.MajorState.BeginMainFrameState begin_main_frame_state = 3;
inline bool ChromeCompositorStateMachine_MajorState::has_begin_main_frame_state() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ChromeCompositorStateMachine_MajorState::clear_begin_main_frame_state() {
  begin_main_frame_state_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState::begin_main_frame_state() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MajorState.begin_main_frame_state)
  return static_cast< ::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginMainFrameState >(begin_main_frame_state_);
}
inline void ChromeCompositorStateMachine_MajorState::set_begin_main_frame_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) {
  assert(::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginMainFrameState_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  begin_main_frame_state_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MajorState.begin_main_frame_state)
}

// optional .perfetto.protos.ChromeCompositorStateMachine.MajorState.LayerTreeFrameSinkState layer_tree_frame_sink_state = 4;
inline bool ChromeCompositorStateMachine_MajorState::has_layer_tree_frame_sink_state() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ChromeCompositorStateMachine_MajorState::clear_layer_tree_frame_sink_state() {
  layer_tree_frame_sink_state_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState::layer_tree_frame_sink_state() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MajorState.layer_tree_frame_sink_state)
  return static_cast< ::perfetto::protos::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState >(layer_tree_frame_sink_state_);
}
inline void ChromeCompositorStateMachine_MajorState::set_layer_tree_frame_sink_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) {
  assert(::perfetto::protos::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  layer_tree_frame_sink_state_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MajorState.layer_tree_frame_sink_state)
}

// optional .perfetto.protos.ChromeCompositorStateMachine.MajorState.ForcedRedrawOnTimeoutState forced_redraw_state = 5;
inline bool ChromeCompositorStateMachine_MajorState::has_forced_redraw_state() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ChromeCompositorStateMachine_MajorState::clear_forced_redraw_state() {
  forced_redraw_state_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState::forced_redraw_state() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MajorState.forced_redraw_state)
  return static_cast< ::perfetto::protos::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState >(forced_redraw_state_);
}
inline void ChromeCompositorStateMachine_MajorState::set_forced_redraw_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) {
  assert(::perfetto::protos::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  forced_redraw_state_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MajorState.forced_redraw_state)
}

// -------------------------------------------------------------------

// ChromeCompositorStateMachine_MinorState

// optional int32 commit_count = 1;
inline bool ChromeCompositorStateMachine_MinorState::has_commit_count() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_commit_count() {
  commit_count_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ChromeCompositorStateMachine_MinorState::commit_count() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.commit_count)
  return commit_count_;
}
inline void ChromeCompositorStateMachine_MinorState::set_commit_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000001u;
  commit_count_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.commit_count)
}

// optional int32 current_frame_number = 2;
inline bool ChromeCompositorStateMachine_MinorState::has_current_frame_number() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_current_frame_number() {
  current_frame_number_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ChromeCompositorStateMachine_MinorState::current_frame_number() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.current_frame_number)
  return current_frame_number_;
}
inline void ChromeCompositorStateMachine_MinorState::set_current_frame_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  current_frame_number_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.current_frame_number)
}

// optional int32 last_frame_number_submit_performed = 3;
inline bool ChromeCompositorStateMachine_MinorState::has_last_frame_number_submit_performed() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_last_frame_number_submit_performed() {
  last_frame_number_submit_performed_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ChromeCompositorStateMachine_MinorState::last_frame_number_submit_performed() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.last_frame_number_submit_performed)
  return last_frame_number_submit_performed_;
}
inline void ChromeCompositorStateMachine_MinorState::set_last_frame_number_submit_performed(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  last_frame_number_submit_performed_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.last_frame_number_submit_performed)
}

// optional int32 last_frame_number_draw_performed = 4;
inline bool ChromeCompositorStateMachine_MinorState::has_last_frame_number_draw_performed() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_last_frame_number_draw_performed() {
  last_frame_number_draw_performed_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ChromeCompositorStateMachine_MinorState::last_frame_number_draw_performed() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.last_frame_number_draw_performed)
  return last_frame_number_draw_performed_;
}
inline void ChromeCompositorStateMachine_MinorState::set_last_frame_number_draw_performed(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  last_frame_number_draw_performed_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.last_frame_number_draw_performed)
}

// optional int32 last_frame_number_begin_main_frame_sent = 5;
inline bool ChromeCompositorStateMachine_MinorState::has_last_frame_number_begin_main_frame_sent() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_last_frame_number_begin_main_frame_sent() {
  last_frame_number_begin_main_frame_sent_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ChromeCompositorStateMachine_MinorState::last_frame_number_begin_main_frame_sent() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.last_frame_number_begin_main_frame_sent)
  return last_frame_number_begin_main_frame_sent_;
}
inline void ChromeCompositorStateMachine_MinorState::set_last_frame_number_begin_main_frame_sent(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000010u;
  last_frame_number_begin_main_frame_sent_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.last_frame_number_begin_main_frame_sent)
}

// optional bool did_draw = 6;
inline bool ChromeCompositorStateMachine_MinorState::has_did_draw() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_draw() {
  did_draw_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_draw() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_draw)
  return did_draw_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_draw(bool value) {
  _has_bits_[0] |= 0x00000020u;
  did_draw_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_draw)
}

// optional bool did_send_begin_main_frame_for_current_frame = 7;
inline bool ChromeCompositorStateMachine_MinorState::has_did_send_begin_main_frame_for_current_frame() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_send_begin_main_frame_for_current_frame() {
  did_send_begin_main_frame_for_current_frame_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_send_begin_main_frame_for_current_frame() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_send_begin_main_frame_for_current_frame)
  return did_send_begin_main_frame_for_current_frame_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_send_begin_main_frame_for_current_frame(bool value) {
  _has_bits_[0] |= 0x00000040u;
  did_send_begin_main_frame_for_current_frame_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_send_begin_main_frame_for_current_frame)
}

// optional bool did_notify_begin_main_frame_not_expected_until = 8;
inline bool ChromeCompositorStateMachine_MinorState::has_did_notify_begin_main_frame_not_expected_until() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_notify_begin_main_frame_not_expected_until() {
  did_notify_begin_main_frame_not_expected_until_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_notify_begin_main_frame_not_expected_until() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_notify_begin_main_frame_not_expected_until)
  return did_notify_begin_main_frame_not_expected_until_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_notify_begin_main_frame_not_expected_until(bool value) {
  _has_bits_[0] |= 0x00000080u;
  did_notify_begin_main_frame_not_expected_until_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_notify_begin_main_frame_not_expected_until)
}

// optional bool did_notify_begin_main_frame_not_expected_soon = 9;
inline bool ChromeCompositorStateMachine_MinorState::has_did_notify_begin_main_frame_not_expected_soon() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_notify_begin_main_frame_not_expected_soon() {
  did_notify_begin_main_frame_not_expected_soon_ = false;
  _has_bits_[0] &= ~0x00000100u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_notify_begin_main_frame_not_expected_soon() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_notify_begin_main_frame_not_expected_soon)
  return did_notify_begin_main_frame_not_expected_soon_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_notify_begin_main_frame_not_expected_soon(bool value) {
  _has_bits_[0] |= 0x00000100u;
  did_notify_begin_main_frame_not_expected_soon_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_notify_begin_main_frame_not_expected_soon)
}

// optional bool wants_begin_main_frame_not_expected = 10;
inline bool ChromeCompositorStateMachine_MinorState::has_wants_begin_main_frame_not_expected() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_wants_begin_main_frame_not_expected() {
  wants_begin_main_frame_not_expected_ = false;
  _has_bits_[0] &= ~0x00000200u;
}
inline bool ChromeCompositorStateMachine_MinorState::wants_begin_main_frame_not_expected() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.wants_begin_main_frame_not_expected)
  return wants_begin_main_frame_not_expected_;
}
inline void ChromeCompositorStateMachine_MinorState::set_wants_begin_main_frame_not_expected(bool value) {
  _has_bits_[0] |= 0x00000200u;
  wants_begin_main_frame_not_expected_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.wants_begin_main_frame_not_expected)
}

// optional bool did_commit_during_frame = 11;
inline bool ChromeCompositorStateMachine_MinorState::has_did_commit_during_frame() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_commit_during_frame() {
  did_commit_during_frame_ = false;
  _has_bits_[0] &= ~0x00000400u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_commit_during_frame() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_commit_during_frame)
  return did_commit_during_frame_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_commit_during_frame(bool value) {
  _has_bits_[0] |= 0x00000400u;
  did_commit_during_frame_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_commit_during_frame)
}

// optional bool did_invalidate_layer_tree_frame_sink = 12;
inline bool ChromeCompositorStateMachine_MinorState::has_did_invalidate_layer_tree_frame_sink() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_invalidate_layer_tree_frame_sink() {
  did_invalidate_layer_tree_frame_sink_ = false;
  _has_bits_[0] &= ~0x00000800u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_invalidate_layer_tree_frame_sink() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_invalidate_layer_tree_frame_sink)
  return did_invalidate_layer_tree_frame_sink_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_invalidate_layer_tree_frame_sink(bool value) {
  _has_bits_[0] |= 0x00000800u;
  did_invalidate_layer_tree_frame_sink_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_invalidate_layer_tree_frame_sink)
}

// optional bool did_perform_impl_side_invalidaion = 13;
inline bool ChromeCompositorStateMachine_MinorState::has_did_perform_impl_side_invalidaion() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_perform_impl_side_invalidaion() {
  did_perform_impl_side_invalidaion_ = false;
  _has_bits_[0] &= ~0x00001000u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_perform_impl_side_invalidaion() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_perform_impl_side_invalidaion)
  return did_perform_impl_side_invalidaion_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_perform_impl_side_invalidaion(bool value) {
  _has_bits_[0] |= 0x00001000u;
  did_perform_impl_side_invalidaion_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_perform_impl_side_invalidaion)
}

// optional bool did_prepare_tiles = 14;
inline bool ChromeCompositorStateMachine_MinorState::has_did_prepare_tiles() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_prepare_tiles() {
  did_prepare_tiles_ = false;
  _has_bits_[0] &= ~0x00010000u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_prepare_tiles() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_prepare_tiles)
  return did_prepare_tiles_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_prepare_tiles(bool value) {
  _has_bits_[0] |= 0x00010000u;
  did_prepare_tiles_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_prepare_tiles)
}

// optional int32 consecutive_checkerboard_animations = 15;
inline bool ChromeCompositorStateMachine_MinorState::has_consecutive_checkerboard_animations() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_consecutive_checkerboard_animations() {
  consecutive_checkerboard_animations_ = 0;
  _has_bits_[0] &= ~0x00002000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ChromeCompositorStateMachine_MinorState::consecutive_checkerboard_animations() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.consecutive_checkerboard_animations)
  return consecutive_checkerboard_animations_;
}
inline void ChromeCompositorStateMachine_MinorState::set_consecutive_checkerboard_animations(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00002000u;
  consecutive_checkerboard_animations_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.consecutive_checkerboard_animations)
}

// optional int32 pending_submit_frames = 16;
inline bool ChromeCompositorStateMachine_MinorState::has_pending_submit_frames() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_pending_submit_frames() {
  pending_submit_frames_ = 0;
  _has_bits_[0] &= ~0x00004000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ChromeCompositorStateMachine_MinorState::pending_submit_frames() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.pending_submit_frames)
  return pending_submit_frames_;
}
inline void ChromeCompositorStateMachine_MinorState::set_pending_submit_frames(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00004000u;
  pending_submit_frames_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.pending_submit_frames)
}

// optional int32 submit_frames_with_current_layer_tree_frame_sink = 17;
inline bool ChromeCompositorStateMachine_MinorState::has_submit_frames_with_current_layer_tree_frame_sink() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_submit_frames_with_current_layer_tree_frame_sink() {
  submit_frames_with_current_layer_tree_frame_sink_ = 0;
  _has_bits_[0] &= ~0x00008000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ChromeCompositorStateMachine_MinorState::submit_frames_with_current_layer_tree_frame_sink() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.submit_frames_with_current_layer_tree_frame_sink)
  return submit_frames_with_current_layer_tree_frame_sink_;
}
inline void ChromeCompositorStateMachine_MinorState::set_submit_frames_with_current_layer_tree_frame_sink(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00008000u;
  submit_frames_with_current_layer_tree_frame_sink_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.submit_frames_with_current_layer_tree_frame_sink)
}

// optional bool needs_redraw = 18;
inline bool ChromeCompositorStateMachine_MinorState::has_needs_redraw() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_needs_redraw() {
  needs_redraw_ = false;
  _has_bits_[0] &= ~0x00020000u;
}
inline bool ChromeCompositorStateMachine_MinorState::needs_redraw() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_redraw)
  return needs_redraw_;
}
inline void ChromeCompositorStateMachine_MinorState::set_needs_redraw(bool value) {
  _has_bits_[0] |= 0x00020000u;
  needs_redraw_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_redraw)
}

// optional bool needs_prepare_tiles = 19;
inline bool ChromeCompositorStateMachine_MinorState::has_needs_prepare_tiles() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_needs_prepare_tiles() {
  needs_prepare_tiles_ = false;
  _has_bits_[0] &= ~0x00040000u;
}
inline bool ChromeCompositorStateMachine_MinorState::needs_prepare_tiles() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_prepare_tiles)
  return needs_prepare_tiles_;
}
inline void ChromeCompositorStateMachine_MinorState::set_needs_prepare_tiles(bool value) {
  _has_bits_[0] |= 0x00040000u;
  needs_prepare_tiles_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_prepare_tiles)
}

// optional bool needs_begin_main_frame = 20;
inline bool ChromeCompositorStateMachine_MinorState::has_needs_begin_main_frame() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_needs_begin_main_frame() {
  needs_begin_main_frame_ = false;
  _has_bits_[0] &= ~0x00080000u;
}
inline bool ChromeCompositorStateMachine_MinorState::needs_begin_main_frame() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_begin_main_frame)
  return needs_begin_main_frame_;
}
inline void ChromeCompositorStateMachine_MinorState::set_needs_begin_main_frame(bool value) {
  _has_bits_[0] |= 0x00080000u;
  needs_begin_main_frame_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_begin_main_frame)
}

// optional bool needs_one_begin_impl_frame = 21;
inline bool ChromeCompositorStateMachine_MinorState::has_needs_one_begin_impl_frame() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_needs_one_begin_impl_frame() {
  needs_one_begin_impl_frame_ = false;
  _has_bits_[0] &= ~0x00100000u;
}
inline bool ChromeCompositorStateMachine_MinorState::needs_one_begin_impl_frame() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_one_begin_impl_frame)
  return needs_one_begin_impl_frame_;
}
inline void ChromeCompositorStateMachine_MinorState::set_needs_one_begin_impl_frame(bool value) {
  _has_bits_[0] |= 0x00100000u;
  needs_one_begin_impl_frame_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_one_begin_impl_frame)
}

// optional bool visible = 22;
inline bool ChromeCompositorStateMachine_MinorState::has_visible() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_visible() {
  visible_ = false;
  _has_bits_[0] &= ~0x00200000u;
}
inline bool ChromeCompositorStateMachine_MinorState::visible() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.visible)
  return visible_;
}
inline void ChromeCompositorStateMachine_MinorState::set_visible(bool value) {
  _has_bits_[0] |= 0x00200000u;
  visible_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.visible)
}

// optional bool begin_frame_source_paused = 23;
inline bool ChromeCompositorStateMachine_MinorState::has_begin_frame_source_paused() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_begin_frame_source_paused() {
  begin_frame_source_paused_ = false;
  _has_bits_[0] &= ~0x00400000u;
}
inline bool ChromeCompositorStateMachine_MinorState::begin_frame_source_paused() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.begin_frame_source_paused)
  return begin_frame_source_paused_;
}
inline void ChromeCompositorStateMachine_MinorState::set_begin_frame_source_paused(bool value) {
  _has_bits_[0] |= 0x00400000u;
  begin_frame_source_paused_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.begin_frame_source_paused)
}

// optional bool can_draw = 24;
inline bool ChromeCompositorStateMachine_MinorState::has_can_draw() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_can_draw() {
  can_draw_ = false;
  _has_bits_[0] &= ~0x00800000u;
}
inline bool ChromeCompositorStateMachine_MinorState::can_draw() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.can_draw)
  return can_draw_;
}
inline void ChromeCompositorStateMachine_MinorState::set_can_draw(bool value) {
  _has_bits_[0] |= 0x00800000u;
  can_draw_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.can_draw)
}

// optional bool resourceless_draw = 25;
inline bool ChromeCompositorStateMachine_MinorState::has_resourceless_draw() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_resourceless_draw() {
  resourceless_draw_ = false;
  _has_bits_[0] &= ~0x01000000u;
}
inline bool ChromeCompositorStateMachine_MinorState::resourceless_draw() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.resourceless_draw)
  return resourceless_draw_;
}
inline void ChromeCompositorStateMachine_MinorState::set_resourceless_draw(bool value) {
  _has_bits_[0] |= 0x01000000u;
  resourceless_draw_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.resourceless_draw)
}

// optional bool has_pending_tree = 26;
inline bool ChromeCompositorStateMachine_MinorState::has_has_pending_tree() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_has_pending_tree() {
  has_pending_tree_ = false;
  _has_bits_[0] &= ~0x02000000u;
}
inline bool ChromeCompositorStateMachine_MinorState::has_pending_tree() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.has_pending_tree)
  return has_pending_tree_;
}
inline void ChromeCompositorStateMachine_MinorState::set_has_pending_tree(bool value) {
  _has_bits_[0] |= 0x02000000u;
  has_pending_tree_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.has_pending_tree)
}

// optional bool pending_tree_is_ready_for_activation = 27;
inline bool ChromeCompositorStateMachine_MinorState::has_pending_tree_is_ready_for_activation() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_pending_tree_is_ready_for_activation() {
  pending_tree_is_ready_for_activation_ = false;
  _has_bits_[0] &= ~0x04000000u;
}
inline bool ChromeCompositorStateMachine_MinorState::pending_tree_is_ready_for_activation() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.pending_tree_is_ready_for_activation)
  return pending_tree_is_ready_for_activation_;
}
inline void ChromeCompositorStateMachine_MinorState::set_pending_tree_is_ready_for_activation(bool value) {
  _has_bits_[0] |= 0x04000000u;
  pending_tree_is_ready_for_activation_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.pending_tree_is_ready_for_activation)
}

// optional bool active_tree_needs_first_draw = 28;
inline bool ChromeCompositorStateMachine_MinorState::has_active_tree_needs_first_draw() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_active_tree_needs_first_draw() {
  active_tree_needs_first_draw_ = false;
  _has_bits_[0] &= ~0x08000000u;
}
inline bool ChromeCompositorStateMachine_MinorState::active_tree_needs_first_draw() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.active_tree_needs_first_draw)
  return active_tree_needs_first_draw_;
}
inline void ChromeCompositorStateMachine_MinorState::set_active_tree_needs_first_draw(bool value) {
  _has_bits_[0] |= 0x08000000u;
  active_tree_needs_first_draw_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.active_tree_needs_first_draw)
}

// optional bool active_tree_is_ready_to_draw = 29;
inline bool ChromeCompositorStateMachine_MinorState::has_active_tree_is_ready_to_draw() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_active_tree_is_ready_to_draw() {
  active_tree_is_ready_to_draw_ = false;
  _has_bits_[0] &= ~0x20000000u;
}
inline bool ChromeCompositorStateMachine_MinorState::active_tree_is_ready_to_draw() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.active_tree_is_ready_to_draw)
  return active_tree_is_ready_to_draw_;
}
inline void ChromeCompositorStateMachine_MinorState::set_active_tree_is_ready_to_draw(bool value) {
  _has_bits_[0] |= 0x20000000u;
  active_tree_is_ready_to_draw_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.active_tree_is_ready_to_draw)
}

// optional bool did_create_and_initialize_first_layer_tree_frame_sink = 30;
inline bool ChromeCompositorStateMachine_MinorState::has_did_create_and_initialize_first_layer_tree_frame_sink() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_create_and_initialize_first_layer_tree_frame_sink() {
  did_create_and_initialize_first_layer_tree_frame_sink_ = false;
  _has_bits_[0] &= ~0x40000000u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_create_and_initialize_first_layer_tree_frame_sink() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_create_and_initialize_first_layer_tree_frame_sink)
  return did_create_and_initialize_first_layer_tree_frame_sink_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_create_and_initialize_first_layer_tree_frame_sink(bool value) {
  _has_bits_[0] |= 0x40000000u;
  did_create_and_initialize_first_layer_tree_frame_sink_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_create_and_initialize_first_layer_tree_frame_sink)
}

// optional .perfetto.protos.ChromeCompositorStateMachine.MinorState.TreePriority tree_priority = 31;
inline bool ChromeCompositorStateMachine_MinorState::has_tree_priority() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_tree_priority() {
  tree_priority_ = 0;
  _has_bits_[0] &= ~0x10000000u;
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState::tree_priority() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.tree_priority)
  return static_cast< ::perfetto::protos::ChromeCompositorStateMachine_MinorState_TreePriority >(tree_priority_);
}
inline void ChromeCompositorStateMachine_MinorState::set_tree_priority(::perfetto::protos::ChromeCompositorStateMachine_MinorState_TreePriority value) {
  assert(::perfetto::protos::ChromeCompositorStateMachine_MinorState_TreePriority_IsValid(value));
  _has_bits_[0] |= 0x10000000u;
  tree_priority_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.tree_priority)
}

// optional .perfetto.protos.ChromeCompositorStateMachine.MinorState.ScrollHandlerState scroll_handler_state = 32;
inline bool ChromeCompositorStateMachine_MinorState::has_scroll_handler_state() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_scroll_handler_state() {
  scroll_handler_state_ = 0;
  _has_bits_[1] &= ~0x00000002u;
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState::scroll_handler_state() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.scroll_handler_state)
  return static_cast< ::perfetto::protos::ChromeCompositorStateMachine_MinorState_ScrollHandlerState >(scroll_handler_state_);
}
inline void ChromeCompositorStateMachine_MinorState::set_scroll_handler_state(::perfetto::protos::ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) {
  assert(::perfetto::protos::ChromeCompositorStateMachine_MinorState_ScrollHandlerState_IsValid(value));
  _has_bits_[1] |= 0x00000002u;
  scroll_handler_state_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.scroll_handler_state)
}

// optional bool critical_begin_main_frame_to_activate_is_fast = 33;
inline bool ChromeCompositorStateMachine_MinorState::has_critical_begin_main_frame_to_activate_is_fast() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_critical_begin_main_frame_to_activate_is_fast() {
  critical_begin_main_frame_to_activate_is_fast_ = false;
  _has_bits_[0] &= ~0x80000000u;
}
inline bool ChromeCompositorStateMachine_MinorState::critical_begin_main_frame_to_activate_is_fast() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.critical_begin_main_frame_to_activate_is_fast)
  return critical_begin_main_frame_to_activate_is_fast_;
}
inline void ChromeCompositorStateMachine_MinorState::set_critical_begin_main_frame_to_activate_is_fast(bool value) {
  _has_bits_[0] |= 0x80000000u;
  critical_begin_main_frame_to_activate_is_fast_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.critical_begin_main_frame_to_activate_is_fast)
}

// optional bool main_thread_missed_last_deadline = 34;
inline bool ChromeCompositorStateMachine_MinorState::has_main_thread_missed_last_deadline() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_main_thread_missed_last_deadline() {
  main_thread_missed_last_deadline_ = false;
  _has_bits_[1] &= ~0x00000001u;
}
inline bool ChromeCompositorStateMachine_MinorState::main_thread_missed_last_deadline() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.main_thread_missed_last_deadline)
  return main_thread_missed_last_deadline_;
}
inline void ChromeCompositorStateMachine_MinorState::set_main_thread_missed_last_deadline(bool value) {
  _has_bits_[1] |= 0x00000001u;
  main_thread_missed_last_deadline_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.main_thread_missed_last_deadline)
}

// optional bool video_needs_begin_frames = 36;
inline bool ChromeCompositorStateMachine_MinorState::has_video_needs_begin_frames() const {
  return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_video_needs_begin_frames() {
  video_needs_begin_frames_ = false;
  _has_bits_[1] &= ~0x00000004u;
}
inline bool ChromeCompositorStateMachine_MinorState::video_needs_begin_frames() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.video_needs_begin_frames)
  return video_needs_begin_frames_;
}
inline void ChromeCompositorStateMachine_MinorState::set_video_needs_begin_frames(bool value) {
  _has_bits_[1] |= 0x00000004u;
  video_needs_begin_frames_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.video_needs_begin_frames)
}

// optional bool defer_begin_main_frame = 37;
inline bool ChromeCompositorStateMachine_MinorState::has_defer_begin_main_frame() const {
  return (_has_bits_[1] & 0x00000008u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_defer_begin_main_frame() {
  defer_begin_main_frame_ = false;
  _has_bits_[1] &= ~0x00000008u;
}
inline bool ChromeCompositorStateMachine_MinorState::defer_begin_main_frame() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.defer_begin_main_frame)
  return defer_begin_main_frame_;
}
inline void ChromeCompositorStateMachine_MinorState::set_defer_begin_main_frame(bool value) {
  _has_bits_[1] |= 0x00000008u;
  defer_begin_main_frame_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.defer_begin_main_frame)
}

// optional bool last_commit_had_no_updates = 38;
inline bool ChromeCompositorStateMachine_MinorState::has_last_commit_had_no_updates() const {
  return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_last_commit_had_no_updates() {
  last_commit_had_no_updates_ = false;
  _has_bits_[1] &= ~0x00000010u;
}
inline bool ChromeCompositorStateMachine_MinorState::last_commit_had_no_updates() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.last_commit_had_no_updates)
  return last_commit_had_no_updates_;
}
inline void ChromeCompositorStateMachine_MinorState::set_last_commit_had_no_updates(bool value) {
  _has_bits_[1] |= 0x00000010u;
  last_commit_had_no_updates_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.last_commit_had_no_updates)
}

// optional bool did_draw_in_last_frame = 39;
inline bool ChromeCompositorStateMachine_MinorState::has_did_draw_in_last_frame() const {
  return (_has_bits_[1] & 0x00000020u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_draw_in_last_frame() {
  did_draw_in_last_frame_ = false;
  _has_bits_[1] &= ~0x00000020u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_draw_in_last_frame() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_draw_in_last_frame)
  return did_draw_in_last_frame_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_draw_in_last_frame(bool value) {
  _has_bits_[1] |= 0x00000020u;
  did_draw_in_last_frame_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_draw_in_last_frame)
}

// optional bool did_submit_in_last_frame = 40;
inline bool ChromeCompositorStateMachine_MinorState::has_did_submit_in_last_frame() const {
  return (_has_bits_[1] & 0x00000040u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_did_submit_in_last_frame() {
  did_submit_in_last_frame_ = false;
  _has_bits_[1] &= ~0x00000040u;
}
inline bool ChromeCompositorStateMachine_MinorState::did_submit_in_last_frame() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_submit_in_last_frame)
  return did_submit_in_last_frame_;
}
inline void ChromeCompositorStateMachine_MinorState::set_did_submit_in_last_frame(bool value) {
  _has_bits_[1] |= 0x00000040u;
  did_submit_in_last_frame_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.did_submit_in_last_frame)
}

// optional bool needs_impl_side_invalidation = 41;
inline bool ChromeCompositorStateMachine_MinorState::has_needs_impl_side_invalidation() const {
  return (_has_bits_[1] & 0x00000080u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_needs_impl_side_invalidation() {
  needs_impl_side_invalidation_ = false;
  _has_bits_[1] &= ~0x00000080u;
}
inline bool ChromeCompositorStateMachine_MinorState::needs_impl_side_invalidation() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_impl_side_invalidation)
  return needs_impl_side_invalidation_;
}
inline void ChromeCompositorStateMachine_MinorState::set_needs_impl_side_invalidation(bool value) {
  _has_bits_[1] |= 0x00000080u;
  needs_impl_side_invalidation_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.needs_impl_side_invalidation)
}

// optional bool current_pending_tree_is_impl_side = 42;
inline bool ChromeCompositorStateMachine_MinorState::has_current_pending_tree_is_impl_side() const {
  return (_has_bits_[1] & 0x00000100u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_current_pending_tree_is_impl_side() {
  current_pending_tree_is_impl_side_ = false;
  _has_bits_[1] &= ~0x00000100u;
}
inline bool ChromeCompositorStateMachine_MinorState::current_pending_tree_is_impl_side() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.current_pending_tree_is_impl_side)
  return current_pending_tree_is_impl_side_;
}
inline void ChromeCompositorStateMachine_MinorState::set_current_pending_tree_is_impl_side(bool value) {
  _has_bits_[1] |= 0x00000100u;
  current_pending_tree_is_impl_side_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.current_pending_tree_is_impl_side)
}

// optional bool previous_pending_tree_was_impl_side = 43;
inline bool ChromeCompositorStateMachine_MinorState::has_previous_pending_tree_was_impl_side() const {
  return (_has_bits_[1] & 0x00000200u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_previous_pending_tree_was_impl_side() {
  previous_pending_tree_was_impl_side_ = false;
  _has_bits_[1] &= ~0x00000200u;
}
inline bool ChromeCompositorStateMachine_MinorState::previous_pending_tree_was_impl_side() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.previous_pending_tree_was_impl_side)
  return previous_pending_tree_was_impl_side_;
}
inline void ChromeCompositorStateMachine_MinorState::set_previous_pending_tree_was_impl_side(bool value) {
  _has_bits_[1] |= 0x00000200u;
  previous_pending_tree_was_impl_side_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.previous_pending_tree_was_impl_side)
}

// optional bool processing_animation_worklets_for_active_tree = 44;
inline bool ChromeCompositorStateMachine_MinorState::has_processing_animation_worklets_for_active_tree() const {
  return (_has_bits_[1] & 0x00000400u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_processing_animation_worklets_for_active_tree() {
  processing_animation_worklets_for_active_tree_ = false;
  _has_bits_[1] &= ~0x00000400u;
}
inline bool ChromeCompositorStateMachine_MinorState::processing_animation_worklets_for_active_tree() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.processing_animation_worklets_for_active_tree)
  return processing_animation_worklets_for_active_tree_;
}
inline void ChromeCompositorStateMachine_MinorState::set_processing_animation_worklets_for_active_tree(bool value) {
  _has_bits_[1] |= 0x00000400u;
  processing_animation_worklets_for_active_tree_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.processing_animation_worklets_for_active_tree)
}

// optional bool processing_animation_worklets_for_pending_tree = 45;
inline bool ChromeCompositorStateMachine_MinorState::has_processing_animation_worklets_for_pending_tree() const {
  return (_has_bits_[1] & 0x00000800u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_processing_animation_worklets_for_pending_tree() {
  processing_animation_worklets_for_pending_tree_ = false;
  _has_bits_[1] &= ~0x00000800u;
}
inline bool ChromeCompositorStateMachine_MinorState::processing_animation_worklets_for_pending_tree() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.processing_animation_worklets_for_pending_tree)
  return processing_animation_worklets_for_pending_tree_;
}
inline void ChromeCompositorStateMachine_MinorState::set_processing_animation_worklets_for_pending_tree(bool value) {
  _has_bits_[1] |= 0x00000800u;
  processing_animation_worklets_for_pending_tree_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.processing_animation_worklets_for_pending_tree)
}

// optional bool processing_paint_worklets_for_pending_tree = 46;
inline bool ChromeCompositorStateMachine_MinorState::has_processing_paint_worklets_for_pending_tree() const {
  return (_has_bits_[1] & 0x00001000u) != 0;
}
inline void ChromeCompositorStateMachine_MinorState::clear_processing_paint_worklets_for_pending_tree() {
  processing_paint_worklets_for_pending_tree_ = false;
  _has_bits_[1] &= ~0x00001000u;
}
inline bool ChromeCompositorStateMachine_MinorState::processing_paint_worklets_for_pending_tree() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.MinorState.processing_paint_worklets_for_pending_tree)
  return processing_paint_worklets_for_pending_tree_;
}
inline void ChromeCompositorStateMachine_MinorState::set_processing_paint_worklets_for_pending_tree(bool value) {
  _has_bits_[1] |= 0x00001000u;
  processing_paint_worklets_for_pending_tree_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.ChromeCompositorStateMachine.MinorState.processing_paint_worklets_for_pending_tree)
}

// -------------------------------------------------------------------

// ChromeCompositorStateMachine

// optional .perfetto.protos.ChromeCompositorStateMachine.MajorState major_state = 1;
inline bool ChromeCompositorStateMachine::has_major_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChromeCompositorStateMachine::clear_major_state() {
  if (major_state_ != nullptr) major_state_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::perfetto::protos::ChromeCompositorStateMachine_MajorState& ChromeCompositorStateMachine::major_state() const {
  const ::perfetto::protos::ChromeCompositorStateMachine_MajorState* p = major_state_;
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.major_state)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::ChromeCompositorStateMachine_MajorState*>(
      &::perfetto::protos::_ChromeCompositorStateMachine_MajorState_default_instance_);
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MajorState* ChromeCompositorStateMachine::release_major_state() {
  // @@protoc_insertion_point(field_release:perfetto.protos.ChromeCompositorStateMachine.major_state)
  _has_bits_[0] &= ~0x00000001u;
  ::perfetto::protos::ChromeCompositorStateMachine_MajorState* temp = major_state_;
  major_state_ = nullptr;
  return temp;
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MajorState* ChromeCompositorStateMachine::mutable_major_state() {
  _has_bits_[0] |= 0x00000001u;
  if (major_state_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::ChromeCompositorStateMachine_MajorState>(GetArenaNoVirtual());
    major_state_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeCompositorStateMachine.major_state)
  return major_state_;
}
inline void ChromeCompositorStateMachine::set_allocated_major_state(::perfetto::protos::ChromeCompositorStateMachine_MajorState* major_state) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete major_state_;
  }
  if (major_state) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      major_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, major_state, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  major_state_ = major_state;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeCompositorStateMachine.major_state)
}

// optional .perfetto.protos.ChromeCompositorStateMachine.MinorState minor_state = 2;
inline bool ChromeCompositorStateMachine::has_minor_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChromeCompositorStateMachine::clear_minor_state() {
  if (minor_state_ != nullptr) minor_state_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::perfetto::protos::ChromeCompositorStateMachine_MinorState& ChromeCompositorStateMachine::minor_state() const {
  const ::perfetto::protos::ChromeCompositorStateMachine_MinorState* p = minor_state_;
  // @@protoc_insertion_point(field_get:perfetto.protos.ChromeCompositorStateMachine.minor_state)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::ChromeCompositorStateMachine_MinorState*>(
      &::perfetto::protos::_ChromeCompositorStateMachine_MinorState_default_instance_);
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MinorState* ChromeCompositorStateMachine::release_minor_state() {
  // @@protoc_insertion_point(field_release:perfetto.protos.ChromeCompositorStateMachine.minor_state)
  _has_bits_[0] &= ~0x00000002u;
  ::perfetto::protos::ChromeCompositorStateMachine_MinorState* temp = minor_state_;
  minor_state_ = nullptr;
  return temp;
}
inline ::perfetto::protos::ChromeCompositorStateMachine_MinorState* ChromeCompositorStateMachine::mutable_minor_state() {
  _has_bits_[0] |= 0x00000002u;
  if (minor_state_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::ChromeCompositorStateMachine_MinorState>(GetArenaNoVirtual());
    minor_state_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeCompositorStateMachine.minor_state)
  return minor_state_;
}
inline void ChromeCompositorStateMachine::set_allocated_minor_state(::perfetto::protos::ChromeCompositorStateMachine_MinorState* minor_state) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete minor_state_;
  }
  if (minor_state) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      minor_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, minor_state, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  minor_state_ = minor_state;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeCompositorStateMachine.minor_state)
}

// -------------------------------------------------------------------

// BeginFrameArgs

// optional .perfetto.protos.BeginFrameArgs.BeginFrameArgsType type = 1;
inline bool BeginFrameArgs::has_type() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BeginFrameArgs::clear_type() {
  type_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::perfetto::protos::BeginFrameArgs_BeginFrameArgsType BeginFrameArgs::type() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.type)
  return static_cast< ::perfetto::protos::BeginFrameArgs_BeginFrameArgsType >(type_);
}
inline void BeginFrameArgs::set_type(::perfetto::protos::BeginFrameArgs_BeginFrameArgsType value) {
  assert(::perfetto::protos::BeginFrameArgs_BeginFrameArgsType_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  type_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.type)
}

// optional uint64 source_id = 2;
inline bool BeginFrameArgs::has_source_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BeginFrameArgs::clear_source_id() {
  source_id_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 BeginFrameArgs::source_id() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.source_id)
  return source_id_;
}
inline void BeginFrameArgs::set_source_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  source_id_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.source_id)
}

// optional uint64 sequence_number = 3;
inline bool BeginFrameArgs::has_sequence_number() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BeginFrameArgs::clear_sequence_number() {
  sequence_number_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 BeginFrameArgs::sequence_number() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.sequence_number)
  return sequence_number_;
}
inline void BeginFrameArgs::set_sequence_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000002u;
  sequence_number_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.sequence_number)
}

// optional int64 frame_time_us = 4;
inline bool BeginFrameArgs::has_frame_time_us() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BeginFrameArgs::clear_frame_time_us() {
  frame_time_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginFrameArgs::frame_time_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.frame_time_us)
  return frame_time_us_;
}
inline void BeginFrameArgs::set_frame_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  frame_time_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.frame_time_us)
}

// optional int64 deadline_us = 5;
inline bool BeginFrameArgs::has_deadline_us() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BeginFrameArgs::clear_deadline_us() {
  deadline_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginFrameArgs::deadline_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.deadline_us)
  return deadline_us_;
}
inline void BeginFrameArgs::set_deadline_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000008u;
  deadline_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.deadline_us)
}

// optional int64 interval_delta_us = 6;
inline bool BeginFrameArgs::has_interval_delta_us() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void BeginFrameArgs::clear_interval_delta_us() {
  interval_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000080u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginFrameArgs::interval_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.interval_delta_us)
  return interval_delta_us_;
}
inline void BeginFrameArgs::set_interval_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000080u;
  interval_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.interval_delta_us)
}

// optional bool on_critical_path = 7;
inline bool BeginFrameArgs::has_on_critical_path() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void BeginFrameArgs::clear_on_critical_path() {
  on_critical_path_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool BeginFrameArgs::on_critical_path() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.on_critical_path)
  return on_critical_path_;
}
inline void BeginFrameArgs::set_on_critical_path(bool value) {
  _has_bits_[0] |= 0x00000020u;
  on_critical_path_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.on_critical_path)
}

// optional bool animate_only = 8;
inline bool BeginFrameArgs::has_animate_only() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void BeginFrameArgs::clear_animate_only() {
  animate_only_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool BeginFrameArgs::animate_only() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.animate_only)
  return animate_only_;
}
inline void BeginFrameArgs::set_animate_only(bool value) {
  _has_bits_[0] |= 0x00000040u;
  animate_only_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.animate_only)
}

// optional uint64 source_location_iid = 9;
inline bool BeginFrameArgs::has_source_location_iid() const {
  return created_from_case() == kSourceLocationIid;
}
inline void BeginFrameArgs::set_has_source_location_iid() {
  _oneof_case_[0] = kSourceLocationIid;
}
inline void BeginFrameArgs::clear_source_location_iid() {
  if (has_source_location_iid()) {
    created_from_.source_location_iid_ = PROTOBUF_ULONGLONG(0);
    clear_has_created_from();
  }
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 BeginFrameArgs::source_location_iid() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.source_location_iid)
  if (has_source_location_iid()) {
    return created_from_.source_location_iid_;
  }
  return PROTOBUF_ULONGLONG(0);
}
inline void BeginFrameArgs::set_source_location_iid(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  if (!has_source_location_iid()) {
    clear_created_from();
    set_has_source_location_iid();
  }
  created_from_.source_location_iid_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.source_location_iid)
}

// optional .perfetto.protos.SourceLocation source_location = 10;
inline bool BeginFrameArgs::has_source_location() const {
  return created_from_case() == kSourceLocation;
}
inline void BeginFrameArgs::set_has_source_location() {
  _oneof_case_[0] = kSourceLocation;
}
inline ::perfetto::protos::SourceLocation* BeginFrameArgs::release_source_location() {
  // @@protoc_insertion_point(field_release:perfetto.protos.BeginFrameArgs.source_location)
  if (has_source_location()) {
    clear_has_created_from();
      ::perfetto::protos::SourceLocation* temp = created_from_.source_location_;
    created_from_.source_location_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::perfetto::protos::SourceLocation& BeginFrameArgs::source_location() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.source_location)
  return has_source_location()
      ? *created_from_.source_location_
      : *reinterpret_cast< ::perfetto::protos::SourceLocation*>(&::perfetto::protos::_SourceLocation_default_instance_);
}
inline ::perfetto::protos::SourceLocation* BeginFrameArgs::mutable_source_location() {
  if (!has_source_location()) {
    clear_created_from();
    set_has_source_location();
    created_from_.source_location_ = CreateMaybeMessage< ::perfetto::protos::SourceLocation >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.BeginFrameArgs.source_location)
  return created_from_.source_location_;
}

// optional int64 frames_throttled_since_last = 12;
inline bool BeginFrameArgs::has_frames_throttled_since_last() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void BeginFrameArgs::clear_frames_throttled_since_last() {
  frames_throttled_since_last_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginFrameArgs::frames_throttled_since_last() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameArgs.frames_throttled_since_last)
  return frames_throttled_since_last_;
}
inline void BeginFrameArgs::set_frames_throttled_since_last(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000100u;
  frames_throttled_since_last_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameArgs.frames_throttled_since_last)
}

inline bool BeginFrameArgs::has_created_from() const {
  return created_from_case() != CREATED_FROM_NOT_SET;
}
inline void BeginFrameArgs::clear_has_created_from() {
  _oneof_case_[0] = CREATED_FROM_NOT_SET;
}
inline BeginFrameArgs::CreatedFromCase BeginFrameArgs::created_from_case() const {
  return BeginFrameArgs::CreatedFromCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// BeginImplFrameArgs_TimestampsInUs

// optional int64 interval_delta = 1;
inline bool BeginImplFrameArgs_TimestampsInUs::has_interval_delta() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BeginImplFrameArgs_TimestampsInUs::clear_interval_delta() {
  interval_delta_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs_TimestampsInUs::interval_delta() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.interval_delta)
  return interval_delta_;
}
inline void BeginImplFrameArgs_TimestampsInUs::set_interval_delta(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000001u;
  interval_delta_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.interval_delta)
}

// optional int64 now_to_deadline_delta = 2;
inline bool BeginImplFrameArgs_TimestampsInUs::has_now_to_deadline_delta() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BeginImplFrameArgs_TimestampsInUs::clear_now_to_deadline_delta() {
  now_to_deadline_delta_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs_TimestampsInUs::now_to_deadline_delta() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.now_to_deadline_delta)
  return now_to_deadline_delta_;
}
inline void BeginImplFrameArgs_TimestampsInUs::set_now_to_deadline_delta(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  now_to_deadline_delta_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.now_to_deadline_delta)
}

// optional int64 frame_time_to_now_delta = 3;
inline bool BeginImplFrameArgs_TimestampsInUs::has_frame_time_to_now_delta() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BeginImplFrameArgs_TimestampsInUs::clear_frame_time_to_now_delta() {
  frame_time_to_now_delta_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs_TimestampsInUs::frame_time_to_now_delta() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.frame_time_to_now_delta)
  return frame_time_to_now_delta_;
}
inline void BeginImplFrameArgs_TimestampsInUs::set_frame_time_to_now_delta(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  frame_time_to_now_delta_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.frame_time_to_now_delta)
}

// optional int64 frame_time_to_deadline_delta = 4;
inline bool BeginImplFrameArgs_TimestampsInUs::has_frame_time_to_deadline_delta() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BeginImplFrameArgs_TimestampsInUs::clear_frame_time_to_deadline_delta() {
  frame_time_to_deadline_delta_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs_TimestampsInUs::frame_time_to_deadline_delta() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.frame_time_to_deadline_delta)
  return frame_time_to_deadline_delta_;
}
inline void BeginImplFrameArgs_TimestampsInUs::set_frame_time_to_deadline_delta(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000008u;
  frame_time_to_deadline_delta_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.frame_time_to_deadline_delta)
}

// optional int64 now = 5;
inline bool BeginImplFrameArgs_TimestampsInUs::has_now() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BeginImplFrameArgs_TimestampsInUs::clear_now() {
  now_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs_TimestampsInUs::now() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.now)
  return now_;
}
inline void BeginImplFrameArgs_TimestampsInUs::set_now(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000010u;
  now_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.now)
}

// optional int64 frame_time = 6;
inline bool BeginImplFrameArgs_TimestampsInUs::has_frame_time() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void BeginImplFrameArgs_TimestampsInUs::clear_frame_time() {
  frame_time_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs_TimestampsInUs::frame_time() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.frame_time)
  return frame_time_;
}
inline void BeginImplFrameArgs_TimestampsInUs::set_frame_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000020u;
  frame_time_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.frame_time)
}

// optional int64 deadline = 7;
inline bool BeginImplFrameArgs_TimestampsInUs::has_deadline() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void BeginImplFrameArgs_TimestampsInUs::clear_deadline() {
  deadline_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs_TimestampsInUs::deadline() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.deadline)
  return deadline_;
}
inline void BeginImplFrameArgs_TimestampsInUs::set_deadline(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000040u;
  deadline_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.TimestampsInUs.deadline)
}

// -------------------------------------------------------------------

// BeginImplFrameArgs

// optional int64 updated_at_us = 1;
inline bool BeginImplFrameArgs::has_updated_at_us() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BeginImplFrameArgs::clear_updated_at_us() {
  updated_at_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs::updated_at_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.updated_at_us)
  return updated_at_us_;
}
inline void BeginImplFrameArgs::set_updated_at_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  updated_at_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.updated_at_us)
}

// optional int64 finished_at_us = 2;
inline bool BeginImplFrameArgs::has_finished_at_us() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BeginImplFrameArgs::clear_finished_at_us() {
  finished_at_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginImplFrameArgs::finished_at_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.finished_at_us)
  return finished_at_us_;
}
inline void BeginImplFrameArgs::set_finished_at_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  finished_at_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.finished_at_us)
}

// optional .perfetto.protos.BeginImplFrameArgs.State state = 3;
inline bool BeginImplFrameArgs::has_state() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BeginImplFrameArgs::clear_state() {
  state_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::perfetto::protos::BeginImplFrameArgs_State BeginImplFrameArgs::state() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.state)
  return static_cast< ::perfetto::protos::BeginImplFrameArgs_State >(state_);
}
inline void BeginImplFrameArgs::set_state(::perfetto::protos::BeginImplFrameArgs_State value) {
  assert(::perfetto::protos::BeginImplFrameArgs_State_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  state_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginImplFrameArgs.state)
}

// optional .perfetto.protos.BeginFrameArgs current_args = 4;
inline bool BeginImplFrameArgs::has_current_args() const {
  return args_case() == kCurrentArgs;
}
inline void BeginImplFrameArgs::set_has_current_args() {
  _oneof_case_[0] = kCurrentArgs;
}
inline void BeginImplFrameArgs::clear_current_args() {
  if (has_current_args()) {
    delete args_.current_args_;
    clear_has_args();
  }
}
inline ::perfetto::protos::BeginFrameArgs* BeginImplFrameArgs::release_current_args() {
  // @@protoc_insertion_point(field_release:perfetto.protos.BeginImplFrameArgs.current_args)
  if (has_current_args()) {
    clear_has_args();
      ::perfetto::protos::BeginFrameArgs* temp = args_.current_args_;
    args_.current_args_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::perfetto::protos::BeginFrameArgs& BeginImplFrameArgs::current_args() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.current_args)
  return has_current_args()
      ? *args_.current_args_
      : *reinterpret_cast< ::perfetto::protos::BeginFrameArgs*>(&::perfetto::protos::_BeginFrameArgs_default_instance_);
}
inline ::perfetto::protos::BeginFrameArgs* BeginImplFrameArgs::mutable_current_args() {
  if (!has_current_args()) {
    clear_args();
    set_has_current_args();
    args_.current_args_ = CreateMaybeMessage< ::perfetto::protos::BeginFrameArgs >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.BeginImplFrameArgs.current_args)
  return args_.current_args_;
}

// optional .perfetto.protos.BeginFrameArgs last_args = 5;
inline bool BeginImplFrameArgs::has_last_args() const {
  return args_case() == kLastArgs;
}
inline void BeginImplFrameArgs::set_has_last_args() {
  _oneof_case_[0] = kLastArgs;
}
inline void BeginImplFrameArgs::clear_last_args() {
  if (has_last_args()) {
    delete args_.last_args_;
    clear_has_args();
  }
}
inline ::perfetto::protos::BeginFrameArgs* BeginImplFrameArgs::release_last_args() {
  // @@protoc_insertion_point(field_release:perfetto.protos.BeginImplFrameArgs.last_args)
  if (has_last_args()) {
    clear_has_args();
      ::perfetto::protos::BeginFrameArgs* temp = args_.last_args_;
    args_.last_args_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::perfetto::protos::BeginFrameArgs& BeginImplFrameArgs::last_args() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.last_args)
  return has_last_args()
      ? *args_.last_args_
      : *reinterpret_cast< ::perfetto::protos::BeginFrameArgs*>(&::perfetto::protos::_BeginFrameArgs_default_instance_);
}
inline ::perfetto::protos::BeginFrameArgs* BeginImplFrameArgs::mutable_last_args() {
  if (!has_last_args()) {
    clear_args();
    set_has_last_args();
    args_.last_args_ = CreateMaybeMessage< ::perfetto::protos::BeginFrameArgs >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.BeginImplFrameArgs.last_args)
  return args_.last_args_;
}

// optional .perfetto.protos.BeginImplFrameArgs.TimestampsInUs timestamps_in_us = 6;
inline bool BeginImplFrameArgs::has_timestamps_in_us() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BeginImplFrameArgs::clear_timestamps_in_us() {
  if (timestamps_in_us_ != nullptr) timestamps_in_us_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs& BeginImplFrameArgs::timestamps_in_us() const {
  const ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* p = timestamps_in_us_;
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginImplFrameArgs.timestamps_in_us)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs*>(
      &::perfetto::protos::_BeginImplFrameArgs_TimestampsInUs_default_instance_);
}
inline ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* BeginImplFrameArgs::release_timestamps_in_us() {
  // @@protoc_insertion_point(field_release:perfetto.protos.BeginImplFrameArgs.timestamps_in_us)
  _has_bits_[0] &= ~0x00000001u;
  ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* temp = timestamps_in_us_;
  timestamps_in_us_ = nullptr;
  return temp;
}
inline ::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* BeginImplFrameArgs::mutable_timestamps_in_us() {
  _has_bits_[0] |= 0x00000001u;
  if (timestamps_in_us_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::BeginImplFrameArgs_TimestampsInUs>(GetArenaNoVirtual());
    timestamps_in_us_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.BeginImplFrameArgs.timestamps_in_us)
  return timestamps_in_us_;
}
inline void BeginImplFrameArgs::set_allocated_timestamps_in_us(::perfetto::protos::BeginImplFrameArgs_TimestampsInUs* timestamps_in_us) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete timestamps_in_us_;
  }
  if (timestamps_in_us) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      timestamps_in_us = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, timestamps_in_us, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  timestamps_in_us_ = timestamps_in_us;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.BeginImplFrameArgs.timestamps_in_us)
}

inline bool BeginImplFrameArgs::has_args() const {
  return args_case() != ARGS_NOT_SET;
}
inline void BeginImplFrameArgs::clear_has_args() {
  _oneof_case_[0] = ARGS_NOT_SET;
}
inline BeginImplFrameArgs::ArgsCase BeginImplFrameArgs::args_case() const {
  return BeginImplFrameArgs::ArgsCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// BeginFrameObserverState

// optional int64 dropped_begin_frame_args = 1;
inline bool BeginFrameObserverState::has_dropped_begin_frame_args() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BeginFrameObserverState::clear_dropped_begin_frame_args() {
  dropped_begin_frame_args_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BeginFrameObserverState::dropped_begin_frame_args() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameObserverState.dropped_begin_frame_args)
  return dropped_begin_frame_args_;
}
inline void BeginFrameObserverState::set_dropped_begin_frame_args(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  dropped_begin_frame_args_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameObserverState.dropped_begin_frame_args)
}

// optional .perfetto.protos.BeginFrameArgs last_begin_frame_args = 2;
inline bool BeginFrameObserverState::has_last_begin_frame_args() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BeginFrameObserverState::clear_last_begin_frame_args() {
  if (last_begin_frame_args_ != nullptr) last_begin_frame_args_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::perfetto::protos::BeginFrameArgs& BeginFrameObserverState::last_begin_frame_args() const {
  const ::perfetto::protos::BeginFrameArgs* p = last_begin_frame_args_;
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameObserverState.last_begin_frame_args)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::BeginFrameArgs*>(
      &::perfetto::protos::_BeginFrameArgs_default_instance_);
}
inline ::perfetto::protos::BeginFrameArgs* BeginFrameObserverState::release_last_begin_frame_args() {
  // @@protoc_insertion_point(field_release:perfetto.protos.BeginFrameObserverState.last_begin_frame_args)
  _has_bits_[0] &= ~0x00000001u;
  ::perfetto::protos::BeginFrameArgs* temp = last_begin_frame_args_;
  last_begin_frame_args_ = nullptr;
  return temp;
}
inline ::perfetto::protos::BeginFrameArgs* BeginFrameObserverState::mutable_last_begin_frame_args() {
  _has_bits_[0] |= 0x00000001u;
  if (last_begin_frame_args_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::BeginFrameArgs>(GetArenaNoVirtual());
    last_begin_frame_args_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.BeginFrameObserverState.last_begin_frame_args)
  return last_begin_frame_args_;
}
inline void BeginFrameObserverState::set_allocated_last_begin_frame_args(::perfetto::protos::BeginFrameArgs* last_begin_frame_args) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete last_begin_frame_args_;
  }
  if (last_begin_frame_args) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      last_begin_frame_args = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, last_begin_frame_args, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  last_begin_frame_args_ = last_begin_frame_args;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.BeginFrameObserverState.last_begin_frame_args)
}

// -------------------------------------------------------------------

// BeginFrameSourceState

// optional uint32 source_id = 1;
inline bool BeginFrameSourceState::has_source_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BeginFrameSourceState::clear_source_id() {
  source_id_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 BeginFrameSourceState::source_id() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameSourceState.source_id)
  return source_id_;
}
inline void BeginFrameSourceState::set_source_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  source_id_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameSourceState.source_id)
}

// optional bool paused = 2;
inline bool BeginFrameSourceState::has_paused() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BeginFrameSourceState::clear_paused() {
  paused_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool BeginFrameSourceState::paused() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameSourceState.paused)
  return paused_;
}
inline void BeginFrameSourceState::set_paused(bool value) {
  _has_bits_[0] |= 0x00000004u;
  paused_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameSourceState.paused)
}

// optional uint32 num_observers = 3;
inline bool BeginFrameSourceState::has_num_observers() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BeginFrameSourceState::clear_num_observers() {
  num_observers_ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 BeginFrameSourceState::num_observers() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameSourceState.num_observers)
  return num_observers_;
}
inline void BeginFrameSourceState::set_num_observers(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  num_observers_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.BeginFrameSourceState.num_observers)
}

// optional .perfetto.protos.BeginFrameArgs last_begin_frame_args = 4;
inline bool BeginFrameSourceState::has_last_begin_frame_args() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BeginFrameSourceState::clear_last_begin_frame_args() {
  if (last_begin_frame_args_ != nullptr) last_begin_frame_args_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::perfetto::protos::BeginFrameArgs& BeginFrameSourceState::last_begin_frame_args() const {
  const ::perfetto::protos::BeginFrameArgs* p = last_begin_frame_args_;
  // @@protoc_insertion_point(field_get:perfetto.protos.BeginFrameSourceState.last_begin_frame_args)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::BeginFrameArgs*>(
      &::perfetto::protos::_BeginFrameArgs_default_instance_);
}
inline ::perfetto::protos::BeginFrameArgs* BeginFrameSourceState::release_last_begin_frame_args() {
  // @@protoc_insertion_point(field_release:perfetto.protos.BeginFrameSourceState.last_begin_frame_args)
  _has_bits_[0] &= ~0x00000001u;
  ::perfetto::protos::BeginFrameArgs* temp = last_begin_frame_args_;
  last_begin_frame_args_ = nullptr;
  return temp;
}
inline ::perfetto::protos::BeginFrameArgs* BeginFrameSourceState::mutable_last_begin_frame_args() {
  _has_bits_[0] |= 0x00000001u;
  if (last_begin_frame_args_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::BeginFrameArgs>(GetArenaNoVirtual());
    last_begin_frame_args_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.BeginFrameSourceState.last_begin_frame_args)
  return last_begin_frame_args_;
}
inline void BeginFrameSourceState::set_allocated_last_begin_frame_args(::perfetto::protos::BeginFrameArgs* last_begin_frame_args) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete last_begin_frame_args_;
  }
  if (last_begin_frame_args) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      last_begin_frame_args = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, last_begin_frame_args, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  last_begin_frame_args_ = last_begin_frame_args;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.BeginFrameSourceState.last_begin_frame_args)
}

// -------------------------------------------------------------------

// CompositorTimingHistory

// optional int64 begin_main_frame_queue_critical_estimate_delta_us = 1;
inline bool CompositorTimingHistory::has_begin_main_frame_queue_critical_estimate_delta_us() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CompositorTimingHistory::clear_begin_main_frame_queue_critical_estimate_delta_us() {
  begin_main_frame_queue_critical_estimate_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CompositorTimingHistory::begin_main_frame_queue_critical_estimate_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.CompositorTimingHistory.begin_main_frame_queue_critical_estimate_delta_us)
  return begin_main_frame_queue_critical_estimate_delta_us_;
}
inline void CompositorTimingHistory::set_begin_main_frame_queue_critical_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000001u;
  begin_main_frame_queue_critical_estimate_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.CompositorTimingHistory.begin_main_frame_queue_critical_estimate_delta_us)
}

// optional int64 begin_main_frame_queue_not_critical_estimate_delta_us = 2;
inline bool CompositorTimingHistory::has_begin_main_frame_queue_not_critical_estimate_delta_us() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CompositorTimingHistory::clear_begin_main_frame_queue_not_critical_estimate_delta_us() {
  begin_main_frame_queue_not_critical_estimate_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CompositorTimingHistory::begin_main_frame_queue_not_critical_estimate_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.CompositorTimingHistory.begin_main_frame_queue_not_critical_estimate_delta_us)
  return begin_main_frame_queue_not_critical_estimate_delta_us_;
}
inline void CompositorTimingHistory::set_begin_main_frame_queue_not_critical_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  begin_main_frame_queue_not_critical_estimate_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.CompositorTimingHistory.begin_main_frame_queue_not_critical_estimate_delta_us)
}

// optional int64 begin_main_frame_start_to_ready_to_commit_estimate_delta_us = 3;
inline bool CompositorTimingHistory::has_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CompositorTimingHistory::clear_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() {
  begin_main_frame_start_to_ready_to_commit_estimate_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CompositorTimingHistory::begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.CompositorTimingHistory.begin_main_frame_start_to_ready_to_commit_estimate_delta_us)
  return begin_main_frame_start_to_ready_to_commit_estimate_delta_us_;
}
inline void CompositorTimingHistory::set_begin_main_frame_start_to_ready_to_commit_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  begin_main_frame_start_to_ready_to_commit_estimate_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.CompositorTimingHistory.begin_main_frame_start_to_ready_to_commit_estimate_delta_us)
}

// optional int64 commit_to_ready_to_activate_estimate_delta_us = 4;
inline bool CompositorTimingHistory::has_commit_to_ready_to_activate_estimate_delta_us() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CompositorTimingHistory::clear_commit_to_ready_to_activate_estimate_delta_us() {
  commit_to_ready_to_activate_estimate_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CompositorTimingHistory::commit_to_ready_to_activate_estimate_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.CompositorTimingHistory.commit_to_ready_to_activate_estimate_delta_us)
  return commit_to_ready_to_activate_estimate_delta_us_;
}
inline void CompositorTimingHistory::set_commit_to_ready_to_activate_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000008u;
  commit_to_ready_to_activate_estimate_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.CompositorTimingHistory.commit_to_ready_to_activate_estimate_delta_us)
}

// optional int64 prepare_tiles_estimate_delta_us = 5;
inline bool CompositorTimingHistory::has_prepare_tiles_estimate_delta_us() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CompositorTimingHistory::clear_prepare_tiles_estimate_delta_us() {
  prepare_tiles_estimate_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CompositorTimingHistory::prepare_tiles_estimate_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.CompositorTimingHistory.prepare_tiles_estimate_delta_us)
  return prepare_tiles_estimate_delta_us_;
}
inline void CompositorTimingHistory::set_prepare_tiles_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000010u;
  prepare_tiles_estimate_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.CompositorTimingHistory.prepare_tiles_estimate_delta_us)
}

// optional int64 activate_estimate_delta_us = 6;
inline bool CompositorTimingHistory::has_activate_estimate_delta_us() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CompositorTimingHistory::clear_activate_estimate_delta_us() {
  activate_estimate_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CompositorTimingHistory::activate_estimate_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.CompositorTimingHistory.activate_estimate_delta_us)
  return activate_estimate_delta_us_;
}
inline void CompositorTimingHistory::set_activate_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000020u;
  activate_estimate_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.CompositorTimingHistory.activate_estimate_delta_us)
}

// optional int64 draw_estimate_delta_us = 7;
inline bool CompositorTimingHistory::has_draw_estimate_delta_us() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CompositorTimingHistory::clear_draw_estimate_delta_us() {
  draw_estimate_delta_us_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CompositorTimingHistory::draw_estimate_delta_us() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.CompositorTimingHistory.draw_estimate_delta_us)
  return draw_estimate_delta_us_;
}
inline void CompositorTimingHistory::set_draw_estimate_delta_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000040u;
  draw_estimate_delta_us_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.CompositorTimingHistory.draw_estimate_delta_us)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace perfetto

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::perfetto::protos::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginImplFrameState> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::ChromeCompositorStateMachine_MajorState_BeginMainFrameState> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::ChromeCompositorStateMachine_MinorState_TreePriority> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::ChromeCompositorStateMachine_MinorState_ScrollHandlerState> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::BeginFrameArgs_BeginFrameArgsType> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::BeginImplFrameArgs_State> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::ChromeCompositorSchedulerAction> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2ftrack_5fevent_2fchrome_5fcompositor_5fscheduler_5fstate_2eproto