chromium/out/Default/gen/logging/rtc_event_log/rtc_event_log.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: rtc_event_log.proto

#include "rtc_event_log.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace webrtc {
namespace rtclog {
PROTOBUF_CONSTEXPR EventStream::EventStream(
    ::_pbi::ConstantInitialized): … { … }
struct EventStreamDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventStreamDefaultTypeInternal _EventStream_default_instance_;
PROTOBUF_CONSTEXPR Event::Event(
    ::_pbi::ConstantInitialized): … { … }
struct EventDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventDefaultTypeInternal _Event_default_instance_;
PROTOBUF_CONSTEXPR RtpPacket::RtpPacket(
    ::_pbi::ConstantInitialized): … { … }
struct RtpPacketDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RtpPacketDefaultTypeInternal _RtpPacket_default_instance_;
PROTOBUF_CONSTEXPR RtcpPacket::RtcpPacket(
    ::_pbi::ConstantInitialized): … { … }
struct RtcpPacketDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RtcpPacketDefaultTypeInternal _RtcpPacket_default_instance_;
PROTOBUF_CONSTEXPR AudioPlayoutEvent::AudioPlayoutEvent(
    ::_pbi::ConstantInitialized): … { … }
struct AudioPlayoutEventDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioPlayoutEventDefaultTypeInternal _AudioPlayoutEvent_default_instance_;
PROTOBUF_CONSTEXPR LossBasedBweUpdate::LossBasedBweUpdate(
    ::_pbi::ConstantInitialized): … { … }
struct LossBasedBweUpdateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LossBasedBweUpdateDefaultTypeInternal _LossBasedBweUpdate_default_instance_;
PROTOBUF_CONSTEXPR DelayBasedBweUpdate::DelayBasedBweUpdate(
    ::_pbi::ConstantInitialized): … { … }
struct DelayBasedBweUpdateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DelayBasedBweUpdateDefaultTypeInternal _DelayBasedBweUpdate_default_instance_;
PROTOBUF_CONSTEXPR VideoReceiveConfig::VideoReceiveConfig(
    ::_pbi::ConstantInitialized): … { … }
struct VideoReceiveConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VideoReceiveConfigDefaultTypeInternal _VideoReceiveConfig_default_instance_;
PROTOBUF_CONSTEXPR DecoderConfig::DecoderConfig(
    ::_pbi::ConstantInitialized): … { … }
struct DecoderConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DecoderConfigDefaultTypeInternal _DecoderConfig_default_instance_;
PROTOBUF_CONSTEXPR RtpHeaderExtension::RtpHeaderExtension(
    ::_pbi::ConstantInitialized): … { … }
struct RtpHeaderExtensionDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RtpHeaderExtensionDefaultTypeInternal _RtpHeaderExtension_default_instance_;
PROTOBUF_CONSTEXPR RtxConfig::RtxConfig(
    ::_pbi::ConstantInitialized): … { … }
struct RtxConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RtxConfigDefaultTypeInternal _RtxConfig_default_instance_;
PROTOBUF_CONSTEXPR RtxMap::RtxMap(
    ::_pbi::ConstantInitialized): … { … }
struct RtxMapDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RtxMapDefaultTypeInternal _RtxMap_default_instance_;
PROTOBUF_CONSTEXPR VideoSendConfig::VideoSendConfig(
    ::_pbi::ConstantInitialized): … { … }
struct VideoSendConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VideoSendConfigDefaultTypeInternal _VideoSendConfig_default_instance_;
PROTOBUF_CONSTEXPR EncoderConfig::EncoderConfig(
    ::_pbi::ConstantInitialized): … { … }
struct EncoderConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncoderConfigDefaultTypeInternal _EncoderConfig_default_instance_;
PROTOBUF_CONSTEXPR AudioReceiveConfig::AudioReceiveConfig(
    ::_pbi::ConstantInitialized): … { … }
struct AudioReceiveConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioReceiveConfigDefaultTypeInternal _AudioReceiveConfig_default_instance_;
PROTOBUF_CONSTEXPR AudioSendConfig::AudioSendConfig(
    ::_pbi::ConstantInitialized): … { … }
struct AudioSendConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioSendConfigDefaultTypeInternal _AudioSendConfig_default_instance_;
PROTOBUF_CONSTEXPR AudioNetworkAdaptation::AudioNetworkAdaptation(
    ::_pbi::ConstantInitialized): … { … }
struct AudioNetworkAdaptationDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioNetworkAdaptationDefaultTypeInternal _AudioNetworkAdaptation_default_instance_;
PROTOBUF_CONSTEXPR BweProbeCluster::BweProbeCluster(
    ::_pbi::ConstantInitialized): … { … }
struct BweProbeClusterDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BweProbeClusterDefaultTypeInternal _BweProbeCluster_default_instance_;
PROTOBUF_CONSTEXPR BweProbeResult::BweProbeResult(
    ::_pbi::ConstantInitialized): … { … }
struct BweProbeResultDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BweProbeResultDefaultTypeInternal _BweProbeResult_default_instance_;
PROTOBUF_CONSTEXPR RemoteEstimate::RemoteEstimate(
    ::_pbi::ConstantInitialized): … { … }
struct RemoteEstimateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RemoteEstimateDefaultTypeInternal _RemoteEstimate_default_instance_;
PROTOBUF_CONSTEXPR AlrState::AlrState(
    ::_pbi::ConstantInitialized): … { … }
struct AlrStateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AlrStateDefaultTypeInternal _AlrState_default_instance_;
PROTOBUF_CONSTEXPR IceCandidatePairConfig::IceCandidatePairConfig(
    ::_pbi::ConstantInitialized): … { … }
struct IceCandidatePairConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IceCandidatePairConfigDefaultTypeInternal _IceCandidatePairConfig_default_instance_;
PROTOBUF_CONSTEXPR IceCandidatePairEvent::IceCandidatePairEvent(
    ::_pbi::ConstantInitialized): … { … }
struct IceCandidatePairEventDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IceCandidatePairEventDefaultTypeInternal _IceCandidatePairEvent_default_instance_;
}  // namespace rtclog
}  // namespace webrtc
namespace webrtc {
namespace rtclog {
bool Event_EventType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Event_EventType_strings[19] = …;

static const char Event_EventType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Event_EventType_entries[] = …;

static const int Event_EventType_entries_by_number[] = …;

const std::string& Event_EventType_Name(
    Event_EventType value) { … }
bool Event_EventType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Event_EventType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr Event_EventType Event::UNKNOWN_EVENT;
constexpr Event_EventType Event::LOG_START;
constexpr Event_EventType Event::LOG_END;
constexpr Event_EventType Event::RTP_EVENT;
constexpr Event_EventType Event::RTCP_EVENT;
constexpr Event_EventType Event::AUDIO_PLAYOUT_EVENT;
constexpr Event_EventType Event::LOSS_BASED_BWE_UPDATE;
constexpr Event_EventType Event::DELAY_BASED_BWE_UPDATE;
constexpr Event_EventType Event::VIDEO_RECEIVER_CONFIG_EVENT;
constexpr Event_EventType Event::VIDEO_SENDER_CONFIG_EVENT;
constexpr Event_EventType Event::AUDIO_RECEIVER_CONFIG_EVENT;
constexpr Event_EventType Event::AUDIO_SENDER_CONFIG_EVENT;
constexpr Event_EventType Event::AUDIO_NETWORK_ADAPTATION_EVENT;
constexpr Event_EventType Event::BWE_PROBE_CLUSTER_CREATED_EVENT;
constexpr Event_EventType Event::BWE_PROBE_RESULT_EVENT;
constexpr Event_EventType Event::ALR_STATE_EVENT;
constexpr Event_EventType Event::ICE_CANDIDATE_PAIR_CONFIG;
constexpr Event_EventType Event::ICE_CANDIDATE_PAIR_EVENT;
constexpr Event_EventType Event::REMOTE_ESTIMATE;
constexpr Event_EventType Event::EventType_MIN;
constexpr Event_EventType Event::EventType_MAX;
constexpr int Event::EventType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool DelayBasedBweUpdate_DetectorState_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DelayBasedBweUpdate_DetectorState_strings[3] = …;

static const char DelayBasedBweUpdate_DetectorState_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DelayBasedBweUpdate_DetectorState_entries[] = …;

static const int DelayBasedBweUpdate_DetectorState_entries_by_number[] = …;

const std::string& DelayBasedBweUpdate_DetectorState_Name(
    DelayBasedBweUpdate_DetectorState value) { … }
bool DelayBasedBweUpdate_DetectorState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DelayBasedBweUpdate_DetectorState* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::BWE_NORMAL;
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::BWE_UNDERUSING;
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::BWE_OVERUSING;
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::DetectorState_MIN;
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::DetectorState_MAX;
constexpr int DelayBasedBweUpdate::DetectorState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool VideoReceiveConfig_RtcpMode_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> VideoReceiveConfig_RtcpMode_strings[2] = …;

static const char VideoReceiveConfig_RtcpMode_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VideoReceiveConfig_RtcpMode_entries[] = …;

static const int VideoReceiveConfig_RtcpMode_entries_by_number[] = …;

const std::string& VideoReceiveConfig_RtcpMode_Name(
    VideoReceiveConfig_RtcpMode value) { … }
bool VideoReceiveConfig_RtcpMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VideoReceiveConfig_RtcpMode* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr VideoReceiveConfig_RtcpMode VideoReceiveConfig::RTCP_COMPOUND;
constexpr VideoReceiveConfig_RtcpMode VideoReceiveConfig::RTCP_REDUCEDSIZE;
constexpr VideoReceiveConfig_RtcpMode VideoReceiveConfig::RtcpMode_MIN;
constexpr VideoReceiveConfig_RtcpMode VideoReceiveConfig::RtcpMode_MAX;
constexpr int VideoReceiveConfig::RtcpMode_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool BweProbeResult_ResultType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BweProbeResult_ResultType_strings[4] = …;

static const char BweProbeResult_ResultType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BweProbeResult_ResultType_entries[] = …;

static const int BweProbeResult_ResultType_entries_by_number[] = …;

const std::string& BweProbeResult_ResultType_Name(
    BweProbeResult_ResultType value) { … }
bool BweProbeResult_ResultType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BweProbeResult_ResultType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr BweProbeResult_ResultType BweProbeResult::SUCCESS;
constexpr BweProbeResult_ResultType BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL;
constexpr BweProbeResult_ResultType BweProbeResult::INVALID_SEND_RECEIVE_RATIO;
constexpr BweProbeResult_ResultType BweProbeResult::TIMEOUT;
constexpr BweProbeResult_ResultType BweProbeResult::ResultType_MIN;
constexpr BweProbeResult_ResultType BweProbeResult::ResultType_MAX;
constexpr int BweProbeResult::ResultType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_IceCandidatePairConfigType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_IceCandidatePairConfigType_strings[4] = …;

static const char IceCandidatePairConfig_IceCandidatePairConfigType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_IceCandidatePairConfigType_entries[] = …;

static const int IceCandidatePairConfig_IceCandidatePairConfigType_entries_by_number[] = …;

const std::string& IceCandidatePairConfig_IceCandidatePairConfigType_Name(
    IceCandidatePairConfig_IceCandidatePairConfigType value) { … }
bool IceCandidatePairConfig_IceCandidatePairConfigType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_IceCandidatePairConfigType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::ADDED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::UPDATED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::DESTROYED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::SELECTED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::IceCandidatePairConfigType_MIN;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::IceCandidatePairConfigType_MAX;
constexpr int IceCandidatePairConfig::IceCandidatePairConfigType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_IceCandidateType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_IceCandidateType_strings[5] = …;

static const char IceCandidatePairConfig_IceCandidateType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_IceCandidateType_entries[] = …;

static const int IceCandidatePairConfig_IceCandidateType_entries_by_number[] = …;

const std::string& IceCandidatePairConfig_IceCandidateType_Name(
    IceCandidatePairConfig_IceCandidateType value) { … }
bool IceCandidatePairConfig_IceCandidateType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_IceCandidateType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::LOCAL;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::STUN;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::PRFLX;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::RELAY;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::UNKNOWN_CANDIDATE_TYPE;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::IceCandidateType_MIN;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::IceCandidateType_MAX;
constexpr int IceCandidatePairConfig::IceCandidateType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_Protocol_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_Protocol_strings[5] = …;

static const char IceCandidatePairConfig_Protocol_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_Protocol_entries[] = …;

static const int IceCandidatePairConfig_Protocol_entries_by_number[] = …;

const std::string& IceCandidatePairConfig_Protocol_Name(
    IceCandidatePairConfig_Protocol value) { … }
bool IceCandidatePairConfig_Protocol_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_Protocol* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::UDP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::TCP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::SSLTCP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::TLS;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::UNKNOWN_PROTOCOL;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::Protocol_MIN;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::Protocol_MAX;
constexpr int IceCandidatePairConfig::Protocol_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_AddressFamily_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_AddressFamily_strings[3] = …;

static const char IceCandidatePairConfig_AddressFamily_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_AddressFamily_entries[] = …;

static const int IceCandidatePairConfig_AddressFamily_entries_by_number[] = …;

const std::string& IceCandidatePairConfig_AddressFamily_Name(
    IceCandidatePairConfig_AddressFamily value) { … }
bool IceCandidatePairConfig_AddressFamily_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_AddressFamily* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::IPV4;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::IPV6;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::UNKNOWN_ADDRESS_FAMILY;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::AddressFamily_MIN;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::AddressFamily_MAX;
constexpr int IceCandidatePairConfig::AddressFamily_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairConfig_NetworkType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_NetworkType_strings[6] = …;

static const char IceCandidatePairConfig_NetworkType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_NetworkType_entries[] = …;

static const int IceCandidatePairConfig_NetworkType_entries_by_number[] = …;

const std::string& IceCandidatePairConfig_NetworkType_Name(
    IceCandidatePairConfig_NetworkType value) { … }
bool IceCandidatePairConfig_NetworkType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairConfig_NetworkType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::ETHERNET;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::LOOPBACK;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::WIFI;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::VPN;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::CELLULAR;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::UNKNOWN_NETWORK_TYPE;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::NetworkType_MIN;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::NetworkType_MAX;
constexpr int IceCandidatePairConfig::NetworkType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IceCandidatePairEvent_IceCandidatePairEventType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairEvent_IceCandidatePairEventType_strings[4] = …;

static const char IceCandidatePairEvent_IceCandidatePairEventType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairEvent_IceCandidatePairEventType_entries[] = …;

static const int IceCandidatePairEvent_IceCandidatePairEventType_entries_by_number[] = …;

const std::string& IceCandidatePairEvent_IceCandidatePairEventType_Name(
    IceCandidatePairEvent_IceCandidatePairEventType value) { … }
bool IceCandidatePairEvent_IceCandidatePairEventType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IceCandidatePairEvent_IceCandidatePairEventType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_SENT;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RECEIVED;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RESPONSE_SENT;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RESPONSE_RECEIVED;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::IceCandidatePairEventType_MIN;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::IceCandidatePairEventType_MAX;
constexpr int IceCandidatePairEvent::IceCandidatePairEventType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool MediaType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MediaType_strings[4] = …;

static const char MediaType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MediaType_entries[] = …;

static const int MediaType_entries_by_number[] = …;

const std::string& MediaType_Name(
    MediaType value) { … }
bool MediaType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediaType* value) { … }

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

class EventStream::_Internal { … };

EventStream::EventStream(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
EventStream::EventStream(const EventStream& from)
  : … { … }

inline void EventStream::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

EventStream::~EventStream() { … }

inline void EventStream::SharedDtor() { … }

void EventStream::SetCachedSize(int size) const { … }

void EventStream::Clear() { … }

const char* EventStream::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* EventStream::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t EventStream::ByteSizeLong() const { … }

void EventStream::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void EventStream::MergeFrom(const EventStream& from) { … }

void EventStream::CopyFrom(const EventStream& from) { … }

bool EventStream::IsInitialized() const { … }

void EventStream::InternalSwap(EventStream* other) { … }

std::string EventStream::GetTypeName() const { … }


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

class Event::_Internal { … };

const ::webrtc::rtclog::RtpPacket&
Event::_Internal::rtp_packet(const Event* msg) { … }
const ::webrtc::rtclog::RtcpPacket&
Event::_Internal::rtcp_packet(const Event* msg) { … }
const ::webrtc::rtclog::AudioPlayoutEvent&
Event::_Internal::audio_playout_event(const Event* msg) { … }
const ::webrtc::rtclog::LossBasedBweUpdate&
Event::_Internal::loss_based_bwe_update(const Event* msg) { … }
const ::webrtc::rtclog::DelayBasedBweUpdate&
Event::_Internal::delay_based_bwe_update(const Event* msg) { … }
const ::webrtc::rtclog::VideoReceiveConfig&
Event::_Internal::video_receiver_config(const Event* msg) { … }
const ::webrtc::rtclog::VideoSendConfig&
Event::_Internal::video_sender_config(const Event* msg) { … }
const ::webrtc::rtclog::AudioReceiveConfig&
Event::_Internal::audio_receiver_config(const Event* msg) { … }
const ::webrtc::rtclog::AudioSendConfig&
Event::_Internal::audio_sender_config(const Event* msg) { … }
const ::webrtc::rtclog::AudioNetworkAdaptation&
Event::_Internal::audio_network_adaptation(const Event* msg) { … }
const ::webrtc::rtclog::BweProbeCluster&
Event::_Internal::probe_cluster(const Event* msg) { … }
const ::webrtc::rtclog::BweProbeResult&
Event::_Internal::probe_result(const Event* msg) { … }
const ::webrtc::rtclog::AlrState&
Event::_Internal::alr_state(const Event* msg) { … }
const ::webrtc::rtclog::IceCandidatePairConfig&
Event::_Internal::ice_candidate_pair_config(const Event* msg) { … }
const ::webrtc::rtclog::IceCandidatePairEvent&
Event::_Internal::ice_candidate_pair_event(const Event* msg) { … }
const ::webrtc::rtclog::RemoteEstimate&
Event::_Internal::remote_estimate(const Event* msg) { … }
void Event::set_allocated_rtp_packet(::webrtc::rtclog::RtpPacket* rtp_packet) { … }
void Event::set_allocated_rtcp_packet(::webrtc::rtclog::RtcpPacket* rtcp_packet) { … }
void Event::set_allocated_audio_playout_event(::webrtc::rtclog::AudioPlayoutEvent* audio_playout_event) { … }
void Event::set_allocated_loss_based_bwe_update(::webrtc::rtclog::LossBasedBweUpdate* loss_based_bwe_update) { … }
void Event::set_allocated_delay_based_bwe_update(::webrtc::rtclog::DelayBasedBweUpdate* delay_based_bwe_update) { … }
void Event::set_allocated_video_receiver_config(::webrtc::rtclog::VideoReceiveConfig* video_receiver_config) { … }
void Event::set_allocated_video_sender_config(::webrtc::rtclog::VideoSendConfig* video_sender_config) { … }
void Event::set_allocated_audio_receiver_config(::webrtc::rtclog::AudioReceiveConfig* audio_receiver_config) { … }
void Event::set_allocated_audio_sender_config(::webrtc::rtclog::AudioSendConfig* audio_sender_config) { … }
void Event::set_allocated_audio_network_adaptation(::webrtc::rtclog::AudioNetworkAdaptation* audio_network_adaptation) { … }
void Event::set_allocated_probe_cluster(::webrtc::rtclog::BweProbeCluster* probe_cluster) { … }
void Event::set_allocated_probe_result(::webrtc::rtclog::BweProbeResult* probe_result) { … }
void Event::set_allocated_alr_state(::webrtc::rtclog::AlrState* alr_state) { … }
void Event::set_allocated_ice_candidate_pair_config(::webrtc::rtclog::IceCandidatePairConfig* ice_candidate_pair_config) { … }
void Event::set_allocated_ice_candidate_pair_event(::webrtc::rtclog::IceCandidatePairEvent* ice_candidate_pair_event) { … }
void Event::set_allocated_remote_estimate(::webrtc::rtclog::RemoteEstimate* remote_estimate) { … }
Event::Event(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
Event::Event(const Event& from)
  : … { … }

inline void Event::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

Event::~Event() { … }

inline void Event::SharedDtor() { … }

void Event::SetCachedSize(int size) const { … }

void Event::clear_subtype() { … }


void Event::Clear() { … }

const char* Event::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* Event::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t Event::ByteSizeLong() const { … }

void Event::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void Event::MergeFrom(const Event& from) { … }

void Event::CopyFrom(const Event& from) { … }

bool Event::IsInitialized() const { … }

void Event::InternalSwap(Event* other) { … }

std::string Event::GetTypeName() const { … }


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

class RtpPacket::_Internal { … };

RtpPacket::RtpPacket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RtpPacket::RtpPacket(const RtpPacket& from)
  : … { … }

inline void RtpPacket::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

RtpPacket::~RtpPacket() { … }

inline void RtpPacket::SharedDtor() { … }

void RtpPacket::SetCachedSize(int size) const { … }

void RtpPacket::Clear() { … }

const char* RtpPacket::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* RtpPacket::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t RtpPacket::ByteSizeLong() const { … }

void RtpPacket::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void RtpPacket::MergeFrom(const RtpPacket& from) { … }

void RtpPacket::CopyFrom(const RtpPacket& from) { … }

bool RtpPacket::IsInitialized() const { … }

void RtpPacket::InternalSwap(RtpPacket* other) { … }

std::string RtpPacket::GetTypeName() const { … }


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

class RtcpPacket::_Internal { … };

RtcpPacket::RtcpPacket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RtcpPacket::RtcpPacket(const RtcpPacket& from)
  : … { … }

inline void RtcpPacket::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

RtcpPacket::~RtcpPacket() { … }

inline void RtcpPacket::SharedDtor() { … }

void RtcpPacket::SetCachedSize(int size) const { … }

void RtcpPacket::Clear() { … }

const char* RtcpPacket::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* RtcpPacket::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t RtcpPacket::ByteSizeLong() const { … }

void RtcpPacket::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void RtcpPacket::MergeFrom(const RtcpPacket& from) { … }

void RtcpPacket::CopyFrom(const RtcpPacket& from) { … }

bool RtcpPacket::IsInitialized() const { … }

void RtcpPacket::InternalSwap(RtcpPacket* other) { … }

std::string RtcpPacket::GetTypeName() const { … }


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

class AudioPlayoutEvent::_Internal { … };

AudioPlayoutEvent::AudioPlayoutEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AudioPlayoutEvent::AudioPlayoutEvent(const AudioPlayoutEvent& from)
  : … { … }

inline void AudioPlayoutEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AudioPlayoutEvent::~AudioPlayoutEvent() { … }

inline void AudioPlayoutEvent::SharedDtor() { … }

void AudioPlayoutEvent::SetCachedSize(int size) const { … }

void AudioPlayoutEvent::Clear() { … }

const char* AudioPlayoutEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AudioPlayoutEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AudioPlayoutEvent::ByteSizeLong() const { … }

void AudioPlayoutEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AudioPlayoutEvent::MergeFrom(const AudioPlayoutEvent& from) { … }

void AudioPlayoutEvent::CopyFrom(const AudioPlayoutEvent& from) { … }

bool AudioPlayoutEvent::IsInitialized() const { … }

void AudioPlayoutEvent::InternalSwap(AudioPlayoutEvent* other) { … }

std::string AudioPlayoutEvent::GetTypeName() const { … }


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

class LossBasedBweUpdate::_Internal { … };

LossBasedBweUpdate::LossBasedBweUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
LossBasedBweUpdate::LossBasedBweUpdate(const LossBasedBweUpdate& from)
  : … { … }

inline void LossBasedBweUpdate::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

LossBasedBweUpdate::~LossBasedBweUpdate() { … }

inline void LossBasedBweUpdate::SharedDtor() { … }

void LossBasedBweUpdate::SetCachedSize(int size) const { … }

void LossBasedBweUpdate::Clear() { … }

const char* LossBasedBweUpdate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* LossBasedBweUpdate::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t LossBasedBweUpdate::ByteSizeLong() const { … }

void LossBasedBweUpdate::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void LossBasedBweUpdate::MergeFrom(const LossBasedBweUpdate& from) { … }

void LossBasedBweUpdate::CopyFrom(const LossBasedBweUpdate& from) { … }

bool LossBasedBweUpdate::IsInitialized() const { … }

void LossBasedBweUpdate::InternalSwap(LossBasedBweUpdate* other) { … }

std::string LossBasedBweUpdate::GetTypeName() const { … }


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

class DelayBasedBweUpdate::_Internal { … };

DelayBasedBweUpdate::DelayBasedBweUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
DelayBasedBweUpdate::DelayBasedBweUpdate(const DelayBasedBweUpdate& from)
  : … { … }

inline void DelayBasedBweUpdate::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

DelayBasedBweUpdate::~DelayBasedBweUpdate() { … }

inline void DelayBasedBweUpdate::SharedDtor() { … }

void DelayBasedBweUpdate::SetCachedSize(int size) const { … }

void DelayBasedBweUpdate::Clear() { … }

const char* DelayBasedBweUpdate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* DelayBasedBweUpdate::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t DelayBasedBweUpdate::ByteSizeLong() const { … }

void DelayBasedBweUpdate::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void DelayBasedBweUpdate::MergeFrom(const DelayBasedBweUpdate& from) { … }

void DelayBasedBweUpdate::CopyFrom(const DelayBasedBweUpdate& from) { … }

bool DelayBasedBweUpdate::IsInitialized() const { … }

void DelayBasedBweUpdate::InternalSwap(DelayBasedBweUpdate* other) { … }

std::string DelayBasedBweUpdate::GetTypeName() const { … }


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

class VideoReceiveConfig::_Internal { … };

VideoReceiveConfig::VideoReceiveConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
VideoReceiveConfig::VideoReceiveConfig(const VideoReceiveConfig& from)
  : … { … }

inline void VideoReceiveConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

VideoReceiveConfig::~VideoReceiveConfig() { … }

inline void VideoReceiveConfig::SharedDtor() { … }

void VideoReceiveConfig::SetCachedSize(int size) const { … }

void VideoReceiveConfig::Clear() { … }

const char* VideoReceiveConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* VideoReceiveConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t VideoReceiveConfig::ByteSizeLong() const { … }

void VideoReceiveConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void VideoReceiveConfig::MergeFrom(const VideoReceiveConfig& from) { … }

void VideoReceiveConfig::CopyFrom(const VideoReceiveConfig& from) { … }

bool VideoReceiveConfig::IsInitialized() const { … }

void VideoReceiveConfig::InternalSwap(VideoReceiveConfig* other) { … }

std::string VideoReceiveConfig::GetTypeName() const { … }


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

class DecoderConfig::_Internal { … };

DecoderConfig::DecoderConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
DecoderConfig::DecoderConfig(const DecoderConfig& from)
  : … { … }

inline void DecoderConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

DecoderConfig::~DecoderConfig() { … }

inline void DecoderConfig::SharedDtor() { … }

void DecoderConfig::SetCachedSize(int size) const { … }

void DecoderConfig::Clear() { … }

const char* DecoderConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* DecoderConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t DecoderConfig::ByteSizeLong() const { … }

void DecoderConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void DecoderConfig::MergeFrom(const DecoderConfig& from) { … }

void DecoderConfig::CopyFrom(const DecoderConfig& from) { … }

bool DecoderConfig::IsInitialized() const { … }

void DecoderConfig::InternalSwap(DecoderConfig* other) { … }

std::string DecoderConfig::GetTypeName() const { … }


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

class RtpHeaderExtension::_Internal { … };

RtpHeaderExtension::RtpHeaderExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RtpHeaderExtension::RtpHeaderExtension(const RtpHeaderExtension& from)
  : … { … }

inline void RtpHeaderExtension::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

RtpHeaderExtension::~RtpHeaderExtension() { … }

inline void RtpHeaderExtension::SharedDtor() { … }

void RtpHeaderExtension::SetCachedSize(int size) const { … }

void RtpHeaderExtension::Clear() { … }

const char* RtpHeaderExtension::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* RtpHeaderExtension::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t RtpHeaderExtension::ByteSizeLong() const { … }

void RtpHeaderExtension::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void RtpHeaderExtension::MergeFrom(const RtpHeaderExtension& from) { … }

void RtpHeaderExtension::CopyFrom(const RtpHeaderExtension& from) { … }

bool RtpHeaderExtension::IsInitialized() const { … }

void RtpHeaderExtension::InternalSwap(RtpHeaderExtension* other) { … }

std::string RtpHeaderExtension::GetTypeName() const { … }


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

class RtxConfig::_Internal { … };

RtxConfig::RtxConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RtxConfig::RtxConfig(const RtxConfig& from)
  : … { … }

inline void RtxConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

RtxConfig::~RtxConfig() { … }

inline void RtxConfig::SharedDtor() { … }

void RtxConfig::SetCachedSize(int size) const { … }

void RtxConfig::Clear() { … }

const char* RtxConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* RtxConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t RtxConfig::ByteSizeLong() const { … }

void RtxConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void RtxConfig::MergeFrom(const RtxConfig& from) { … }

void RtxConfig::CopyFrom(const RtxConfig& from) { … }

bool RtxConfig::IsInitialized() const { … }

void RtxConfig::InternalSwap(RtxConfig* other) { … }

std::string RtxConfig::GetTypeName() const { … }


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

class RtxMap::_Internal { … };

const ::webrtc::rtclog::RtxConfig&
RtxMap::_Internal::config(const RtxMap* msg) { … }
RtxMap::RtxMap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RtxMap::RtxMap(const RtxMap& from)
  : … { … }

inline void RtxMap::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

RtxMap::~RtxMap() { … }

inline void RtxMap::SharedDtor() { … }

void RtxMap::SetCachedSize(int size) const { … }

void RtxMap::Clear() { … }

const char* RtxMap::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* RtxMap::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t RtxMap::ByteSizeLong() const { … }

void RtxMap::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void RtxMap::MergeFrom(const RtxMap& from) { … }

void RtxMap::CopyFrom(const RtxMap& from) { … }

bool RtxMap::IsInitialized() const { … }

void RtxMap::InternalSwap(RtxMap* other) { … }

std::string RtxMap::GetTypeName() const { … }


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

class VideoSendConfig::_Internal { … };

const ::webrtc::rtclog::EncoderConfig&
VideoSendConfig::_Internal::encoder(const VideoSendConfig* msg) { … }
VideoSendConfig::VideoSendConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
VideoSendConfig::VideoSendConfig(const VideoSendConfig& from)
  : … { … }

inline void VideoSendConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

VideoSendConfig::~VideoSendConfig() { … }

inline void VideoSendConfig::SharedDtor() { … }

void VideoSendConfig::SetCachedSize(int size) const { … }

void VideoSendConfig::Clear() { … }

const char* VideoSendConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* VideoSendConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t VideoSendConfig::ByteSizeLong() const { … }

void VideoSendConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void VideoSendConfig::MergeFrom(const VideoSendConfig& from) { … }

void VideoSendConfig::CopyFrom(const VideoSendConfig& from) { … }

bool VideoSendConfig::IsInitialized() const { … }

void VideoSendConfig::InternalSwap(VideoSendConfig* other) { … }

std::string VideoSendConfig::GetTypeName() const { … }


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

class EncoderConfig::_Internal { … };

EncoderConfig::EncoderConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
EncoderConfig::EncoderConfig(const EncoderConfig& from)
  : … { … }

inline void EncoderConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

EncoderConfig::~EncoderConfig() { … }

inline void EncoderConfig::SharedDtor() { … }

void EncoderConfig::SetCachedSize(int size) const { … }

void EncoderConfig::Clear() { … }

const char* EncoderConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* EncoderConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t EncoderConfig::ByteSizeLong() const { … }

void EncoderConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void EncoderConfig::MergeFrom(const EncoderConfig& from) { … }

void EncoderConfig::CopyFrom(const EncoderConfig& from) { … }

bool EncoderConfig::IsInitialized() const { … }

void EncoderConfig::InternalSwap(EncoderConfig* other) { … }

std::string EncoderConfig::GetTypeName() const { … }


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

class AudioReceiveConfig::_Internal { … };

AudioReceiveConfig::AudioReceiveConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AudioReceiveConfig::AudioReceiveConfig(const AudioReceiveConfig& from)
  : … { … }

inline void AudioReceiveConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AudioReceiveConfig::~AudioReceiveConfig() { … }

inline void AudioReceiveConfig::SharedDtor() { … }

void AudioReceiveConfig::SetCachedSize(int size) const { … }

void AudioReceiveConfig::Clear() { … }

const char* AudioReceiveConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AudioReceiveConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AudioReceiveConfig::ByteSizeLong() const { … }

void AudioReceiveConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AudioReceiveConfig::MergeFrom(const AudioReceiveConfig& from) { … }

void AudioReceiveConfig::CopyFrom(const AudioReceiveConfig& from) { … }

bool AudioReceiveConfig::IsInitialized() const { … }

void AudioReceiveConfig::InternalSwap(AudioReceiveConfig* other) { … }

std::string AudioReceiveConfig::GetTypeName() const { … }


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

class AudioSendConfig::_Internal { … };

AudioSendConfig::AudioSendConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AudioSendConfig::AudioSendConfig(const AudioSendConfig& from)
  : … { … }

inline void AudioSendConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AudioSendConfig::~AudioSendConfig() { … }

inline void AudioSendConfig::SharedDtor() { … }

void AudioSendConfig::SetCachedSize(int size) const { … }

void AudioSendConfig::Clear() { … }

const char* AudioSendConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AudioSendConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AudioSendConfig::ByteSizeLong() const { … }

void AudioSendConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AudioSendConfig::MergeFrom(const AudioSendConfig& from) { … }

void AudioSendConfig::CopyFrom(const AudioSendConfig& from) { … }

bool AudioSendConfig::IsInitialized() const { … }

void AudioSendConfig::InternalSwap(AudioSendConfig* other) { … }

std::string AudioSendConfig::GetTypeName() const { … }


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

class AudioNetworkAdaptation::_Internal { … };

AudioNetworkAdaptation::AudioNetworkAdaptation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AudioNetworkAdaptation::AudioNetworkAdaptation(const AudioNetworkAdaptation& from)
  : … { … }

inline void AudioNetworkAdaptation::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AudioNetworkAdaptation::~AudioNetworkAdaptation() { … }

inline void AudioNetworkAdaptation::SharedDtor() { … }

void AudioNetworkAdaptation::SetCachedSize(int size) const { … }

void AudioNetworkAdaptation::Clear() { … }

const char* AudioNetworkAdaptation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AudioNetworkAdaptation::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AudioNetworkAdaptation::ByteSizeLong() const { … }

void AudioNetworkAdaptation::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AudioNetworkAdaptation::MergeFrom(const AudioNetworkAdaptation& from) { … }

void AudioNetworkAdaptation::CopyFrom(const AudioNetworkAdaptation& from) { … }

bool AudioNetworkAdaptation::IsInitialized() const { … }

void AudioNetworkAdaptation::InternalSwap(AudioNetworkAdaptation* other) { … }

std::string AudioNetworkAdaptation::GetTypeName() const { … }


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

class BweProbeCluster::_Internal { … };

BweProbeCluster::BweProbeCluster(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
BweProbeCluster::BweProbeCluster(const BweProbeCluster& from)
  : … { … }

inline void BweProbeCluster::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

BweProbeCluster::~BweProbeCluster() { … }

inline void BweProbeCluster::SharedDtor() { … }

void BweProbeCluster::SetCachedSize(int size) const { … }

void BweProbeCluster::Clear() { … }

const char* BweProbeCluster::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* BweProbeCluster::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t BweProbeCluster::ByteSizeLong() const { … }

void BweProbeCluster::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void BweProbeCluster::MergeFrom(const BweProbeCluster& from) { … }

void BweProbeCluster::CopyFrom(const BweProbeCluster& from) { … }

bool BweProbeCluster::IsInitialized() const { … }

void BweProbeCluster::InternalSwap(BweProbeCluster* other) { … }

std::string BweProbeCluster::GetTypeName() const { … }


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

class BweProbeResult::_Internal { … };

BweProbeResult::BweProbeResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
BweProbeResult::BweProbeResult(const BweProbeResult& from)
  : … { … }

inline void BweProbeResult::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

BweProbeResult::~BweProbeResult() { … }

inline void BweProbeResult::SharedDtor() { … }

void BweProbeResult::SetCachedSize(int size) const { … }

void BweProbeResult::Clear() { … }

const char* BweProbeResult::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* BweProbeResult::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t BweProbeResult::ByteSizeLong() const { … }

void BweProbeResult::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void BweProbeResult::MergeFrom(const BweProbeResult& from) { … }

void BweProbeResult::CopyFrom(const BweProbeResult& from) { … }

bool BweProbeResult::IsInitialized() const { … }

void BweProbeResult::InternalSwap(BweProbeResult* other) { … }

std::string BweProbeResult::GetTypeName() const { … }


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

class RemoteEstimate::_Internal { … };

RemoteEstimate::RemoteEstimate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
RemoteEstimate::RemoteEstimate(const RemoteEstimate& from)
  : … { … }

inline void RemoteEstimate::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

RemoteEstimate::~RemoteEstimate() { … }

inline void RemoteEstimate::SharedDtor() { … }

void RemoteEstimate::SetCachedSize(int size) const { … }

void RemoteEstimate::Clear() { … }

const char* RemoteEstimate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* RemoteEstimate::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t RemoteEstimate::ByteSizeLong() const { … }

void RemoteEstimate::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void RemoteEstimate::MergeFrom(const RemoteEstimate& from) { … }

void RemoteEstimate::CopyFrom(const RemoteEstimate& from) { … }

bool RemoteEstimate::IsInitialized() const { … }

void RemoteEstimate::InternalSwap(RemoteEstimate* other) { … }

std::string RemoteEstimate::GetTypeName() const { … }


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

class AlrState::_Internal { … };

AlrState::AlrState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AlrState::AlrState(const AlrState& from)
  : … { … }

inline void AlrState::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AlrState::~AlrState() { … }

inline void AlrState::SharedDtor() { … }

void AlrState::SetCachedSize(int size) const { … }

void AlrState::Clear() { … }

const char* AlrState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AlrState::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AlrState::ByteSizeLong() const { … }

void AlrState::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AlrState::MergeFrom(const AlrState& from) { … }

void AlrState::CopyFrom(const AlrState& from) { … }

bool AlrState::IsInitialized() const { … }

void AlrState::InternalSwap(AlrState* other) { … }

std::string AlrState::GetTypeName() const { … }


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

class IceCandidatePairConfig::_Internal { … };

IceCandidatePairConfig::IceCandidatePairConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
IceCandidatePairConfig::IceCandidatePairConfig(const IceCandidatePairConfig& from)
  : … { … }

inline void IceCandidatePairConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

IceCandidatePairConfig::~IceCandidatePairConfig() { … }

inline void IceCandidatePairConfig::SharedDtor() { … }

void IceCandidatePairConfig::SetCachedSize(int size) const { … }

void IceCandidatePairConfig::Clear() { … }

const char* IceCandidatePairConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* IceCandidatePairConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t IceCandidatePairConfig::ByteSizeLong() const { … }

void IceCandidatePairConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void IceCandidatePairConfig::MergeFrom(const IceCandidatePairConfig& from) { … }

void IceCandidatePairConfig::CopyFrom(const IceCandidatePairConfig& from) { … }

bool IceCandidatePairConfig::IsInitialized() const { … }

void IceCandidatePairConfig::InternalSwap(IceCandidatePairConfig* other) { … }

std::string IceCandidatePairConfig::GetTypeName() const { … }


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

class IceCandidatePairEvent::_Internal { … };

IceCandidatePairEvent::IceCandidatePairEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
IceCandidatePairEvent::IceCandidatePairEvent(const IceCandidatePairEvent& from)
  : … { … }

inline void IceCandidatePairEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

IceCandidatePairEvent::~IceCandidatePairEvent() { … }

inline void IceCandidatePairEvent::SharedDtor() { … }

void IceCandidatePairEvent::SetCachedSize(int size) const { … }

void IceCandidatePairEvent::Clear() { … }

const char* IceCandidatePairEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* IceCandidatePairEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t IceCandidatePairEvent::ByteSizeLong() const { … }

void IceCandidatePairEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void IceCandidatePairEvent::MergeFrom(const IceCandidatePairEvent& from) { … }

void IceCandidatePairEvent::CopyFrom(const IceCandidatePairEvent& from) { … }

bool IceCandidatePairEvent::IsInitialized() const { … }

void IceCandidatePairEvent::InternalSwap(IceCandidatePairEvent* other) { … }

std::string IceCandidatePairEvent::GetTypeName() const { … }


// @@protoc_insertion_point(namespace_scope)
}  // namespace rtclog
}  // namespace webrtc
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::EventStream*
Arena::CreateMaybeMessage< ::webrtc::rtclog::EventStream >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::Event*
Arena::CreateMaybeMessage< ::webrtc::rtclog::Event >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtpPacket*
Arena::CreateMaybeMessage< ::webrtc::rtclog::RtpPacket >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtcpPacket*
Arena::CreateMaybeMessage< ::webrtc::rtclog::RtcpPacket >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AudioPlayoutEvent*
Arena::CreateMaybeMessage< ::webrtc::rtclog::AudioPlayoutEvent >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::LossBasedBweUpdate*
Arena::CreateMaybeMessage< ::webrtc::rtclog::LossBasedBweUpdate >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::DelayBasedBweUpdate*
Arena::CreateMaybeMessage< ::webrtc::rtclog::DelayBasedBweUpdate >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::VideoReceiveConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog::VideoReceiveConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::DecoderConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog::DecoderConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtpHeaderExtension*
Arena::CreateMaybeMessage< ::webrtc::rtclog::RtpHeaderExtension >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtxConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog::RtxConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtxMap*
Arena::CreateMaybeMessage< ::webrtc::rtclog::RtxMap >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::VideoSendConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog::VideoSendConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::EncoderConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog::EncoderConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AudioReceiveConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog::AudioReceiveConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AudioSendConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog::AudioSendConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AudioNetworkAdaptation*
Arena::CreateMaybeMessage< ::webrtc::rtclog::AudioNetworkAdaptation >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::BweProbeCluster*
Arena::CreateMaybeMessage< ::webrtc::rtclog::BweProbeCluster >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::BweProbeResult*
Arena::CreateMaybeMessage< ::webrtc::rtclog::BweProbeResult >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RemoteEstimate*
Arena::CreateMaybeMessage< ::webrtc::rtclog::RemoteEstimate >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AlrState*
Arena::CreateMaybeMessage< ::webrtc::rtclog::AlrState >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::IceCandidatePairConfig*
Arena::CreateMaybeMessage< ::webrtc::rtclog::IceCandidatePairConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::IceCandidatePairEvent*
Arena::CreateMaybeMessage< ::webrtc::rtclog::IceCandidatePairEvent >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>